You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
702 lines
22 KiB
702 lines
22 KiB
# Copyright 2016, VIXL authors |
|
# All rights reserved. |
|
# |
|
# Redistribution and use in source and binary forms, with or without |
|
# modification, are permitted provided that the following conditions are met: |
|
# |
|
# * Redistributions of source code must retain the above copyright notice, |
|
# this list of conditions and the following disclaimer. |
|
# * Redistributions in binary form must reproduce the above copyright notice, |
|
# this list of conditions and the following disclaimer in the documentation |
|
# and/or other materials provided with the distribution. |
|
# * Neither the name of ARM Limited nor the names of its contributors may be |
|
# used to endorse or promote products derived from this software without |
|
# specific prior written permission. |
|
# |
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND |
|
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
|
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE |
|
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
|
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
|
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
|
|
import itertools |
|
import random |
|
import os.path |
|
from copy import deepcopy |
|
|
|
class OperandList(object): |
|
""" |
|
Convenience class representing a list of operand objects. It can be viewed is |
|
an iterator over operand objects. |
|
|
|
Attributes: |
|
operand_list |
|
""" |
|
|
|
def __init__(self, operand_list): |
|
self.operand_list = operand_list |
|
|
|
def __iter__(self): |
|
return iter(self.operand_list) |
|
|
|
def unwrap(self): |
|
""" |
|
Return a list of `Operand` objects, unwrapping `OperandWrapper` objects into |
|
`Operand` objects. For example: |
|
|
|
~~~ |
|
Condition, Register, Operand(Register, Shift, Register) |
|
~~~ |
|
|
|
Unwraps to: |
|
|
|
~~~ |
|
Condition, Register, Register, Shift, Register |
|
~~~ |
|
""" |
|
return itertools.chain(*self.operand_list) |
|
|
|
def ExcludeVariants(self, type_name, variant_to_exclude): |
|
""" |
|
Remove variants in `variant_to_exclude` from operands with type `type_name`. |
|
""" |
|
# Find the list of operand with type `type_name`. |
|
relevant_operands = filter(lambda operand: operand.type_name == type_name, |
|
self) |
|
for operand in relevant_operands: |
|
# Remove the intersection of the existing variants and variants we do not |
|
# want. |
|
for variant in set(operand.variants) & set(variant_to_exclude): |
|
operand.variants.remove(variant) |
|
|
|
def GetNames(self): |
|
""" |
|
Return the list of all `Operand` names, excluding `OperandWrapper` objects. |
|
""" |
|
return [operand.name for operand in self.unwrap()] |
|
|
|
|
|
class InputList(object): |
|
""" |
|
Convevience class representing a list of input objects. |
|
|
|
This class is an iterator over input objects. |
|
|
|
Attributes: |
|
inputs |
|
""" |
|
|
|
def __init__(self, inputs): |
|
self.inputs = inputs |
|
|
|
def __iter__(self): |
|
return iter(self.inputs) |
|
|
|
def GetNames(self): |
|
""" |
|
Return the list of input names. |
|
""" |
|
return [input.name for input in self] |
|
|
|
|
|
class TestCase(object): |
|
""" |
|
Object representation of a test case, as described in JSON. This object is |
|
used to build sets of operands and inputs that will be used by the generator |
|
to produce C++ arrays. |
|
|
|
Attributes: |
|
name Name of the test case, it is used to name the array to |
|
produce. |
|
seed Seed value to use for reproducable random generation. |
|
operand_names List of operand names this test case covers. |
|
input_names List of input names this test case covers. |
|
operand_filter Python expression as a string to filter out operands. |
|
input_filter Python expression as a string to filter out inputs. |
|
operand_limit Optional limit of the number of operands to generate. |
|
input_limit Optional limit of the number of inputs to generate. |
|
it_condition If not None, an IT instruction needs to be generated for the |
|
instruction under test to be valid. This member is a string |
|
template indicating the name of the condition operand, to be |
|
used with "format". For example, it will most likely have |
|
the value "{cond}". |
|
""" |
|
|
|
# Declare functions that will be callable from Python expressions in |
|
# `self.operand_filter`. |
|
operand_filter_runtime = { |
|
'register_is_low': lambda register: |
|
register in ["r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7"] |
|
} |
|
|
|
def __init__(self, name, seed, operand_names, input_names, operand_filter, |
|
input_filter, operand_limit, input_limit, it_condition): |
|
self.name = name |
|
self.seed = seed |
|
self.operand_names = operand_names |
|
self.input_names = input_names |
|
self.operand_filter = operand_filter |
|
self.input_filter = input_filter |
|
self.operand_limit = operand_limit |
|
self.input_limit = input_limit |
|
self.it_condition = it_condition |
|
|
|
def GenerateOperands(self, operand_types): |
|
""" |
|
Generate a list of tuples, each tuple describing what operands to pass to an |
|
instruction to encode it. We use this to generate operand definitions. |
|
|
|
The algorithm used is a simple product of all operand variants. To limit |
|
what we generate, we choose to apply the product only on operands with their |
|
name in the `self.operand_names` list. |
|
|
|
Additionally, we use the Python expression in `self.operand_filter` to |
|
filter out tuples we do not want. |
|
|
|
Argument: |
|
operand_types The `OperandList` object that describe the form of the |
|
instruction to generate code for. |
|
""" |
|
# Build a list of all possible variants as a list of tuples. If the |
|
# operand's name is not in `self.operand_names`, then we restrict the list |
|
# to contain default variant. Each tuple in the list has the form |
|
# `(name, [variant1, variant2, ...])`. For example: |
|
# |
|
# [ |
|
# ('cond', ['al', 'ne', 'eq', ...]), # All condition variants. |
|
# ('rd', ['r0', 'r1', ...]), # All register variants. |
|
# ('rn', ['r0']) # Default register variant (r0). |
|
# ... |
|
# ] |
|
variants = [ |
|
[(operand_type.name, variant) for variant in operand_type.variants] |
|
if operand_type.name in self.operand_names |
|
else [(operand_type.name, operand_type.default)] |
|
for operand_type in operand_types.unwrap() |
|
] |
|
lambda_string = "lambda {args}: {expression}".format( |
|
args=",".join(operand_types.GetNames()), |
|
expression=self.operand_filter) |
|
filter_lambda = eval(lambda_string, self.operand_filter_runtime) |
|
|
|
def BuildOperandDefinition(operands): |
|
""" |
|
Take a list of tuples describing the operands and build a definition from |
|
it. A definition is a tuple with a list of variants and a |
|
`expect_instruction_before` string. |
|
|
|
For example, we are turning this: |
|
|
|
[ |
|
('cond', 'ne'), |
|
('rd', 'r0'), |
|
('rn', 'r1'), |
|
('rm', 'r0) |
|
[ |
|
|
|
Into: |
|
|
|
(['ne', 'r0', 'r1', 'r0'], "It ne;") |
|
|
|
""" |
|
return ( |
|
# Build a list of operands by only keeping the second element of each |
|
# tuple. |
|
[operand[1] for operand in operands], |
|
# The next field is a boolean indicating if the test case needs to |
|
# generate an IT instruction. |
|
"true" if self.it_condition else "false", |
|
# If so, what condition should it be? |
|
self.it_condition.format(**dict(operands)) if self.it_condition else "al" |
|
) |
|
|
|
# Build and return a list of operand definitions by computing the product of |
|
# all variants and filtering them with `filter_lambda`. |
|
# |
|
# Operand definitions consist of a list with a list of variants and an |
|
# optional `expect_instruction_before` string. For example: |
|
# |
|
# [ |
|
# (['al', 'r0', 'r1', 'r2'], ""), |
|
# (['ne', 'r0', 'r1', 'r0'], "It ne;"), |
|
# ... |
|
# ] |
|
# |
|
# Here, the filtered product of variants builds a list of lists of tuples, as such: |
|
# |
|
# [ |
|
# [('cond', 'al'), ('rd', 'r0'), ('rn', 'r1'), ('rn', 'r2')] |
|
# [('cond', 'ne'), ('rd', 'r0'), ('rn', 'r1'), ('rn', 'r0')], |
|
# ... |
|
# ] |
|
# |
|
# We then pass them to `BuildOperandDefinition` to produce the expected form |
|
# out of it. |
|
result = [ |
|
BuildOperandDefinition(operands) |
|
for operands in itertools.product(*variants) |
|
if filter_lambda(**dict(operands)) |
|
] |
|
if self.operand_limit is None: |
|
return result |
|
else: |
|
# Use a fixed seed to randomly choose a limited set of operands. |
|
random.seed(self.seed) |
|
return random.sample(result, self.operand_limit) |
|
|
|
def GenerateInputs(self, input_types): |
|
""" |
|
Generate a list of tuples, each tuple describing what input to pass to an |
|
instruction at runtime. We use this to generate input definitions. |
|
|
|
The algorithm used is a simple product of all input values. To limit what |
|
we generate, we choose to apply the product only on inputs with their name |
|
in the `self.input_names` list. |
|
|
|
Additionally, we use the Python expression in `self.input_filter` to filter |
|
out tuples we do not want. |
|
|
|
Argument: |
|
input_types The `InputList` object describing the list of inputs the |
|
instruction can take. |
|
""" |
|
# Build a list of all possible values as a list of lists. If the input's |
|
# name is not in `self.input_names`, then we restrict the list to the |
|
# default value. |
|
values = [ |
|
input_type.values |
|
if input_type.name in self.input_names else [input_type.default] |
|
for input_type in input_types |
|
] |
|
lambda_string = "lambda {args}: {expression}".format( |
|
args=", ".join(input_types.GetNames()), |
|
expression=self.input_filter) |
|
filter_lambda = eval(lambda_string) |
|
# Build and return a list of input definitions, such as |
|
# [('NoFlag', '0xffffffff', 0xabababab'), ...] for example. |
|
result = [ |
|
input_definition |
|
for input_definition in itertools.product(*values) |
|
if filter_lambda(*input_definition) |
|
] |
|
if self.input_limit is None: |
|
return result |
|
else: |
|
# Use a fixed seed to randomly choose a limited set of inputs. |
|
random.seed(self.seed) |
|
return random.sample(result, self.input_limit) |
|
|
|
|
|
class Generator(object): |
|
""" |
|
A `Generator` object contains all information needed to generate a test file. |
|
Each method will return a string used to fill a variable in a template. |
|
|
|
|
|
Attributes: |
|
test_name Name of the test inferred from the name of the configuration |
|
file. It has the following form: `type-op1-op2-op3-isa`. |
|
test_type Type of the test, extracted from test_name. |
|
mnemonics List of instruction mnemonics. |
|
operands `OperandList` object. |
|
inputs `InputList` object. |
|
test_cases List of `TestCase` objects. |
|
""" |
|
|
|
def __init__(self, test_name, test_isa, test_type, mnemonics, operands, |
|
inputs, test_cases): |
|
self.test_name = test_name |
|
self.test_isa = test_isa |
|
self.test_type = test_type |
|
self.mnemonics = mnemonics |
|
self.inputs = inputs |
|
self.test_cases = test_cases |
|
|
|
# A simulator test cannot easily make use of the PC and SP registers. |
|
if self.test_type == "simulator": |
|
# We need to explicitely create our own deep copy the operands before we |
|
# can modify them. |
|
self.operands = deepcopy(operands) |
|
self.operands.ExcludeVariants("Register", ["r13", "r15"]) |
|
else: |
|
self.operands = operands |
|
|
|
def MnemonicToMethodName(self, mnemonic): |
|
if self.test_type in ["simulator", "macro-assembler"]: |
|
# Return a MacroAssembler method name |
|
return mnemonic.capitalize() |
|
else: |
|
# Return an Assembler method name |
|
method_name = mnemonic.lower() |
|
return "and_" if method_name == "and" else method_name |
|
|
|
def InstructionListDeclaration(self): |
|
""" |
|
~~~ |
|
M(Adc) \ |
|
M(Adcs) \ |
|
M(Add) \ |
|
M(Adds) \ |
|
M(And) \ |
|
... |
|
~~~ |
|
""" |
|
return "".join([ |
|
"M({}) \\\n".format(self.MnemonicToMethodName(mnemonic)) |
|
for mnemonic in self.mnemonics |
|
]) |
|
|
|
def OperandDeclarations(self): |
|
""" |
|
~~~ |
|
Condition cond; |
|
Register rd; |
|
Register rn; |
|
... |
|
~~~ |
|
""" |
|
return "".join([operand.Declare() for operand in self.operands]) |
|
|
|
def InputDeclarations(self): |
|
""" |
|
~~~ |
|
uint32_t cond; |
|
uint32_t rd; |
|
uint32_t rn; |
|
... |
|
~~~ |
|
""" |
|
return "".join([input.Declare() for input in self.inputs]) |
|
|
|
def InputDefinitions(self): |
|
""" |
|
~~~ |
|
static const Inputs kCondition[] = {{...},{...}, ...}; |
|
static const Inputs kRdIsRd[] = {{...},{...}, ...}; |
|
... |
|
~~~ |
|
""" |
|
def InputDefinition(test_input): |
|
inputs = [ |
|
"{{{}}}".format(",".join(input)) |
|
for input in test_input.GenerateInputs(self.inputs) |
|
] |
|
|
|
return """static const Inputs k{name}[] = {{ {input} }}; |
|
""".format(name=test_input.name, input=",".join(inputs)) |
|
|
|
return "\n".join(map(InputDefinition, self.test_cases)) |
|
|
|
def TestCaseDefinitions(self): |
|
""" |
|
For simulator tests: |
|
~~~ |
|
{{eq, r0, r0, ...}, |
|
"eq r0 r0 ...", |
|
"Condition_eq_r0_...", |
|
ARRAY_SIZE(kCondition), kCondition}, |
|
... |
|
{{eq, r0, r0, ...}, |
|
"eq r0 r0 ...", |
|
"RdIsRd_eq_r0_...", |
|
ARRAY_SIZE(kRdIsRd), kRdIsRn}, |
|
... |
|
~~~ |
|
|
|
For assembler tests: |
|
~~~ |
|
{{eq, r0, r0, ...}, |
|
"", |
|
"eq r0 r0 ...", |
|
"Condition_eq_r0_...", |
|
... |
|
{{eq, r0, r0, ...}, |
|
"", |
|
"eq r0 r0 ...", |
|
"RdIsRd_eq_r0_..."} |
|
... |
|
{{eq, r0, r0, ...}, |
|
"It eq", |
|
"eq r0 r0 ...", |
|
"RdIsRd_eq_r0_..."} |
|
... |
|
~~~ |
|
""" |
|
def SimulatorTestCaseDefinition(test_case): |
|
test_cases = [ |
|
"""{{ {{ {operands} }}, |
|
"{operands_description}", |
|
"{identifier}", |
|
ARRAY_SIZE(k{test_case_name}), |
|
k{test_case_name} }} |
|
""".format(operands=",".join(operand), |
|
operands_description=" ".join(operand), |
|
identifier=test_case.name + "_" + "_".join(operand), |
|
test_case_name=test_case.name) |
|
for operand, _, _ in test_case.GenerateOperands(self.operands) |
|
] |
|
return ",\n".join(test_cases) |
|
|
|
def AssemblerTestCaseDefinition(test_case): |
|
test_cases = [ |
|
"""{{ {{ {operands} }}, |
|
{in_it_block}, |
|
{it_condition}, |
|
"{operands_description}", |
|
"{identifier}" }} |
|
""".format(operands=",".join(operand), |
|
in_it_block=in_it_block, |
|
it_condition=it_condition, |
|
operands_description=" ".join(operand), |
|
identifier="_".join(operand)) |
|
for operand, in_it_block, it_condition |
|
in test_case.GenerateOperands(self.operands) |
|
] |
|
return ",\n".join(test_cases) |
|
|
|
def MacroAssemblerTestCaseDefinition(test_case): |
|
test_cases = [ |
|
"""{{ {{ {operands} }}, |
|
"{operands_description}", |
|
"{identifier}" }} |
|
""".format(operands=",".join(operand), |
|
operands_description=", ".join(operand), |
|
identifier="_".join(operand)) |
|
for operand, _, _ in test_case.GenerateOperands(self.operands) |
|
] |
|
return ",\n".join(test_cases) |
|
|
|
if self.test_type == "simulator": |
|
return ",\n".join(map(SimulatorTestCaseDefinition, self.test_cases)) |
|
elif self.test_type == "assembler": |
|
return ",\n".join(map(AssemblerTestCaseDefinition, self.test_cases)) |
|
elif self.test_type == "macro-assembler": |
|
return ",\n".join(map(MacroAssemblerTestCaseDefinition, self.test_cases)) |
|
else: |
|
raise Exception("Unrecognized test type \"{}\".".format(self.test_type)) |
|
|
|
def IncludeTraceFiles(self): |
|
""" |
|
~~~ |
|
#include "aarch32/traces/sim-...-a32.h" |
|
#include "aarch32/traces/sim-...-a32.h" |
|
... |
|
~~~ |
|
""" |
|
operands = "-".join(self.operands.GetNames()) |
|
return "".join([ |
|
"#include \"aarch32/traces/" + self.GetTraceFileName(mnemonic) + "\"\n" |
|
for mnemonic in self.mnemonics |
|
]) |
|
|
|
def MacroAssemblerMethodArgs(self): |
|
""" |
|
~~~ |
|
Condition cond, Register rd, Register rm, const Operand& immediate |
|
~~~ |
|
""" |
|
return ", ".join([ |
|
operand.GetArgumentType() + " " + operand.name |
|
for operand in self.operands |
|
]) |
|
|
|
def MacroAssemblerSetISA(self): |
|
""" |
|
Generate code to set the ISA. |
|
""" |
|
if self.test_isa == "t32": |
|
return "masm.UseT32();" |
|
else: |
|
return "masm.UseA32();" |
|
|
|
def CodeInstantiateOperands(self): |
|
""" |
|
~~~ |
|
Condition cond = kTests[i].operands.cond; |
|
Register rd = kTests[i].operands.rd; |
|
... |
|
~~~ |
|
""" |
|
code = "".join([operand.Instantiate() for operand in self.operands]) |
|
if self.test_type in ["simulator", "macro-assembler"]: |
|
# Simulator tests need scratch registers to function and uses |
|
# `UseScratchRegisterScope` to dynamically allocate them. We need to |
|
# exclude all register operands from the list of available scratch |
|
# registers. |
|
# MacroAssembler test also need to ensure that they don't try to run tests |
|
# with registers that are scratch registers; the MacroAssembler contains |
|
# assertions to protect against such usage. |
|
excluded_registers = [ |
|
"scratch_registers.Exclude({});".format(operand.name) |
|
for operand in self.operands.unwrap() |
|
if operand.type_name == "Register" |
|
] |
|
return code + "\n".join(excluded_registers) |
|
return code |
|
|
|
def CodePrologue(self): |
|
""" |
|
~~~ |
|
__ Ldr(rn, MemOperand(input_ptr, offsetof(Inputs, rn))); |
|
__ Ldr(rm, MemOperand(input_ptr, offsetof(Inputs, rm))); |
|
... |
|
~~~ |
|
""" |
|
return "".join([input.Prologue() for input in self.inputs]) |
|
|
|
def CodeEpilogue(self): |
|
""" |
|
~~~ |
|
__ Str(rn, MemOperand(result_ptr, offsetof(Inputs, rn))); |
|
__ Str(rm, MemOperand(result_ptr, offsetof(Inputs, rm))); |
|
... |
|
~~~ |
|
""" |
|
return "".join([input.Epilogue() for input in self.inputs]) |
|
|
|
def CodeParameterList(self): |
|
""" |
|
~~~ |
|
cond, rd, rn, immediate |
|
~~~ |
|
""" |
|
return ", ".join([ |
|
operand.name |
|
for operand in self.operands |
|
]) |
|
|
|
def TracePrintOutputs(self): |
|
""" |
|
~~~ |
|
printf("0x%08" PRIx32, results[i]->outputs[j].cond); |
|
printf(", "); |
|
printf("0x%08" PRIx32, results[i]->outputs[j].rd); |
|
printf(", "); |
|
... |
|
~~~ |
|
""" |
|
return "printf(\", \");".join( |
|
[input.PrintOutput() for input in self.inputs]) |
|
|
|
|
|
def CheckInstantiateResults(self): |
|
""" |
|
~~~ |
|
uint32_t cond = results[i]->outputs[j].cond; |
|
uint32_t rd = results[i]->outputs[j].rd; |
|
... |
|
~~~ |
|
""" |
|
return "".join([input.InstantiateResult() for input in self.inputs]) |
|
|
|
def CheckInstantiateInputs(self): |
|
""" |
|
~~~ |
|
uint32_t cond_input = kTests[i].inputs[j].cond; |
|
uint32_t rd_input = kTests[i].inputs[j].rd; |
|
... |
|
~~~ |
|
""" |
|
return "".join([input.InstantiateInput("_input") for input in self.inputs]) |
|
|
|
def CheckInstantiateReferences(self): |
|
""" |
|
~~~ |
|
uint32_t cond_ref = reference[i].outputs[j].cond; |
|
uint32_t rd_ref = reference[i].outputs[j].rd; |
|
... |
|
~~~ |
|
""" |
|
return "".join([input.InstantiateReference("_ref") for input in self.inputs]) |
|
|
|
def CheckResultsAgainstReferences(self): |
|
""" |
|
~~~ |
|
(cond != cond_ref) || (rd != rd_ref) || ... |
|
~~~ |
|
""" |
|
return " || ".join([input.Compare("", "!=", "_ref") for input in self.inputs]) |
|
|
|
def CheckPrintInput(self): |
|
""" |
|
~~~ |
|
printf("0x%08" PRIx32, cond_input); |
|
printf(", "); |
|
printf("0x%08" PRIx32, rd_input); |
|
printf(", "); |
|
... |
|
~~~ |
|
""" |
|
return "printf(\", \");".join( |
|
[input.PrintInput("_input") for input in self.inputs]) |
|
|
|
def CheckPrintExpected(self): |
|
""" |
|
~~~ |
|
printf("0x%08" PRIx32, cond_ref); |
|
printf(", "); |
|
printf("0x%08" PRIx32, rd_ref); |
|
printf(", "); |
|
... |
|
~~~ |
|
""" |
|
return "printf(\", \");".join( |
|
[input.PrintInput("_ref") for input in self.inputs]) |
|
|
|
def CheckPrintFound(self): |
|
""" |
|
~~~ |
|
printf("0x%08" PRIx32, cond); |
|
printf(", "); |
|
printf("0x%08" PRIx32, rd); |
|
printf(", "); |
|
... |
|
~~~ |
|
""" |
|
return "printf(\", \");".join( |
|
[input.PrintInput("") for input in self.inputs]) |
|
|
|
def TestName(self): |
|
""" |
|
~~~ |
|
SIMULATOR_COND_RD_RN_RM_... |
|
~~~ |
|
""" |
|
return self.test_type.replace("-", "_").upper() + "_" + \ |
|
self.test_name.replace("-", "_").upper() |
|
|
|
def GetTraceFileName(self, mnemonic): |
|
""" |
|
Return the name of a trace file for a given mnemonic. |
|
""" |
|
return self.test_type + "-" + self.test_name + "-" + \ |
|
mnemonic.lower() + ".h" |
|
|
|
def WriteEmptyTraces(self, output_directory): |
|
""" |
|
Write out empty trace files so we can compile the new test cases. |
|
""" |
|
for mnemonic in self.mnemonics: |
|
# The MacroAssembler tests have no traces. |
|
if self.test_type == "macro-assembler": continue |
|
|
|
with open(os.path.join(output_directory, self.GetTraceFileName(mnemonic)), |
|
"w") as f: |
|
code = "static const TestResult *kReference{} = NULL;\n" |
|
f.write(code.format(self.MnemonicToMethodName(mnemonic))) |
|
|
|
def GetIsaGuard(self): |
|
""" |
|
This guard ensure the ISA of the test is enabled. |
|
""" |
|
if 'A32' in self.TestName(): |
|
return 'VIXL_INCLUDE_TARGET_A32' |
|
else: |
|
assert 'T32' in self.TestName() |
|
return 'VIXL_INCLUDE_TARGET_T32' |
|
|
|
|