# 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.
|
|
class OperandBase(object):
|
"""
|
Base class for operands. An operand represents an argument passed to the
|
macro-assembler to generate an instruction. For example, registers, conditions
|
or C++ `Operand` and `MemOperand` objects are operands. We can think of them
|
as "assemble-time" data.
|
|
An operand is described with a type name, corresponding to the C++ type used
|
to represent it (e.g. "Register", "ShiftType", "MemOperand", ...) and a name
|
to identify it.
|
|
Attributes:
|
name Name for the operand. It is used to declare variable names.
|
type_name C++ type for the operand.
|
"""
|
|
def __init__(self, name, type_name):
|
self.name = name
|
self.type_name = type_name
|
|
@staticmethod
|
def __iter__():
|
"""
|
Operand types have to act as an iterator so that `generator.OperandList` can
|
unwrap them (see `OperandWrapper` and `generator.OperandList.unwrap()`).
|
"""
|
raise NotImplementedError()
|
|
@staticmethod
|
def GetArgumentType():
|
"""
|
Return the type to be printed when passing this operand as an argument. For
|
example, we could pass it by value or by reference.
|
"""
|
raise NotImplementedError()
|
|
@staticmethod
|
def Declare():
|
"""
|
Generate code to declare the operand `struct Operands`.
|
"""
|
raise NotImplementedError()
|
|
@staticmethod
|
def Instantiate():
|
"""
|
Generate code to instantiate the operand from inside a `kTests` loop, with
|
`i` being the index variable.
|
"""
|
raise NotImplementedError()
|
|
|
class Operand(OperandBase):
|
"""
|
Representation of a single operand. An operand has different variants
|
(e.g. "r0", "r1", "LSL", ...) and a default one.
|
|
Attributes:
|
variants List of variants the operand can take.
|
default Default variant to use.
|
|
Note that the `variants` and `default` attributes are not used from inside the
|
class. They are public fields used by the `TestCase` object to generate C++.
|
"""
|
|
def __init__(self, name, type_name, variants, default):
|
super().__init__(name, type_name)
|
self.variants = variants
|
self.default = default
|
|
def __iter__(self):
|
"""
|
Iterating over a single operand just yields the operand object.
|
"""
|
yield self
|
|
def GetArgumentType(self):
|
"""
|
A single operand is passed to the macro-assembler by value. We just print
|
the type name as it is.
|
"""
|
return self.type_name
|
|
def Declare(self):
|
"""
|
Generate code to declare the operand as a single member in
|
`struct Operands`.
|
"""
|
return "{type_name} {name};".format(type_name=self.type_name,
|
name=self.name)
|
|
def Instantiate(self):
|
"""
|
Generate code to instantiate the operand as a single local variable.
|
"""
|
code = "{type_name} {name} = kTests[i].operands.{name};"
|
return code.format(type_name=self.type_name, name=self.name)
|
|
|
class OperandWrapper(OperandBase):
|
"""
|
Representation for an operand type which wraps a list of more operands. It
|
corresponds to C++ objects such as `Operand` or `MemOperand`.
|
|
Attributes:
|
operand_list List of operand that this object wraps.
|
"""
|
|
def __init__(self, name, type_name, operand_list):
|
super().__init__(name, type_name)
|
self.operand_list = operand_list
|
|
def __iter__(self):
|
"""
|
Iterate through the list of operands. This is required by
|
`OperandList.unwrap()`.
|
"""
|
return iter(self.operand_list)
|
|
def GetArgumentType(self):
|
"""
|
An operand wrapper object will be passed to the macro-assembler by
|
reference.
|
"""
|
return "const " + self.type_name + "&"
|
|
def Declare(self):
|
"""
|
An `OperandWrapper` object does not need to be declared in
|
`struct Operands`. Although we do need to declare all underlying operands.
|
"""
|
return "\n".join([operand.Declare() for operand in self.operand_list])
|
|
def Instantiate(self):
|
"""
|
Instantiate the underlying operands first and then finally instantiate the
|
wrapper object.
|
|
For example, if the object represents a C++ `Operand` type for a shifted
|
register we would get:
|
|
~~~
|
Register rm = kTests[i].operands.rm;
|
Shift shift_type = kTests[i].operands.shift_type;
|
uint32_t amount = kTests[i].operands.amount;
|
Operand op(rm, shift_type, amount);
|
~~~
|
"""
|
instantiate_wrapped_operands = "\n".join([
|
operand.Instantiate()
|
for operand in self.operand_list
|
])
|
instantiate_this = "{type_name} {name}({arguments});".format(
|
type_name=self.type_name,
|
name=self.name,
|
arguments=", ".join([operand.name for operand in self.operand_list]))
|
return instantiate_wrapped_operands + "\n" + instantiate_this
|
|
|
class Input(object):
|
"""
|
Base class for all input types instantiated from a JSON description. This
|
class should not be instantiated directly, instead, we create subclasses for
|
each kind of input we have.
|
|
As opposed to operands, an input represents data passed to an instruction at
|
runtime. For example, it will be the value you write to a register before
|
executing the instruction under test.
|
|
Attributes:
|
name Name of the input. It is used to declare variable names.
|
|
values List of values this input can take.
|
default Default value to use.
|
"""
|
|
def __init__(self, name, values, default):
|
self.name = name
|
|
self.values = values
|
self.default = default
|
|
@staticmethod
|
def Prologue():
|
"""
|
Return a string describing what C++ code to emit before the instruction
|
under test is emitted.
|
"""
|
raise NotImplementedError()
|
|
@staticmethod
|
def Epilogue():
|
"""
|
Return a string describing what C++ code to emit after the instruction under
|
test is emitted.
|
"""
|
raise NotImplementedError()
|
|
@staticmethod
|
def Declare():
|
"""
|
Generate code to declare the input in `struct Inputs`.
|
"""
|
raise NotImplementedError()
|
|
@staticmethod
|
def PrintInput(suffix = ""):
|
"""
|
Generate code to print the input referred to by `self.name`. Optionally add
|
`suffix` to the input's name.
|
"""
|
raise NotImplementedError()
|
|
@staticmethod
|
def PrintOutput():
|
"""
|
Generate code to print the input from the result buffer, indexed with `i`
|
and `j`.
|
"""
|
raise NotImplementedError()
|
|
@staticmethod
|
def InstantiateResult(suffix = ""):
|
"""
|
Generate code to instantiate an input from the result buffer, indexed with
|
`i`. Optionally add `suffix` to the input's name.
|
"""
|
raise NotImplementedError()
|
|
@staticmethod
|
def InstantiateInput(suffix = ""):
|
"""
|
Generate code to instantiate an input from the input buffer, indexed with
|
`i`. Optionally add `suffix` to the input's name.
|
"""
|
raise NotImplementedError()
|
|
@staticmethod
|
def InstantiateReference(suffix = ""):
|
"""
|
Generate code to instantiate an input from the reference buffer, indexed
|
with `i`. Optionally add `suffix` to the input's name.
|
"""
|
raise NotImplementedError()
|
|
@staticmethod
|
def Compare(left_suffix, operand, right_suffix):
|
"""
|
Generate code as a C++ expression comparing two inputs of this type.
|
"""
|
raise NotImplementedError()
|
|
|
class Scalar(Input):
|
"""
|
Base class for inputs that are represented as a single scalar value.
|
Subclasses should implement `TypeName()`, `Pri()` and `NDigit()` to specify
|
how they should be represented and printed, see the `U32` class for an
|
example.
|
"""
|
|
@staticmethod
|
def TypeName():
|
"""
|
Return the type name as used to declare and instantiate this input.
|
"""
|
raise NotImplementedError()
|
|
@staticmethod
|
def Pri():
|
"""
|
Return the format string used to generate a call to `printf` to print this
|
input type. For example, "PRIx32".
|
"""
|
raise NotImplementedError()
|
|
@staticmethod
|
def NDigit():
|
"""
|
Return the number of digits to use to print this input type.
|
"""
|
raise NotImplementedError()
|
|
def Declare(self):
|
"""
|
A scalar input is declared as a single member in `struct Inputs`.
|
"""
|
return "{type_name} {name};".format(type_name=self.TypeName(),
|
name=self.name)
|
|
def PrintInput(self, suffix = ""):
|
code = "printf(\"0x%0{n_digit}\" {pri}, {name});"
|
return code.format(n_digit=self.NDigit(), pri=self.Pri(),
|
name=self.name + suffix)
|
|
def PrintOutput(self):
|
code = "printf(\"0x%0{n_digit}\" {pri}, results[i]->outputs[j].{name});"
|
return code.format(n_digit=self.NDigit(), pri=self.Pri(), name=self.name)
|
|
def InstantiateResult(self, suffix = ""):
|
code = "{type_name} {name}{suffix} = results[i]->outputs[j].{name};"
|
return code.format(type_name=self.TypeName(), name=self.name, suffix=suffix)
|
|
def InstantiateInput(self, suffix = ""):
|
code = "{type_name} {name}{suffix} = kTests[i].inputs[j].{name};"
|
return code.format(type_name=self.TypeName(), name=self.name, suffix=suffix)
|
|
def InstantiateReference(self, suffix = ""):
|
code = "{type_name} {name}{suffix} = reference[i].outputs[j].{name};"
|
return code.format(type_name=self.TypeName(), name=self.name, suffix=suffix)
|
|
def Compare(self, left_suffix, operand, right_suffix):
|
return """
|
({name}{left_suffix} {operand} {name}{right_suffix})
|
""".format(name=self.name, left_suffix=left_suffix, operand=operand,
|
right_suffix=right_suffix)
|
|
|
class U32(Scalar):
|
"""
|
Base class for inputs that can be represented as 32 bit unsigned words.
|
"""
|
|
@staticmethod
|
def TypeName():
|
return "uint32_t"
|
|
@staticmethod
|
def Pri():
|
return "PRIx32"
|
|
@staticmethod
|
def NDigit():
|
return 8
|
|
|
class F64(Scalar):
|
@staticmethod
|
def TypeName():
|
return "uint64_t"
|
|
@staticmethod
|
def Pri():
|
return "PRIx64"
|
|
@staticmethod
|
def NDigit():
|
return 16
|
|
def PrintInput(self, suffix = ""):
|
code = "printf(\"0x%0{n_digit}\" {pri} \"(%g)\", {name}, RawbitsToDouble({name}));"
|
return code.format(n_digit=self.NDigit(), pri=self.Pri(),
|
name=self.name + suffix)
|
|
|
class Register(U32):
|
"""
|
Description of a Register input. The `Prologue` and `Epilogue` methods
|
describe what C++ code to emit to set and record the value of a register
|
before and after executing an instruction.
|
"""
|
|
def Prologue(self):
|
code = "__ Ldr({name}, MemOperand(input_ptr, offsetof(Inputs, {name})));"
|
return code.format(name=self.name)
|
|
def Epilogue(self):
|
code = "__ Str({name}, MemOperand(result_ptr, offsetof(Inputs, {name})));"
|
return code.format(name=self.name)
|
|
|
class DRegisterF64(F64):
|
def Prologue(self):
|
code = "__ Vldr({name}, MemOperand(input_ptr, offsetof(Inputs, {name})));"
|
return code.format(name=self.name)
|
|
def Epilogue(self):
|
code = "__ Vstr({name}, MemOperand(result_ptr, offsetof(Inputs, {name})));"
|
return code.format(name=self.name)
|
|
|
class NZCV(U32):
|
"""
|
Description of NZCV flags as inputs to an instruction.
|
|
The `Prologue` and `Epilogue` methods describe what C++ code to emit to set
|
and record the NZCV flags before and after emitting the instruction under
|
test.
|
"""
|
|
def Prologue(self):
|
# When setting the `NZCV` flags, we need to make sure we do not override the
|
# `Q` bit. Therefore we use two scratch registers that we push on the stack
|
# first to allow the instruction to use them as operands.
|
code = """{{
|
UseScratchRegisterScope temp_registers(&masm);
|
Register nzcv_bits = temp_registers.Acquire();
|
Register saved_q_bit = temp_registers.Acquire();
|
// Save the `Q` bit flag.
|
__ Mrs(saved_q_bit, APSR);
|
__ And(saved_q_bit, saved_q_bit, QFlag);
|
// Set the `NZCV` and `Q` flags together.
|
__ Ldr(nzcv_bits, MemOperand(input_ptr, offsetof(Inputs, {})));
|
__ Orr(nzcv_bits, nzcv_bits, saved_q_bit);
|
__ Msr(APSR_nzcvq, nzcv_bits);
|
}}
|
"""
|
return code.format(self.name)
|
|
def Epilogue(self):
|
code = """{{
|
UseScratchRegisterScope temp_registers(&masm);
|
Register nzcv_bits = temp_registers.Acquire();
|
__ Mrs(nzcv_bits, APSR);
|
// Only record the NZCV bits.
|
__ And(nzcv_bits, nzcv_bits, NZCVFlag);
|
__ Str(nzcv_bits, MemOperand(result_ptr, offsetof(Inputs, {})));
|
}}
|
"""
|
return code.format(self.name)
|
|
|
class Q(U32):
|
"""
|
Description of the Q flag as inputs to an instruction.
|
|
The `Prologue` and `Epilogue` methods describe what C++ code to emit to set
|
and record the Q flag before and after emitting the instruction under test.
|
"""
|
|
def Prologue(self):
|
# When clearing or setting the `Q` bit, we need to make sure the `NZCV`
|
# flags are not overriden. Therefore we use two scratch registers that we
|
# push on the stack first to allow the instruction to use them as operands.
|
code = """{{
|
UseScratchRegisterScope temp_registers(&masm);
|
Register q_bit = temp_registers.Acquire();
|
Register saved_nzcv_bits = temp_registers.Acquire();
|
// Save the `NZCV` flags.
|
__ Mrs(saved_nzcv_bits, APSR);
|
__ And(saved_nzcv_bits, saved_nzcv_bits, NZCVFlag);
|
// Set the `NZCV` and `Q` flags together.
|
__ Ldr(q_bit, MemOperand(input_ptr, offsetof(Inputs, {})));
|
__ Orr(q_bit, q_bit, saved_nzcv_bits);
|
__ Msr(APSR_nzcvq, q_bit);
|
}}
|
"""
|
return code.format(self.name)
|
|
def Epilogue(self):
|
code = """{{
|
UseScratchRegisterScope temp_registers(&masm);
|
Register q_bit = temp_registers.Acquire();
|
__ Mrs(q_bit, APSR);
|
// Only record the Q bit.
|
__ And(q_bit, q_bit, QFlag);
|
__ Str(q_bit, MemOperand(result_ptr, offsetof(Inputs, {})));
|
}}
|
"""
|
return code.format(self.name)
|
|
|
class GE(U32):
|
"""
|
Description of the GE flag as inputs to an instruction.
|
|
The `Prologue` and `Epilogue` methods describe what C++ code to emit to set
|
and record the GE flags before and after emitting the instruction under test.
|
"""
|
|
def Prologue(self):
|
# We need a scratch register to load the `GE` flags.
|
code = """{{
|
UseScratchRegisterScope temp_registers(&masm);
|
Register ge_bits = temp_registers.Acquire();
|
__ Ldr(ge_bits, MemOperand(input_ptr, offsetof(Inputs, {})));
|
__ Msr(APSR_g, ge_bits);
|
}}
|
"""
|
return code.format(self.name)
|
|
def Epilogue(self):
|
code = """{{
|
UseScratchRegisterScope temp_registers(&masm);
|
Register ge_bits = temp_registers.Acquire();
|
__ Mrs(ge_bits, APSR);
|
// Only record the GE bits.
|
__ And(ge_bits, ge_bits, GEFlags);
|
__ Str(ge_bits, MemOperand(result_ptr, offsetof(Inputs, {})));
|
}}
|
"""
|
return code.format(self.name)
|
|
|
class FPSCR(U32):
|
def Prologue(self):
|
# We need a scratch register to load the `FPCSR` flags.
|
code = """{{
|
UseScratchRegisterScope temp_registers(&masm);
|
Register fpsr_bits = temp_registers.Acquire();
|
__ Ldr(fpsr_bits, MemOperand(input_ptr, offsetof(Inputs, {})));
|
__ Vmsr(FPSCR, fpsr_bits);
|
}}
|
"""
|
return code.format(self.name)
|
|
def Epilogue(self):
|
code = """{{
|
UseScratchRegisterScope temp_registers(&masm);
|
Register fpsr_bits = temp_registers.Acquire();
|
__ Vmrs(RegisterOrAPSR_nzcv(fpsr_bits.GetCode()), FPSCR);
|
__ Str(fpsr_bits, MemOperand(result_ptr, offsetof(Inputs, {})));
|
}}
|
"""
|
return code.format(self.name)
|
|
|
class MemOperand(Input):
|
"""
|
Description of a memory location input, used to test a `MemOperand` operand.
|
|
A memory location input is a compound type and is represented as an
|
array of two `uint32_t` values, an "offset" and a "data":
|
|
~~~
|
{
|
0x0, // Offset used to record the base register in case it was
|
// updated.
|
0xabababab // 32 bit value in memory the instruction should work with.
|
}
|
~~~
|
"""
|
|
def Declare(self):
|
"""
|
Declare the input as a two element array.
|
"""
|
return "uint32_t {name}[2];".format(name=self.name)
|
|
def PrintInput(self, suffix = ""):
|
code = '''printf("{{0x%08" PRIx32 ", 0x%08" PRIx32 "}}",
|
{name}[0], {name}[1]);'''
|
return code.format(name=self.name + suffix)
|
|
def PrintOutput(self):
|
code = '''printf("{{0x%08" PRIx32 ", 0x%08" PRIx32 "}}",
|
results[i]->outputs[j].{name}[0],
|
results[i]->outputs[j].{name}[1]);'''
|
return code.format(name=self.name)
|
|
def InstantiateResult(self, suffix = ""):
|
code = """uint32_t {name}{suffix}[2] = {{
|
results[i]->outputs[j].{name}[0],
|
results[i]->outputs[j].{name}[1]
|
}};
|
"""
|
return code.format(name=self.name, suffix=suffix)
|
|
def InstantiateInput(self, suffix = ""):
|
code = """uint32_t {name}{suffix}[2] = {{
|
kTests[i].inputs[j].{name}[0],
|
kTests[i].inputs[j].{name}[1]
|
}};
|
"""
|
return code.format(name=self.name, suffix=suffix)
|
|
def InstantiateReference(self, suffix = ""):
|
code = """uint32_t {name}{suffix}[2] = {{
|
results[i]->outputs[j].{name}[0],
|
results[i]->outputs[j].{name}[1]
|
}};
|
"""
|
return code.format(name=self.name, suffix=suffix)
|
|
def Compare(self, left_suffix, operand, right_suffix):
|
return """
|
(({name}{left_suffix}[0] {operand} {name}{right_suffix}[0]) &&
|
({name}{left_suffix}[1] {operand} {name}{right_suffix}[1]))
|
""".format(name=self.name, left_suffix=left_suffix, operand=operand,
|
right_suffix=right_suffix)
|
|
def Prologue(self):
|
return """
|
// Allocate 4 bytes for the instruction to work with.
|
scratch_memory_buffers[i] = new byte[4];
|
{{
|
UseScratchRegisterScope temp_registers(&masm);
|
|
Register {name}_tmp = temp_registers.Acquire();
|
Register base_register = {name}.GetBaseRegister();
|
|
// Write the expected data into the scratch buffer.
|
__ Mov(base_register, Operand::From(scratch_memory_buffers[i]));
|
__ Ldr({name}_tmp, MemOperand(input_ptr, offsetof(Inputs, {name}) + 4));
|
__ Str({name}_tmp, MemOperand(base_register));
|
|
// Compute the address to put into the base register so that the
|
// `MemOperand` points to the right location.
|
// TODO: Support more kinds of `MemOperand`.
|
if (!{name}.IsPostIndex()) {{
|
if ({name}.IsImmediate()) {{
|
if ({name}.GetSign().IsPlus()) {{
|
__ Mov({name}_tmp, {name}.GetOffsetImmediate());
|
__ Sub(base_register, base_register, {name}_tmp);
|
}} else {{
|
__ Mov({name}_tmp, -{name}.GetOffsetImmediate());
|
__ Add(base_register, base_register, {name}_tmp);
|
}}
|
}} else if ({name}.IsShiftedRegister()) {{
|
__ Mov({name}_tmp, Operand({name}.GetOffsetRegister(),
|
{name}.GetShift(),
|
{name}.GetShiftAmount()));
|
if ({name}.GetSign().IsPlus()) {{
|
__ Sub(base_register, base_register, {name}_tmp);
|
}} else {{
|
__ Add(base_register, base_register, {name}_tmp);
|
}}
|
}}
|
}}
|
}}
|
""".format(name=self.name)
|
|
def Epilogue(self):
|
# TODO: This generated code does not support recording the state for
|
# instructions where the base register is the same as another register used
|
# in the instruction. It is possible to do so but requires more temporary
|
# registers which is not trivial to implement without
|
# `UseScratchRegisterScope`. We will be able to lift this restriction when
|
# it is implemented.
|
return """{{
|
UseScratchRegisterScope temp_registers(&masm);
|
Register {name}_tmp = temp_registers.Acquire();
|
Register base_register = {name}.GetBaseRegister();
|
|
// Compute the address of the scratch buffer by from the base register. If
|
// the instruction has updated the base register, we will be able to
|
// record it.
|
if (!{name}.IsPostIndex()) {{
|
if ({name}.IsImmediate()) {{
|
if ({name}.GetSign().IsPlus()) {{
|
__ Mov({name}_tmp, {name}.GetOffsetImmediate());
|
__ Add(base_register, base_register, {name}_tmp);
|
}} else {{
|
__ Mov({name}_tmp, -{name}.GetOffsetImmediate());
|
__ Sub(base_register, base_register, {name}_tmp);
|
}}
|
}} else if ({name}.IsShiftedRegister()) {{
|
__ Mov({name}_tmp, Operand({name}.GetOffsetRegister(),
|
{name}.GetShift(),
|
{name}.GetShiftAmount()));
|
if ({name}.GetSign().IsPlus()) {{
|
__ Add(base_register, base_register, {name}_tmp);
|
}} else {{
|
__ Sub(base_register, base_register, {name}_tmp);
|
}}
|
}}
|
}}
|
|
// Record the value of the base register, as an offset from the scratch
|
// buffer's address.
|
__ Mov({name}_tmp, Operand::From(scratch_memory_buffers[i]));
|
__ Sub(base_register, base_register, {name}_tmp);
|
__ Str(base_register, MemOperand(result_ptr, offsetof(Inputs, {name})));
|
|
// Record the 32 bit word from memory.
|
__ Ldr({name}_tmp, MemOperand({name}_tmp));
|
__ Str({name}_tmp, MemOperand(result_ptr, offsetof(Inputs, {name}) + 4));
|
}}
|
""".format(name=self.name)
|
