bs3-cpu-generated-1-data.py@ 105684

Last change on this file since 105684 was 103217, checked in by vboxsync, 10 months ago
ValidationKit/bootsectors/bs3-cpu-generated-1-data.py: Fix instruction hint identifier for instructions which are invalid in long mode. Fixes the aaa and bound instruction testcases in lm64 mode, bugref:9898
Property svn:eol-style set to `LF` Property svn:executable set to ``* Property svn:keywords set to `Author Date Id Revision`
File size: 25.1 KB

Line
1	#!/usr/bin/env python
2	# -- coding: utf-8 --
3	# $Id: bs3-cpu-generated-1-data.py 103217 2024-02-06 08:45:24Z vboxsync $
4	# pylint: disable=invalid-name
5
6	"""
7	Generates testcases from @optest specifications in IEM.
8	"""
9
10	from __future__ import print_function;
11
12	__copyright__ = \
13	"""
14	Copyright (C) 2017-2023 Oracle and/or its affiliates.
15
16	This file is part of VirtualBox base platform packages, as
17	available from https://www.virtualbox.org.
18
19	This program is free software; you can redistribute it and/or
20	modify it under the terms of the GNU General Public License
21	as published by the Free Software Foundation, in version 3 of the
22	License.
23
24	This program is distributed in the hope that it will be useful, but
25	WITHOUT ANY WARRANTY; without even the implied warranty of
26	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
27	General Public License for more details.
28
29	You should have received a copy of the GNU General Public License
30	along with this program; if not, see <https://www.gnu.org/licenses>.
31
32	The contents of this file may alternatively be used under the terms
33	of the Common Development and Distribution License Version 1.0
34	(CDDL), a copy of it is provided in the "COPYING.CDDL" file included
35	in the VirtualBox distribution, in which case the provisions of the
36	CDDL are applicable instead of those of the GPL.
37
38	You may elect to license modified versions of this file under the
39	terms and conditions of either the GPL or the CDDL or both.
40
41	SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
42	"""
43	__version__ = "$Revision: 103217 $"
44
45	# Standard python imports.
46	import datetime;
47	import os;
48	import sys;
49
50	# Only the main script needs to modify the path.
51	g_ksValidationKitDir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)));
52	g_ksVmmAllDir = os.path.join(os.path.dirname(g_ksValidationKitDir), 'VMM', 'VMMAll')
53	sys.path.append(g_ksVmmAllDir);
54
55	import IEMAllInstPython as iai; # pylint: disable=import-error
56
57
58	# Python 3 hacks:
59	if sys.version_info[0] >= 3:
60	long = int; # pylint: disable=redefined-builtin,invalid-name
61
62
63	class Bs3Cg1TestEncoder(object):
64	"""
65	Does the encoding of a single test.
66	"""
67
68	def __init__(self, fLast):
69	self.fLast = fLast;
70	# Each list member (in all lists) are C expression of a byte.
71	self.asHdr = [];
72	self.asSelectors = [];
73	self.asInputs = [];
74	self.asOutputs = [];
75
76	@staticmethod
77	def _compileSelectors(aoSelectors): # (list(iai.TestSelector)) -> list(str)
78	"""
79	Compiles a list of iai.TestSelector predicate checks.
80	Returns C byte expression strings.
81	"""
82	asRet = [];
83	for oSelector in aoSelectors:
84	sConstant = oSelector.kdVariables[oSelector.sVariable][oSelector.sValue];
85	sConstant = sConstant.upper().replace('.', '_');
86	if oSelector.sOp == '==':
87	sByte = '(BS3CG1PRED_%s << BS3CG1SEL_OP_PRED_SHIFT) \| BS3CG1SEL_OP_IS_TRUE' % (sConstant,);
88	elif oSelector.sOp == '!=':
89	sByte = '(BS3CG1PRED_%s << BS3CG1SEL_OP_PRED_SHIFT) \| BS3CG1SEL_OP_IS_FALSE' % (sConstant,);
90	else:
91	raise Exception('Unknown selector operator: %s' % (oSelector.sOp,));
92	asRet.append(sByte);
93	return asRet;
94
95	kdSmallFields = {
96	'op1': 'BS3CG1_CTXOP_OP1',
97	'op2': 'BS3CG1_CTXOP_OP2',
98	'efl': 'BS3CG1_CTXOP_EFL',
99	};
100	kdOperators = {
101	'=': 'BS3CG1_CTXOP_ASSIGN',
102	'\|=': 'BS3CG1_CTXOP_OR',
103	'&=': 'BS3CG1_CTXOP_AND',
104	'&~=': 'BS3CG1_CTXOP_AND_INV',
105	};
106	kdSmallSizes = {
107	1: 'BS3CG1_CTXOP_1_BYTE',
108	2: 'BS3CG1_CTXOP_2_BYTES',
109	4: 'BS3CG1_CTXOP_4_BYTES',
110	8: 'BS3CG1_CTXOP_8_BYTES',
111	16: 'BS3CG1_CTXOP_16_BYTES',
112	32: 'BS3CG1_CTXOP_32_BYTES',
113	12: 'BS3CG1_CTXOP_12_BYTES',
114	};
115
116	@staticmethod
117	def _amendOutputs(aoOutputs, oInstr): # type: (list(iai.TestInOut), iai.Instruction) -> list(iai.TestInOut)
118	"""
119	Amends aoOutputs for instructions with special flag behaviour (undefined,
120	always set, always clear).
121
122	Undefined flags are copied from the result context as the very first
123	operation so they can be set to CPU vendor specific values later if
124	desired.
125
126	Always set or cleared flags are applied at the very end of the
127	modification operations so that we spot incorrect specifications.
128	"""
129	if oInstr.asFlUndefined or oInstr.asFlClear or oInstr.asFlSet:
130	aoOutputs = list(aoOutputs);
131
132	if oInstr.asFlUndefined:
133	fFlags = oInstr.getUndefinedFlagsMask();
134	assert fFlags != 0;
135	aoOutputs.insert(0, iai.TestInOut('efl_undef', '=', str(fFlags), 'uint'));
136
137	if oInstr.asFlClear:
138	fFlags = oInstr.getClearedFlagsMask();
139	assert fFlags != 0;
140	aoOutputs.append(iai.TestInOut('efl', '&~=', str(fFlags), 'uint'));
141
142	if oInstr.asFlSet:
143	fFlags = oInstr.getSetFlagsMask();
144	assert fFlags != 0;
145	aoOutputs.append(iai.TestInOut('efl', '\|=', str(fFlags), 'uint'));
146
147	return aoOutputs;
148
149	@staticmethod
150	def _compileContextModifers(aoOperations): # (list(iai.TestInOut))
151	"""
152	Compile a list of iai.TestInOut context modifiers.
153	"""
154	asRet = [];
155	for oOperation in aoOperations:
156	oType = iai.TestInOut.kdTypes[oOperation.sType];
157	aaoValues = oType.get(oOperation.sValue);
158	assert len(aaoValues) == 1 or len(aaoValues) == 2;
159
160	sOp = oOperation.sOp;
161	if sOp == '&\|=':
162	sOp = '\|=' if len(aaoValues) == 1 else '&~=';
163
164	for fSignExtend, abValue in aaoValues:
165	cbValue = len(abValue);
166
167	# The opcode byte.
168	sOpcode = Bs3Cg1TestEncoder.kdOperators[sOp];
169	sOpcode += ' \| ';
170	if oOperation.sField in Bs3Cg1TestEncoder.kdSmallFields:
171	sOpcode += Bs3Cg1TestEncoder.kdSmallFields[oOperation.sField];
172	else:
173	sOpcode += 'BS3CG1_CTXOP_DST_ESC';
174	sOpcode += ' \| ';
175	if cbValue in Bs3Cg1TestEncoder.kdSmallSizes:
176	sOpcode += Bs3Cg1TestEncoder.kdSmallSizes[cbValue];
177	else:
178	sOpcode += 'BS3CG1_CTXOP_SIZE_ESC';
179	if fSignExtend:
180	sOpcode += ' \| BS3CG1_CTXOP_SIGN_EXT';
181	asRet.append(sOpcode);
182
183	# Escaped field identifier.
184	if oOperation.sField not in Bs3Cg1TestEncoder.kdSmallFields:
185	asRet.append('BS3CG1DST_%s' % (oOperation.sField.upper().replace('.', '_'),));
186
187	# Escaped size byte?
188	if cbValue not in Bs3Cg1TestEncoder.kdSmallSizes:
189	if cbValue >= 256 or cbValue not in [ 1, 2, 4, 6, 8, 12, 16, 32, 64, 128, ]:
190	raise Exception('Invalid value size: %s' % (cbValue,));
191	asRet.append('0x%02x' % (cbValue,));
192
193	# The value bytes.
194	for b in abValue:
195	asRet.append('0x%02x' % (b,));
196
197	sOp = '\|=';
198
199	return asRet;
200
201	def _constructHeader(self):
202	"""
203	Returns C byte expression strings for BS3CG1TESTHDR.
204	"""
205	cbSelectors = len(self.asSelectors);
206	if cbSelectors >= 256:
207	raise Exception('Too many selectors: %s bytes, max 255 bytes' % (cbSelectors,))
208
209	cbInputs = len(self.asInputs);
210	if cbInputs >= 4096:
211	raise Exception('Too many input context modifiers: %s bytes, max 4095 bytes' % (cbInputs,))
212
213	cbOutputs = len(self.asOutputs);
214	if cbOutputs >= 2048:
215	raise Exception('Too many output context modifiers: %s bytes, max 2047 bytes' % (cbOutputs,))
216
217	return [
218	'%#04x' % (cbSelectors,), # 8-bit
219	'%#05x & 0xff' % (cbInputs,), # first 8 bits of cbInputs
220	'(%#05x >> 8) \| ((%#05x & 0xf) << 4)' % (cbInputs, cbOutputs,), # last 4 bits of cbInputs, lower 4 bits of cbOutputs.
221	'(%#05x >> 4) \| (%#05x << 7)' % (cbOutputs, self.fLast), # last 7 bits of cbOutputs and 1 bit fLast.
222	];
223
224	def encodeTest(self, oTest): # type: (iai.InstructionTest)
225	"""
226	Does the encoding.
227	"""
228	self.asSelectors = self._compileSelectors(oTest.aoSelectors);
229	self.asInputs = self._compileContextModifers(oTest.aoInputs);
230	self.asOutputs = self._compileContextModifers(self._amendOutputs(oTest.aoOutputs, oTest.oInstr));
231	self.asHdr = self._constructHeader();
232
233
234	class Bs3Cg1EncodedTests(object):
235	"""
236	Encodes the tests for an instruction.
237	"""
238
239	def __init__(self, oInstr):
240	self.offTests = -1;
241	self.cbTests = 0;
242	self.asLines = [] # type: list(str)
243	self.aoInstructions = [] # type: list(iai.Instruction)
244
245	# Encode the tests.
246	for iTest, oTest in enumerate(oInstr.aoTests):
247	oEncodedTest = Bs3Cg1TestEncoder(iTest + 1 == len(oInstr.aoTests));
248	oEncodedTest.encodeTest(oTest);
249
250	self.cbTests += len(oEncodedTest.asHdr) + len(oEncodedTest.asSelectors) \
251	+ len(oEncodedTest.asInputs) + len(oEncodedTest.asOutputs);
252
253	self.asLines.append(' /* test #%s: %s */' % (iTest, oTest,));
254	self.asLines += self.bytesToLines(' ', oEncodedTest.asHdr);
255	if oEncodedTest.asSelectors:
256	self.asLines += self.bytesToLines(' /sel:/ ', oEncodedTest.asSelectors);
257	if oEncodedTest.asInputs:
258	self.asLines += self.bytesToLines(' /* in:*/ ', oEncodedTest.asInputs);
259	if oEncodedTest.asOutputs:
260	self.asLines += self.bytesToLines(' /out:/ ', oEncodedTest.asOutputs);
261
262	@staticmethod
263	def bytesToLines(sPrefix, asBytes):
264	"""
265	Formats a series of bytes into one or more lines.
266	A byte ending with a newline indicates that we should start a new line,
267	and prefix it by len(sPrefix) spaces.
268
269	Returns list of lines.
270	"""
271	asRet = [];
272	sLine = sPrefix;
273	for sByte in asBytes:
274	if sByte[-1] == '\n':
275	sLine += sByte[:-1] + ',';
276	asRet.append(sLine);
277	sLine = ' ' * len(sPrefix);
278	else:
279	if len(sLine) + 2 + len(sByte) > 132 and len(sLine) > len(sPrefix):
280	asRet.append(sLine[:-1]);
281	sLine = ' ' * len(sPrefix);
282	sLine += sByte + ', ';
283
284
285	if len(sLine) > len(sPrefix):
286	asRet.append(sLine);
287	return asRet;
288
289
290	def isEqual(self, oOther):
291	""" Compares two encoded tests. """
292	if self.cbTests != oOther.cbTests:
293	return False;
294	if len(self.asLines) != len(oOther.asLines):
295	return False;
296	for iLine, sLines in enumerate(self.asLines):
297	if sLines != oOther.asLines[iLine]:
298	return False;
299	return True;
300
301
302
303	class Bs3Cg1Instruction(object):
304	"""
305	An instruction with tests.
306	"""
307
308	def __init__(self, oMap, oInstr, oTests):
309	self.oMap = oMap # type: iai.InstructionMap
310	self.oInstr = oInstr # type: iai.Instruction
311	self.oTests = oTests # type: Bs3Cg1EncodedTests
312
313	self.asOpcodes = oMap.asLeadOpcodes + [ '0x%02x' % (oInstr.getOpcodeByte(),) ];
314	self.sEncoding = iai.g_kdEncodings[oInstr.sEncoding][0];
315
316	for oOp in oInstr.aoOperands:
317	self.sEncoding += '_' + oOp.sType;
318	if oInstr.sSubOpcode and iai.g_kdSubOpcodes[oInstr.sSubOpcode][1]:
319	self.sEncoding += '_' + iai.g_kdSubOpcodes[oInstr.sSubOpcode][1];
320
321	if oInstr.fUnused:
322	if oInstr.sInvalidStyle == 'immediate' and oInstr.sSubOpcode:
323	self.sEncoding += '_MOD_EQ_3' if oInstr.sSubOpcode == '11 mr/reg' else '_MOD_NE_3';
324	elif oInstr.sInvalidStyle == 'intel-modrm':
325	if oInstr.sSubOpcode is None:
326	self.sEncoding = 'BS3CG1ENC_MODRM_Gv_Ev';
327	elif oInstr.sSubOpcode == '11 mr/reg':
328	self.sEncoding = 'BS3CG1ENC_MODRM_MOD_EQ_3';
329	elif oInstr.sSubOpcode == '!11 mr/reg':
330	self.sEncoding = 'BS3CG1ENC_MODRM_MOD_NE_3';
331	else:
332	raise Exception('Unhandled sSubOpcode=%s for sInvalidStyle=%s' % (oInstr.sSubOpcode, oInstr.sInvalidStyle));
333	elif oInstr.sInvalidStyle == 'vex.modrm':
334	self.sEncoding = 'BS3CG1ENC_VEX_MODRM';
335
336	self.asFlags = [];
337	if 'x86_invalid_64' in oInstr.dHints:
338	self.asFlags.append('BS3CG1INSTR_F_INVALID_64BIT');
339	if oInstr.fUnused:
340	self.asFlags.append('BS3CG1INSTR_F_UNUSED');
341	elif oInstr.fInvalid:
342	self.asFlags.append('BS3CG1INSTR_F_INVALID');
343	if oInstr.sInvalidStyle and oInstr.sInvalidStyle.startswith('intel-'):
344	self.asFlags.append('BS3CG1INSTR_F_INTEL_DECODES_INVALID');
345	if 'vex_l_zero' in oInstr.dHints:
346	self.asFlags.append('BS3CG1INSTR_F_VEX_L_ZERO');
347	if 'vex_l_ignored' in oInstr.dHints:
348	self.asFlags.append('BS3CG1INSTR_F_VEX_L_IGNORED');
349
350	self.fAdvanceMnemonic = True; ##< Set by the caller.
351	if oInstr.sPrefix:
352	if oInstr.sPrefix == 'none':
353	self.sPfxKind = 'BS3CG1PFXKIND_NO_F2_F3_66';
354	else:
355	self.sPfxKind = 'BS3CG1PFXKIND_REQ_' + oInstr.sPrefix[-2:].upper();
356	elif oInstr.sEncoding == 'ModR/M':
357	if 'ignores_op_size' not in oInstr.dHints:
358	self.sPfxKind = 'BS3CG1PFXKIND_MODRM';
359	else:
360	self.sPfxKind = 'BS3CG1PFXKIND_MODRM_NO_OP_SIZES';
361	else:
362	self.sPfxKind = '0';
363
364	self.sCpu = 'BS3CG1CPU_';
365	assert len(oInstr.asCpuIds) in [0, 1], str(oInstr);
366	if oInstr.asCpuIds:
367	self.sCpu += oInstr.asCpuIds[0].upper().replace('.', '_');
368	elif oInstr.sMinCpu:
369	self.sCpu += 'GE_' + oInstr.sMinCpu;
370	else:
371	self.sCpu += 'ANY';
372
373	if oInstr.sXcptType:
374	self.sXcptType = 'BS3CG1XCPTTYPE_' + oInstr.sXcptType.upper();
375	else:
376	self.sXcptType = 'BS3CG1XCPTTYPE_NONE';
377
378	def getOperands(self):
379	""" Returns comma separated string of operand values for g_abBs3Cg1Operands. """
380	return ', '.join(['(uint8_t)BS3CG1OP_%s' % (oOp.sType,) for oOp in self.oInstr.aoOperands]);
381
382	def getOpcodeMap(self):
383	""" Returns the opcode map number for the BS3CG1INSTR structure. """
384	sEncoding = self.oInstr.aoMaps[0].sEncoding;
385	if sEncoding == 'legacy': return 0;
386	if sEncoding == 'vex1': return 1;
387	if sEncoding == 'vex2': return 2;
388	if sEncoding == 'vex3': return 3;
389	if sEncoding == 'xop8': return 8;
390	if sEncoding == 'xop9': return 9;
391	if sEncoding == 'xop10': return 10;
392	assert False, sEncoding;
393	return 3;
394
395	def getInstructionEntry(self):
396	""" Returns an array of BS3CG1INSTR member initializers. """
397	assert len(self.oInstr.sMnemonic) < 16;
398	sOperands = ', '.join([oOp.sType for oOp in self.oInstr.aoOperands]);
399	if sOperands:
400	sOperands = ' /* ' + sOperands + ' */';
401	return [
402	' /* cbOpcodes = / %s, / %s */' % (len(self.asOpcodes), ' '.join(self.asOpcodes),),
403	' /* cOperands = */ %s,%s' % (len(self.oInstr.aoOperands), sOperands,),
404	' /* cchMnemonic = / %s, / %s */' % (len(self.oInstr.sMnemonic), self.oInstr.sMnemonic,),
405	' /* fAdvanceMnemonic = */ %s,' % ('true' if self.fAdvanceMnemonic else 'false',),
406	' /* offTests = */ %s,' % (self.oTests.offTests,),
407	' /* enmEncoding = */ (unsigned)%s,' % (self.sEncoding,),
408	' /* uOpcodeMap = */ (unsigned)%s,' % (self.getOpcodeMap(),),
409	' /* enmPrefixKind = */ (unsigned)%s,' % (self.sPfxKind,),
410	' /* enmCpuTest = */ (unsigned)%s,' % (self.sCpu,),
411	' /* enmXcptType = */ (unsigned)%s,' % (self.sXcptType,),
412	' /* uUnused = */ 0,',
413	' /* fFlags = */ %s' % (' \| '.join(self.asFlags) if self.asFlags else '0'),
414	];
415
416
417	class Bs3CpuGenerated1Generator(object):
418	"""
419	The generator code for bs3-cpu-generated-1.
420	"""
421
422	def __init__(self):
423	self.aoInstructions = [] # type: Bs3Cg1Instruction
424	self.aoTests = [] # type: Bs3Cg1EncodedTests
425	self.cbTests = 0;
426
427	def addTests(self, oTests, oInstr): # type: (Bs3Cg1EncodedTests, iai.Instruction) -> Bs3Cg1EncodedTests
428	"""
429	Adds oTests to self.aoTests, setting the oTests.offTests member.
430	Checks for and eliminates duplicates.
431	Returns the tests to use.
432	"""
433	# Check for duplicates.
434	for oExisting in self.aoTests:
435	if oTests.isEqual(oExisting):
436	oExisting.aoInstructions.append(oInstr);
437	return oExisting;
438
439	# New test, so add it.
440	oTests.offTests = self.cbTests;
441	self.aoTests.append(oTests);
442	self.cbTests += oTests.cbTests;
443
444	assert not oTests.aoInstructions;
445	oTests.aoInstructions.append(oInstr);
446
447	return oTests;
448
449	def processInstruction(self):
450	"""
451	Processes the IEM specified instructions.
452	Returns success indicator.
453	"""
454
455	#
456	# Do the parsing.
457	#
458	try:
459	iai.parseAll();
460	except Exception as oXcpt:
461	print('error: parseAll failed: %s' % (oXcpt,), file = sys.stderr);
462	return False;
463
464	#
465	# Group instructions by mnemonic to reduce the number of sub-tests.
466	#
467	for oInstr in sorted(iai.g_aoAllInstructions,
468	key = lambda oInstr: oInstr.sMnemonic + ''.join([oOp.sType for oOp in oInstr.aoOperands])
469	+ (oInstr.sOpcode if oInstr.sOpcode else 'zz')):
470	if oInstr.aoTests:
471	oTests = Bs3Cg1EncodedTests(oInstr);
472	oTests = self.addTests(oTests, oInstr);
473
474	for oMap in oInstr.aoMaps:
475	self.aoInstructions.append(Bs3Cg1Instruction(oMap, oInstr, oTests));
476
477	# Set fAdvanceMnemonic.
478	for iInstr, oInstr in enumerate(self.aoInstructions):
479	oInstr.fAdvanceMnemonic = iInstr + 1 >= len(self.aoInstructions) \
480	or oInstr.oInstr.sMnemonic != self.aoInstructions[iInstr + 1].oInstr.sMnemonic;
481
482	return True;
483
484	def generateCode(self, oOut):
485	"""
486	Generates the C code.
487	Returns success indicator.
488	"""
489
490	# First, a file header.
491	asLines = [
492	'/*',
493	' * Autogenerated by $Id: bs3-cpu-generated-1-data.py 103217 2024-02-06 08:45:24Z vboxsync $ ',
494	' * Do not edit!',
495	' */',
496	'',
497	'/*',
498	' * Copyright (C) 2017-' + str(datetime.date.today().year) + ' Oracle and/or its affiliates.',
499	' *',
500	' * This file is part of VirtualBox base platform packages, as',
501	' * available from https://www.virtualbox.org.',
502	' *',
503	' * This program is free software; you can redistribute it and/or',
504	' * modify it under the terms of the GNU General Public License',
505	' * as published by the Free Software Foundation, in version 3 of the',
506	' * License.',
507	' *',
508	' * This program is distributed in the hope that it will be useful, but',
509	' * WITHOUT ANY WARRANTY; without even the implied warranty of',
510	' * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU',
511	' * General Public License for more details.',
512	' *',
513	' * You should have received a copy of the GNU General Public License',
514	' * along with this program; if not, see <https://www.gnu.org/licenses>.',
515	' *',
516	' * The contents of this file may alternatively be used under the terms',
517	' * of the Common Development and Distribution License Version 1.0',
518	' * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included',
519	' * in the VirtualBox distribution, in which case the provisions of the',
520	' * CDDL are applicable instead of those of the GPL.',
521	' *',
522	' * You may elect to license modified versions of this file under the',
523	' * terms and conditions of either the GPL or the CDDL or both.',
524	' *',
525	' * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0',
526	' */',
527	'',
528	'',
529	'#include "bs3-cpu-generated-1.h"',
530	'',
531	'',
532	'#pragma data_seg ("BS3DATA16")',
533	];
534
535	# Generate the g_achBs3Cg1Mnemonics array.
536	asLines += [
537	'const char BS3_FAR_DATA g_achBs3Cg1Mnemonics[] = ',
538	'{',
539	];
540	fAdvanceMnemonic = True;
541	for oInstr in self.aoInstructions:
542	if fAdvanceMnemonic:
543	asLines.append(' \"%s\"' % (oInstr.oInstr.sMnemonic,));
544	fAdvanceMnemonic = oInstr.fAdvanceMnemonic;
545	asLines += [
546	'};',
547	'',
548	'',
549	];
550
551	# Generate the g_abBs3Cg1Opcodes array.
552	asLines += [
553	'const uint8_t BS3_FAR_DATA g_abBs3Cg1Opcodes[] = ',
554	'{',
555	];
556	for oInstr in self.aoInstructions:
557	asLines.append(' ' + ', '.join(oInstr.asOpcodes) + ',');
558	asLines += [
559	'};',
560	'',
561	'',
562	];
563
564	# Generate the g_abBs3Cg1Opcodes array.
565	asLines += [
566	'const uint8_t BS3_FAR_DATA g_abBs3Cg1Operands[] = ',
567	'{',
568	];
569	cOperands = 0;
570	for oInstr in self.aoInstructions:
571	if oInstr.oInstr.aoOperands:
572	cOperands += len(oInstr.oInstr.aoOperands);
573	asLines.append(' ' + oInstr.getOperands() + ', /* %s */' % (oInstr.oInstr.sStats,));
574	else:
575	asLines.append(' /* none */');
576	if not cOperands:
577	asLines.append(' 0 /* dummy */');
578	asLines += [
579	'};',
580	'',
581	'',
582	];
583
584	# Generate the g_abBs3Cg1Operands array.
585	asLines += [
586	'const BS3CG1INSTR BS3_FAR_DATA g_aBs3Cg1Instructions[] = ',
587	'{',
588	];
589	for oInstr in self.aoInstructions:
590	asLines.append(' {');
591	asLines += oInstr.getInstructionEntry();
592	asLines.append(' },');
593	asLines += [
594	'};',
595	'const uint16_t BS3_FAR_DATA g_cBs3Cg1Instructions = RT_ELEMENTS(g_aBs3Cg1Instructions);',
596	'',
597	'',
598	];
599
600	# Generate the g_abBs3Cg1Tests array.
601	asLines += [
602	'const uint8_t BS3_FAR_DATA g_abBs3Cg1Tests[] = ',
603	'{',
604	];
605	for oTests in self.aoTests:
606	asLines.append(' /*');
607	asLines.append(' * offTests=%s' % (oTests.offTests,));
608	asLines.append(' * Instructions: %s' % (', '.join([oInstr.sStats for oInstr in oTests.aoInstructions]),));
609	asLines.append(' */');
610	asLines += oTests.asLines;
611	asLines += [
612	'};',
613	'',
614	];
615
616
617	#/** The test data that BS3CG1INSTR.
618	# * In order to simplify generating these, we use a byte array. */
619	#extern const uint8_t BS3_FAR_DATA g_abBs3Cg1Tests[];
620
621
622	oOut.write('\n'.join(asLines));
623	return True;
624
625
626	def usage(self):
627	""" Prints usage. """
628	print('usage: bs3-cpu-generated-1-data.py [output file\|-]');
629	return 0;
630
631	def main(self, asArgs):
632	"""
633	C-like main function.
634	Returns exit code.
635	"""
636
637	#
638	# Quick argument parsing.
639	#
640	if len(asArgs) == 1:
641	sOutFile = '-';
642	elif len(asArgs) != 2:
643	print('syntax error! Expected exactly one argument.');
644	return 2;
645	elif asArgs[1] in [ '-h', '-?', '--help' ]:
646	return self.usage();
647	else:
648	sOutFile = asArgs[1];
649
650	#
651	# Process the instructions specified in the IEM sources.
652	#
653	if self.processInstruction():
654
655	#
656	# Open the output file and generate the code.
657	#
658	if sOutFile == '-':
659	oOut = sys.stdout;
660	else:
661	try:
662	oOut = open(sOutFile, 'w'); # pylint: disable=consider-using-with,unspecified-encoding
663	except Exception as oXcpt:
664	print('error! Failed open "%s" for writing: %s' % (sOutFile, oXcpt,));
665	return 1;
666	if self.generateCode(oOut):
667	return 0;
668
669	return 1;
670
671
672	if __name__ == '__main__':
673	sys.exit(Bs3CpuGenerated1Generator().main(sys.argv));
674

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-generated-1-data.py@ 105684

Download in other formats: