ROSE
0.11.27.0
|
Defines RISC operators for the MultiSemantics domain.
Invoking a RISC operation in the MultiSemantics domain causes the same operation to be invoked for each of its subdomains provided all arguments are valid in those subdomains (i.e., SValue::is_valid() returns true).
Definition at line 245 of file MultiSemantics2.h.
#include <MultiSemantics2.h>
Classes | |
class | Cursor |
Iterates over valid subdomains whose inputs are valid. More... | |
Public Member Functions | |
virtual BaseSemantics::RiscOperatorsPtr | create (const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &solver=SmtSolverPtr()) const ROSE_OVERRIDE |
Virtual allocating constructor. More... | |
virtual BaseSemantics::RiscOperatorsPtr | create (const BaseSemantics::StatePtr &state, const SmtSolverPtr &solver=SmtSolverPtr()) const ROSE_OVERRIDE |
Virtual allocating constructor. More... | |
virtual size_t | add_subdomain (const BaseSemantics::RiscOperatorsPtr &subdomain, const std::string &name, bool activate=true) |
Add a subdomain to this MultiSemantics domain. More... | |
virtual Formatter & | get_formatter () |
Returns a formatter containing the names of the subdomains. More... | |
virtual size_t | nsubdomains () const |
Returns the number of subdomains added to this MultiDomain. More... | |
virtual BaseSemantics::RiscOperatorsPtr | get_subdomain (size_t idx) const |
Returns the RiscOperators for a subdomain. More... | |
virtual bool | is_active (size_t idx) const |
Returns true if a subdomain is active. More... | |
virtual void | clear_active (size_t idx) |
Makes a subdomain inactive. More... | |
virtual void | set_active (size_t idx, bool status) |
Makes a subdomain active or inactive. More... | |
virtual void | before (size_t idx) |
Called before each subdomain RISC operation. More... | |
virtual void | after (size_t idx) |
Called after each subdomain RISC operation. More... | |
virtual SValuePtr | svalue_empty (size_t nbits) |
Convenience function for SValue::create_empty(). More... | |
virtual void | print (std::ostream &o, BaseSemantics::Formatter &) const ROSE_OVERRIDE |
Print multi-line output for this object. | |
virtual void | startInstruction (SgAsmInstruction *insn) ROSE_OVERRIDE |
virtual void | finishInstruction (SgAsmInstruction *insn) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | undefined_ (size_t nbits) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | unspecified_ (size_t nbits) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | number_ (size_t nbits, uint64_t value) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | boolean_ (bool) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | bottom_ (size_t nbits) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | filterCallTarget (const BaseSemantics::SValuePtr &) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | filterReturnTarget (const BaseSemantics::SValuePtr &) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | filterIndirectJumpTarget (const BaseSemantics::SValuePtr &) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | and_ (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &b) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | or_ (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &b) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | xor_ (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &b) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | invert (const BaseSemantics::SValuePtr &a) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | extract (const BaseSemantics::SValuePtr &a, size_t begin_bit, size_t end_bit) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | concat (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &b) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | leastSignificantSetBit (const BaseSemantics::SValuePtr &a) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | mostSignificantSetBit (const BaseSemantics::SValuePtr &a) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | rotateLeft (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &nbits) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | rotateRight (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &nbits) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | shiftLeft (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &nbits) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | shiftRight (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &nbits) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | shiftRightArithmetic (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &nbits) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | equalToZero (const BaseSemantics::SValuePtr &a) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | ite (const BaseSemantics::SValuePtr &cond, const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &b) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | unsignedExtend (const BaseSemantics::SValuePtr &a, size_t new_width) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | signExtend (const BaseSemantics::SValuePtr &a, size_t new_width) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | add (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &b) ROSE_OVERRIDE |
virtual BaseSemantics::SValuePtr | addWithCarries (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &b, const BaseSemantics::SValuePtr &c, BaseSemantics::SValuePtr &carry_out) ROSE_OVERRIDE |
Used for printing RISC operators with formatting. More... | |
virtual BaseSemantics::SValuePtr | negate (const BaseSemantics::SValuePtr &a) ROSE_OVERRIDE |
Two's complement. More... | |
virtual BaseSemantics::SValuePtr | signedDivide (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &b) ROSE_OVERRIDE |
Divides two signed values. More... | |
virtual BaseSemantics::SValuePtr | signedModulo (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &b) ROSE_OVERRIDE |
Calculates modulo with signed values. More... | |
virtual BaseSemantics::SValuePtr | signedMultiply (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &b) ROSE_OVERRIDE |
Multiplies two signed values. More... | |
virtual BaseSemantics::SValuePtr | unsignedDivide (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &b) ROSE_OVERRIDE |
Divides two unsigned values. More... | |
virtual BaseSemantics::SValuePtr | unsignedModulo (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &b) ROSE_OVERRIDE |
Calculates modulo with unsigned values. More... | |
virtual BaseSemantics::SValuePtr | unsignedMultiply (const BaseSemantics::SValuePtr &a, const BaseSemantics::SValuePtr &b) ROSE_OVERRIDE |
Multiply two unsigned values. More... | |
virtual BaseSemantics::SValuePtr | fpFromInteger (const BaseSemantics::SValuePtr &, SgAsmFloatType *) ROSE_OVERRIDE |
Construct a floating-point value from an integer value. More... | |
virtual BaseSemantics::SValuePtr | fpToInteger (const BaseSemantics::SValuePtr &, SgAsmFloatType *, const BaseSemantics::SValuePtr &) ROSE_OVERRIDE |
Construct an integer value from a floating-point value. More... | |
virtual BaseSemantics::SValuePtr | fpConvert (const BaseSemantics::SValuePtr &, SgAsmFloatType *, SgAsmFloatType *) ROSE_OVERRIDE |
Convert from one floating-point type to another. More... | |
virtual BaseSemantics::SValuePtr | fpIsNan (const BaseSemantics::SValuePtr &, SgAsmFloatType *) ROSE_OVERRIDE |
Whether a floating-point value is a special not-a-number bit pattern. More... | |
virtual BaseSemantics::SValuePtr | fpIsDenormalized (const BaseSemantics::SValuePtr &, SgAsmFloatType *) ROSE_OVERRIDE |
Whether a floating-point value is denormalized. More... | |
virtual BaseSemantics::SValuePtr | fpIsZero (const BaseSemantics::SValuePtr &, SgAsmFloatType *) ROSE_OVERRIDE |
Whether a floating-point value is equal to zero. More... | |
virtual BaseSemantics::SValuePtr | fpIsInfinity (const BaseSemantics::SValuePtr &, SgAsmFloatType *) ROSE_OVERRIDE |
Whether a floating-point value is infinity. More... | |
virtual BaseSemantics::SValuePtr | fpSign (const BaseSemantics::SValuePtr &, SgAsmFloatType *) ROSE_OVERRIDE |
Sign of floating-point value. More... | |
virtual BaseSemantics::SValuePtr | fpEffectiveExponent (const BaseSemantics::SValuePtr &, SgAsmFloatType *) ROSE_OVERRIDE |
Exponent of floating-point value. More... | |
virtual BaseSemantics::SValuePtr | fpAdd (const BaseSemantics::SValuePtr &, const BaseSemantics::SValuePtr &, SgAsmFloatType *) ROSE_OVERRIDE |
Add two floating-point values. More... | |
virtual BaseSemantics::SValuePtr | fpSubtract (const BaseSemantics::SValuePtr &, const BaseSemantics::SValuePtr &, SgAsmFloatType *) ROSE_OVERRIDE |
Subtract one floating-point value from another. More... | |
virtual BaseSemantics::SValuePtr | fpMultiply (const BaseSemantics::SValuePtr &, const BaseSemantics::SValuePtr &, SgAsmFloatType *) ROSE_OVERRIDE |
Multiply two floating-point values. More... | |
virtual BaseSemantics::SValuePtr | fpDivide (const BaseSemantics::SValuePtr &, const BaseSemantics::SValuePtr &, SgAsmFloatType *) ROSE_OVERRIDE |
Divide one floating-point value by another. More... | |
virtual BaseSemantics::SValuePtr | fpSquareRoot (const BaseSemantics::SValuePtr &, SgAsmFloatType *) ROSE_OVERRIDE |
Square root. More... | |
virtual BaseSemantics::SValuePtr | fpRoundTowardZero (const BaseSemantics::SValuePtr &, SgAsmFloatType *) ROSE_OVERRIDE |
Round toward zero. More... | |
virtual BaseSemantics::SValuePtr | reinterpret (const BaseSemantics::SValuePtr &, SgAsmType *) ROSE_OVERRIDE |
Reinterpret an expression as a different type. More... | |
virtual BaseSemantics::SValuePtr | readRegister (RegisterDescriptor reg, const BaseSemantics::SValuePtr &dflt) ROSE_OVERRIDE |
Reads a value from a register. More... | |
virtual BaseSemantics::SValuePtr | peekRegister (RegisterDescriptor reg, const BaseSemantics::SValuePtr &dflt) ROSE_OVERRIDE |
Obtain a register value without side effects. More... | |
virtual void | writeRegister (RegisterDescriptor reg, const BaseSemantics::SValuePtr &a) ROSE_OVERRIDE |
Writes a value to a register. More... | |
virtual BaseSemantics::SValuePtr | readMemory (RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &dflt, const BaseSemantics::SValuePtr &cond) ROSE_OVERRIDE |
Reads a value from memory. More... | |
virtual BaseSemantics::SValuePtr | peekMemory (RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &dflt) ROSE_OVERRIDE |
Read memory without side effects. More... | |
virtual void | writeMemory (RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &data, const BaseSemantics::SValuePtr &cond) ROSE_OVERRIDE |
Writes a value to memory. More... | |
![]() | |
virtual SValuePtr | protoval () const |
Property: Prototypical semantic value. More... | |
virtual void | interrupt (int majr, int minr) |
Invoked for instructions that cause an interrupt. More... | |
virtual void | interrupt (const SValuePtr &majr, const SValuePtr &minr, const SValuePtr &enabled) |
Invoked for instructions that cause an interrupt. More... | |
virtual SValuePtr | convert (const SValuePtr &a, SgAsmType *srcType, SgAsmType *dstType) |
Convert value from one type to another. More... | |
virtual SmtSolverPtr | solver () const |
Property: Satisfiability module theory (SMT) solver. More... | |
virtual void | solver (const SmtSolverPtr &s) |
Property: Satisfiability module theory (SMT) solver. More... | |
const HotPatch & | hotPatch () const |
Property: Post-instruction hot patches. More... | |
HotPatch & | hotPatch () |
Property: Post-instruction hot patches. More... | |
void | hotPatch (const HotPatch &hp) |
Property: Post-instruction hot patches. More... | |
virtual StatePtr | currentState () const |
Property: Current semantic state. More... | |
virtual void | currentState (const StatePtr &s) |
Property: Current semantic state. More... | |
virtual StatePtr | initialState () const |
Property: Optional lazily updated initial state. More... | |
virtual void | initialState (const StatePtr &s) |
Property: Optional lazily updated initial state. More... | |
virtual const std::string & | name () const |
Property: Name used for debugging. More... | |
virtual void | name (const std::string &s) |
Property: Name used for debugging. More... | |
void | print (std::ostream &stream, const std::string prefix="") const |
Print multi-line output for this object. | |
virtual SValuePtr | readRegister (RegisterDescriptor reg) |
Reads a value from a register. More... | |
SValuePtr | peekRegister (RegisterDescriptor reg) |
Obtain a register value without side effects. More... | |
Static Public Member Functions | |
static RiscOperatorsPtr | instance (const RegisterDictionary *regdict) |
Static allocating constructor. More... | |
static RiscOperatorsPtr | instance (const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &solver=SmtSolverPtr()) |
static RiscOperatorsPtr | instance (const BaseSemantics::StatePtr &state, const SmtSolverPtr &solver=SmtSolverPtr()) |
static RiscOperatorsPtr | promote (const BaseSemantics::RiscOperatorsPtr &ops) |
![]() | |
static RiscOperatorsPtr | promote (const RiscOperatorsPtr &x) |
Protected Types | |
typedef std::vector< BaseSemantics::RiscOperatorsPtr > | Subdomains |
Protected Member Functions | |
RiscOperators (const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &solver=SmtSolverPtr()) | |
RiscOperators (const BaseSemantics::StatePtr &state, const SmtSolverPtr &solver=SmtSolverPtr()) | |
![]() | |
RiscOperators (const SValuePtr &protoval, const SmtSolverPtr &solver=SmtSolverPtr()) | |
RiscOperators (const StatePtr &state, const SmtSolverPtr &solver=SmtSolverPtr()) | |
Protected Attributes | |
Subdomains | subdomains |
std::vector< bool > | active |
Formatter | formatter |
Additional Inherited Members | |
![]() | |
typedef RiscOperatorsPtr | Ptr |
Shared-ownership pointer for a RiscOperators object. More... | |
|
inlinestatic |
Static allocating constructor.
This constructor creates a new MultiDomain RiscOperators object that does't have any subdomains. The subdomains should be added before using this object. The regdict
argument is not used in this class and is only present for consistency with other classes and for subclasses.
Definition at line 273 of file MultiSemantics2.h.
References Rose::BinaryAnalysis::InstructionSemantics2::MultiSemantics::SValue::instance().
Referenced by create().
|
inlinevirtual |
Virtual allocating constructor.
The protoval
is a prototypical semantic value that is used as a factory to create additional values as necessary via its virtual constructors. The state upon which the RISC operations operate must be set by modifying the currentState property. An optional SMT solver may be specified (see solver).
Implements Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
Definition at line 289 of file MultiSemantics2.h.
References instance(), and Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators::solver().
|
inlinevirtual |
Virtual allocating constructor.
The supplied state
is that upon which the RISC operations operate and is also used to define the prototypical semantic value. Other states can be supplied by setting currentState. The prototypical semantic value is used as a factory to create additional values as necessary via its virtual constructors. An optional SMT solver may be specified (see solver).
Implements Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
Definition at line 294 of file MultiSemantics2.h.
References instance(), and Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators::solver().
|
virtual |
Add a subdomain to this MultiSemantics domain.
Returns the identifier (index) used for this subdomain. The name
is optional and used mostly for debugging; it is also added to the formatter and can be used when printing a semantic value. The activate
argument indicates whether this subdomain is activated (default is true). Activated subdomains will participate in RISC operations if their arguments are defined. See also, is_active(), set_active(), and clear_active().
|
inlinevirtual |
Returns a formatter containing the names of the subdomains.
Definition at line 315 of file MultiSemantics2.h.
|
inlinevirtual |
Returns the number of subdomains added to this MultiDomain.
Definition at line 320 of file MultiSemantics2.h.
|
virtual |
Returns the RiscOperators for a subdomain.
The idx
need not be valid.
|
inlinevirtual |
Returns true if a subdomain is active.
Active subdomains participate in MultiSemantics RISC operations, provided all their operands are valid. This method returns false if idx
is out of range or the subdomain's RiscOperators are null.
Definition at line 330 of file MultiSemantics2.h.
|
inlinevirtual |
Makes a subdomain inactive.
The subdomain's RiscOperators object is not removed or deleted by this method; the subdomain can be made active again at a later time.
Definition at line 336 of file MultiSemantics2.h.
References set_active().
|
virtual |
Makes a subdomain active or inactive.
When making a subdomain inactive, its RiscOperators object is not removed or deleted, and it can be reactivated later. An invalid idx
is ignored when deactivating; it must refer to a valid subdomain when activating.
Referenced by clear_active().
|
inlinevirtual |
Called before each subdomain RISC operation.
The default implementation does nothing, but subclasses can override this to do interesting things. The idx
is the index of the subdomain that's about to be called.
Definition at line 347 of file MultiSemantics2.h.
|
inlinevirtual |
Called after each subdomain RISC operation.
The default implementation does nothing, but subclasses can override this to do interesting things. The idx
is the index of the subdomain that was just called.
Definition at line 351 of file MultiSemantics2.h.
|
inlinevirtual |
Convenience function for SValue::create_empty().
Definition at line 354 of file MultiSemantics2.h.
References Rose::BinaryAnalysis::InstructionSemantics2::MultiSemantics::SValue::promote(), and Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators::protoval().
|
virtual |
Used for printing RISC operators with formatting.
The usual way to use this is:
Since specifying a line prefix string for indentation purposes is such a common use case, the indentation can be given instead of a format, as in the following code that indents the prefixes each line of the expression with four spaces.
The carry_out value is 11100100.
The width of a
and b
must be equal; c
must have a width of one bit; the return value and carry_out
will be the same width as a
and b
. The carry_out
value is allocated herein.
Implements Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Two's complement.
The return value will have the same width as the operand.
Implements Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Divides two signed values.
The width of the result will be the same as the width of the dividend
.
Implements Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Calculates modulo with signed values.
The width of the result will be the same as the width of operand b
.
Implements Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Multiplies two signed values.
The width of the result will be the sum of the widths of a
and b
.
Implements Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Divides two unsigned values.
The width of the result is the same as the width of the dividend
.
Implements Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Calculates modulo with unsigned values.
The width of the result is the same as the width of operand b
.
Implements Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Multiply two unsigned values.
The width of the result is the sum of the widths of a
and b
.
Implements Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Construct a floating-point value from an integer value.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Construct an integer value from a floating-point value.
The bits of fpValue
are interpreted according to the fpType
and converted to a signed integer value that fits in integerWidth
bits. This is done by truncating the fractional part of the floating point number, thus rounding toward zero. If fpValue
is not a number then dflt
is returned.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Convert from one floating-point type to another.
Converts the floating-point value a
having type aType
to the return value having retType
.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Whether a floating-point value is a special not-a-number bit pattern.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Whether a floating-point value is denormalized.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Whether a floating-point value is equal to zero.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Whether a floating-point value is infinity.
Returns true if the floating point value is plus or minus infinity. Querying the sign bit will return the sign of the infinity.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Sign of floating-point value.
Returns the value of the floating-point sign bit.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Exponent of floating-point value.
Returns the exponent of the floating point value. For normalized values this returns the stored exponent minus the exponent bias. For denormalized numbers this returns the stored exponent minus the exponent bias minus an additional amount to normalize the significand.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Add two floating-point values.
Adds two floating-point values that have the same type and returns the sum in the same type.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Subtract one floating-point value from another.
Subtracts b
from a
and returns the difference. All three floating-point values have the same type. The default implementation is in terms of negate and add.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Multiply two floating-point values.
Multiplies two floating-point values and returns the product. All three values have the same type.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Divide one floating-point value by another.
Computes a
divided by b
and returns the result. All three floating-point values have the same type.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Square root.
Computes and returns the square root of the specified floating-point value. Both values have the same type.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Round toward zero.
Truncate the fractional part of the floating point number.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Reinterpret an expression as a different type.
For semantic domains whose values don't carry type information this is a no-op. For other domains, this creates a new value having the same bits as the original value but a new type. The old and new types must be the same size. This is similar to a C++ reinterpret_cast
.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
|
virtual |
Reads a value from a register.
The base implementation simply delegates to the current semantic State, which probably delegates to a register state, but subclasses are welcome to override this behavior at any level.
A register state will typically implement storage for hardware registers, but higher layers (the State, RiscOperators, Dispatcher, ...) should not be concerned about the size of the register they're trying to read. For example, a register state for a 32-bit x86 architecture will likely have a storage location for the 32-bit EAX register, but it should be possible to ask readRegister to return the value of AX (the low-order 16-bits). In order to accomplish this, some level of the readRegister delegations needs to invoke extract to obtain the low 16 bits. The RiscOperators object is passed along the delegation path for this purpose. The inverse concat operation will be needed at some level when we ask readRegister to return a value that comes from multiple storage locations in the register state (such as can happen if an x86 register state holds individual status flags and we ask for the 32-bit EFLAGS register).
If the register state can distinguish between a register that has never been accessed and a register that has only been read, then the dflt
value is stored into the register the first time it's read. This ensures that reading the register a second time with no intervening write will return the same value as the first read. If a dflt
is not provided then one is constructed by invoking undefined_.
There needs to be a certain level of cooperation between the RiscOperators, State, and register state classes to decide which layer should invoke the extract or concat (or whatever other RISC operations might be necessary).
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
Reimplemented in Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::RiscOperators.
|
virtual |
Obtain a register value without side effects.
This is a lower-level operation than readRegister in that it doesn't cause the register to be marked as having been read. It is typically used in situations where the register is being accessed for analysis purposes rather than as part of an instruction emulation.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
Reimplemented in Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::RiscOperators.
|
virtual |
Writes a value to a register.
The base implementation simply delegates to the current semantic State, which probably delegates to a register state, but subclasses are welcome to override this behavior at any level.
As with readRegister, writeRegister may need to perform various RISC operations in order to accomplish the task of writing a value to the specified register when the underlying register state doesn't actually store a value for that specific register. The RiscOperations object is passed along for that purpose. See readRegister for more details.
Reimplemented from Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
Reimplemented in Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::RiscOperators.
|
virtual |
Reads a value from memory.
The implementation (in subclasses) will typically delegate much of the work to the current state's readMemory method.
A MemoryState will implement storage for memory locations and might impose certain restrictions, such as "all memory values must be eight bits". However, the readMemory should not have these constraints so that it can be called from a variety of Dispatcher subclass (e.g., the DispatcherX86 class assumes that readMemory is capable of reading 32-bit values from little-endian memory). The designers of the MemoryState, State, and RiscOperators should collaborate to decide which layer (RiscOperators, State, or MemoryState) is reponsible for combining individual memory locations into larger values. A RiscOperators object is passed along the chain of delegations for this purpose. The RiscOperators might also contain other data that's important during the process, such as an SMT solver.
The segreg
argument is an optional segment register. Most architectures have a flat virtual address space and will pass a default-constructed register descriptor whose is_valid() method returns false.
The cond
argument is a Boolean value that indicates whether this is a true read operation. If cond
can be proven to be false then the read is a no-op and returns an arbitrary value.
The dflt
argument determines the size of the value to be read. This argument is also passed along to the lower layers so that they can, if they desire, use it to initialize memory that has never been read or written before.
Implements Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
Reimplemented in Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::RiscOperators.
|
virtual |
Read memory without side effects.
This is a lower-level operation than readMemory in that it doesn't cause any side effects in the memory state. In all other respects, it's similar to readMemory.
Implements Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
Reimplemented in Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::RiscOperators.
|
virtual |
Writes a value to memory.
The implementation (in subclasses) will typically delegate much of the work to the current state's writeMemory method.
The segreg
argument is an optional segment register. Most architectures have a flat virtual address space and will pass a default-constructed register descriptor whose is_valid() method returns false.
The cond
argument is a Boolean value that indicates whether this is a true write operation. If cond
can be proved to be false then writeMemory is a no-op.
Implements Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RiscOperators.
Reimplemented in Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::RiscOperators.