ROSE 0.11.145.147
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | List of all members
Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators Class Reference

Description

Defines RISC operators for the TaintSemantics domain.

These RISC operators depend on functionality introduced into the SValue class hierarchy at the TaintSemantics::SValue level. Therefore, the prototypical value supplied to the constructor or present in the supplied state object must have a dynamic type which is a TaintSemantics::SValue.

Each RISC operator should return a newly allocated semantic value so that the caller can adjust taintedness for the result without affecting any of the inputs. For example, a no-op that returns its argument should be implemented like this:

return arg->copy(); //correct
return arg; //incorrect
}

Definition at line 265 of file TaintSemantics.h.

#include <Rose/BinaryAnalysis/InstructionSemantics/TaintSemantics.h>

Inheritance diagram for Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators:
Inheritance graph
[legend]
Collaboration diagram for Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators:
Collaboration graph
[legend]

Public Types

using Super = SymbolicSemantics::RiscOperators
 Base type.
 
using Ptr = RiscOperatorsPtr
 Shared-ownership pointer.
 
- Public Types inherited from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators
using Super = BaseSemantics::RiscOperators
 Base type.
 
using Ptr = RiscOperatorsPtr
 Shared-ownership pointer.
 
- Public Types inherited from Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::RiscOperators
enum class  IteStatus {
  NEITHER ,
  A ,
  B ,
  BOTH
}
 Status for iteWithStatus operation. More...
 
using Ptr = RiscOperatorsPtr
 Shared-ownership pointer.
 

Public Member Functions

virtual BaseSemantics::RiscOperatorsPtr create (const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &solver=SmtSolverPtr()) const override
 Virtual allocating constructor.
 
virtual BaseSemantics::RiscOperatorsPtr create (const BaseSemantics::StatePtr &, const SmtSolverPtr &solver=SmtSolverPtr()) const override
 Virtual allocating constructor.
 
virtual BaseSemantics::SValuePtr and_ (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &b_) override
 Computes bit-wise AND of two values.
 
virtual BaseSemantics::SValuePtr or_ (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &b_) override
 Computes bit-wise OR of two values.
 
virtual BaseSemantics::SValuePtr xor_ (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &b_) override
 Computes bit-wise XOR of two values.
 
virtual BaseSemantics::SValuePtr invert (const BaseSemantics::SValuePtr &a_) override
 One's complement.
 
virtual BaseSemantics::SValuePtr extract (const BaseSemantics::SValuePtr &a_, size_t begin_bit, size_t end_bit) override
 Extracts bits from a value.
 
virtual BaseSemantics::SValuePtr concat (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &b_) override
 Concatenates the bits of two values.
 
virtual BaseSemantics::SValuePtr leastSignificantSetBit (const BaseSemantics::SValuePtr &a_) override
 Returns position of least significant set bit; zero when no bits are set.
 
virtual BaseSemantics::SValuePtr mostSignificantSetBit (const BaseSemantics::SValuePtr &a_) override
 Returns position of most significant set bit; zero when no bits are set.
 
virtual BaseSemantics::SValuePtr rotateLeft (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &sa_) override
 Rotate bits to the left.
 
virtual BaseSemantics::SValuePtr rotateRight (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &sa_) override
 Rotate bits to the right.
 
virtual BaseSemantics::SValuePtr shiftLeft (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &sa_) override
 Returns arg shifted left.
 
virtual BaseSemantics::SValuePtr shiftRight (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &sa_) override
 Returns arg shifted right logically (no sign bit).
 
virtual BaseSemantics::SValuePtr shiftRightArithmetic (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &sa_) override
 Returns arg shifted right arithmetically (with sign bit).
 
virtual BaseSemantics::SValuePtr equalToZero (const BaseSemantics::SValuePtr &a_) override
 Determines whether a value is equal to zero.
 
virtual BaseSemantics::SValuePtr iteWithStatus (const BaseSemantics::SValuePtr &sel_, const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &b_, IteStatus &) override
 If-then-else with status.
 
virtual BaseSemantics::SValuePtr unsignedExtend (const BaseSemantics::SValuePtr &a_, size_t new_width) override
 Extend (or shrink) operand a so it is nbits wide by adding or removing high-order bits.
 
virtual BaseSemantics::SValuePtr signExtend (const BaseSemantics::SValuePtr &a_, size_t new_width) override
 Sign extends a value.
 
virtual BaseSemantics::SValuePtr add (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &b_) override
 Adds two integers of equal size.
 
virtual BaseSemantics::SValuePtr addWithCarries (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &b_, const BaseSemantics::SValuePtr &c_, BaseSemantics::SValuePtr &carry_out) override
 Add two values of equal size and a carry bit.
 
virtual BaseSemantics::SValuePtr negate (const BaseSemantics::SValuePtr &a_) override
 Two's complement.
 
virtual BaseSemantics::SValuePtr signedDivide (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &b_) override
 Divides two signed values.
 
virtual BaseSemantics::SValuePtr signedModulo (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &b_) override
 Calculates modulo with signed values.
 
virtual BaseSemantics::SValuePtr signedMultiply (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &b_) override
 Multiplies two signed values.
 
virtual BaseSemantics::SValuePtr unsignedDivide (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &b_) override
 Divides two unsigned values.
 
virtual BaseSemantics::SValuePtr unsignedModulo (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &b_) override
 Calculates modulo with unsigned values.
 
virtual BaseSemantics::SValuePtr unsignedMultiply (const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &b_) override
 Multiply two unsigned values.
 
virtual BaseSemantics::SValuePtr fpConvert (const BaseSemantics::SValuePtr &a, SgAsmFloatType *aType, SgAsmFloatType *retType) override
 Convert from one floating-point type to another.
 
virtual BaseSemantics::SValuePtr reinterpret (const BaseSemantics::SValuePtr &, SgAsmType *) override
 Reinterpret an expression as a different type.
 
- Public Member Functions inherited from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators
virtual BaseSemantics::SValuePtr boolean_ (bool b) override
 Returns a Boolean value.
 
virtual BaseSemantics::SValuePtr number_ (size_t nbits, uint64_t value) override
 Returns a number of the specified bit width.
 
SValuePtr svalueExpr (const ExprPtr &expr, const InsnSet &defs=InsnSet())
 
bool getset_omit_cur_insn (bool b)
 
virtual void substitute (const SValuePtr &from, const SValuePtr &to)
 Substitute all occurrences of from with to in the current state.
 
virtual BaseSemantics::SValuePtr filterResult (const BaseSemantics::SValuePtr &)
 Filters results from RISC operators.
 
virtual SymbolicExpression::Type sgTypeToSymbolicType (SgAsmType *)
 Convert a SgAsmType to a symbolic type.
 
virtual void interrupt (int majr, int minr) override
 Unconditionally raise an interrupt.
 
virtual BaseSemantics::SValuePtr readRegister (RegisterDescriptor reg, const BaseSemantics::SValuePtr &dflt) override
 Reads a value from a register.
 
virtual BaseSemantics::SValuePtr peekRegister (RegisterDescriptor reg, const BaseSemantics::SValuePtr &dflt) override
 Obtain a register value without side effects.
 
virtual void writeRegister (RegisterDescriptor reg, const BaseSemantics::SValuePtr &a_) override
 Writes a value to a register.
 
virtual BaseSemantics::SValuePtr readMemory (RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &dflt, const BaseSemantics::SValuePtr &cond) override
 Reads a value from memory.
 
virtual BaseSemantics::SValuePtr peekMemory (RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &dflt) override
 Read memory without side effects.
 
virtual void writeMemory (RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &data, const BaseSemantics::SValuePtr &cond) override
 Writes a value to memory.
 
BaseSemantics::SValuePtr readOrPeekMemory (RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &dflt, AllowSideEffects::Flag)
 
void computingDefiners (DefinersMode m)
 Property: Track which instructions define a semantic value.
 
DefinersMode computingDefiners () const
 Property: Track which instructions define a semantic value.
 
void computingMemoryWriters (WritersMode m)
 Property: Track which instructions write to each memory location.
 
WritersMode computingMemoryWriters () const
 Property: Track which instructions write to each memory location.
 
void computingRegisterWriters (WritersMode m)
 Property: Track latest writer to each register.
 
WritersMode computingRegisterWriters () const
 Property: Track latest writer to each register.
 
void trimThreshold (uint64_t n)
 Property: Maximum size of expressions.
 
uint64_t trimThreshold () const
 Property: Maximum size of expressions.
 
size_t nTrimmed () const
 Property: Number of symbolic expressions trimmed.
 
void nTrimmed (size_t n)
 Property: Number of symbolic expressions trimmed.
 
bool reinterpretMemoryReads () const
 Property: Reinterpret data as unsigned integers when reading from memory or registers.
 
void reinterpretMemoryReads (bool b)
 Property: Reinterpret data as unsigned integers when reading from memory or registers.
 
bool reinterpretRegisterReads () const
 Property: Reinterpret data as unsigned integers when reading from memory or registers.
 
void reinterpretRegisterReads (bool b)
 Property: Reinterpret data as unsigned integers when reading from memory or registers.
 
- Public Member Functions inherited from Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::RiscOperators
virtual SValuePtr protoval () const
 Property: Prototypical semantic value.
 
virtual void hash (Combinatorics::Hasher &)
 Compute hash of current state.
 
virtual void startInstruction (SgAsmInstruction *insn)
 Called at the beginning of every instruction.
 
virtual void finishInstruction (SgAsmInstruction *insn)
 Called at the end of every instruction.
 
virtual void comment (const std::string &)
 Inject a line comment into debugging streams.
 
virtual SValuePtr bottom_ (size_t nbits)
 Returns a data-flow bottom value.
 
virtual SValuePtr filterCallTarget (const SValuePtr &a)
 Invoked to filter call targets.
 
virtual SValuePtr filterReturnTarget (const SValuePtr &a)
 Invoked to filter return targets.
 
virtual SValuePtr filterIndirectJumpTarget (const SValuePtr &a)
 Invoked to filter indirect jumps.
 
virtual void hlt ()
 Invoked for the x86 HLT instruction.
 
virtual void cpuid ()
 Invoked for the x86 CPUID instruction.
 
virtual SValuePtr rdtsc ()
 Invoked for the x86 RDTSC instruction.
 
virtual std::pair< SValuePtr, SValuePtrsplit (const SValuePtr &a, size_t splitPoint)
 Split a value into two narrower values.
 
virtual SValuePtr countLeadingZeros (const SValuePtr &a)
 Count leading zero bits.
 
virtual SValuePtr countLeadingOnes (const SValuePtr &a)
 Count leading one bits.
 
virtual SValuePtr reverseElmts (const SValuePtr &a, size_t elmtNBits)
 Reverse parts of a value.
 
virtual SValuePtr ite (const SValuePtr &cond, const SValuePtr &a, const SValuePtr &b) final
 If-then-else.
 
virtual SValuePtr addCarry (const SValuePtr &a, const SValuePtr &b, SValuePtr &carryOut, SValuePtr &overflowed)
 Adds two integers of equal size and carry.
 
virtual SValuePtr subtract (const SValuePtr &minuend, const SValuePtr &subtrahend)
 Subtract one value from another.
 
virtual SValuePtr subtractCarry (const SValuePtr &minuend, const SValuePtr &subtrahend, SValuePtr &carryOut, SValuePtr &overflowed)
 Subtract one value from another and carry.
 
virtual void interrupt (const SValuePtr &majr, const SValuePtr &minr, const SValuePtr &raise)
 Invoked for instructions that cause an interrupt.
 
virtual void raiseInterrupt (unsigned majorNumber, unsigned minorNumber, const SValuePtr &raise)
 Conditionally raise an interrupt.
 
virtual SValuePtr fpFromInteger (const SValuePtr &intValue, SgAsmFloatType *fpType)
 Construct a floating-point value from an integer value.
 
virtual SValuePtr fpToInteger (const SValuePtr &fpValue, SgAsmFloatType *fpType, const SValuePtr &dflt)
 Construct an integer value from a floating-point value.
 
virtual SValuePtr fpIsNan (const SValuePtr &fpValue, SgAsmFloatType *fpType)
 Whether a floating-point value is a special not-a-number bit pattern.
 
virtual SValuePtr fpIsDenormalized (const SValuePtr &fpValue, SgAsmFloatType *fpType)
 Whether a floating-point value is denormalized.
 
virtual SValuePtr fpIsZero (const SValuePtr &fpValue, SgAsmFloatType *fpType)
 Whether a floating-point value is equal to zero.
 
virtual SValuePtr fpIsInfinity (const SValuePtr &fpValue, SgAsmFloatType *fpType)
 Whether a floating-point value is infinity.
 
virtual SValuePtr fpSign (const SValuePtr &fpValue, SgAsmFloatType *fpType)
 Sign of floating-point value.
 
virtual SValuePtr fpEffectiveExponent (const SValuePtr &fpValue, SgAsmFloatType *fpType)
 Exponent of floating-point value.
 
virtual SValuePtr fpAdd (const SValuePtr &a, const SValuePtr &b, SgAsmFloatType *fpType)
 Add two floating-point values.
 
virtual SValuePtr fpSubtract (const SValuePtr &a, const SValuePtr &b, SgAsmFloatType *fpType)
 Subtract one floating-point value from another.
 
virtual SValuePtr fpMultiply (const SValuePtr &a, const SValuePtr &b, SgAsmFloatType *fpType)
 Multiply two floating-point values.
 
virtual SValuePtr fpDivide (const SValuePtr &a, const SValuePtr &b, SgAsmFloatType *fpType)
 Divide one floating-point value by another.
 
virtual SValuePtr fpSquareRoot (const SValuePtr &a, SgAsmFloatType *fpType)
 Square root.
 
virtual SValuePtr fpRoundTowardZero (const SValuePtr &a, SgAsmFloatType *fpType)
 Round toward zero.
 
virtual SValuePtr convert (const SValuePtr &a, SgAsmType *srcType, SgAsmType *dstType)
 Convert value from one type to another.
 
virtual SmtSolverPtr solver () const
 Property: Satisfiability module theory (SMT) solver.
 
virtual void solver (const SmtSolverPtr &s)
 Property: Satisfiability module theory (SMT) solver.
 
const HotPatchhotPatch () const
 Property: Post-instruction hot patches.
 
HotPatchhotPatch ()
 Property: Post-instruction hot patches.
 
void hotPatch (const HotPatch &hp)
 Property: Post-instruction hot patches.
 
virtual StatePtr currentState () const
 Property: Current semantic state.
 
virtual void currentState (const StatePtr &s)
 Property: Current semantic state.
 
virtual StatePtr initialState () const
 Property: Optional lazily updated initial state.
 
virtual void initialState (const StatePtr &s)
 Property: Optional lazily updated initial state.
 
virtual const std::string & name () const
 Property: Name used for debugging.
 
virtual void name (const std::string &s)
 Property: Name used for debugging.
 
void print (std::ostream &stream, const std::string prefix="") const
 Print multi-line output for this object.
 
virtual void print (std::ostream &stream, Formatter &fmt) const
 Print multi-line output for this object.
 
WithFormatter with_format (Formatter &fmt)
 Used for printing RISC operators with formatting.
 
WithFormatter operator+ (Formatter &fmt)
 Used for printing RISC operators with formatting.
 
WithFormatter operator+ (const std::string &linePrefix)
 Used for printing RISC operators with formatting.
 
virtual size_t nInsns () const
 Property: Number of instructions processed.
 
virtual void nInsns (size_t n)
 Property: Number of instructions processed.
 
virtual SgAsmInstructioncurrentInstruction () const
 Property: Current instruction.
 
virtual void currentInstruction (SgAsmInstruction *insn)
 Property: Current instruction.
 
virtual bool isNoopRead () const
 Property: No-op read.
 
virtual void isNoopRead (bool b)
 Property: No-op read.
 
virtual SValuePtr undefined_ (size_t nbits)
 Returns a new undefined value.
 
virtual SValuePtr unspecified_ (size_t nbits)
 Returns a new undefined value.
 
virtual SValuePtr concatLoHi (const SValuePtr &lowBits, const SValuePtr &highBits)
 Aliases for concatenation.
 
virtual SValuePtr concatHiLo (const SValuePtr &highBits, const SValuePtr &lowBits)
 Aliases for concatenation.
 
virtual SValuePtr isEqual (const SValuePtr &a, const SValuePtr &b)
 Equality comparison.
 
virtual SValuePtr isNotEqual (const SValuePtr &a, const SValuePtr &b)
 Equality comparison.
 
virtual SValuePtr isUnsignedLessThan (const SValuePtr &a, const SValuePtr &b)
 Comparison for unsigned values.
 
virtual SValuePtr isUnsignedLessThanOrEqual (const SValuePtr &a, const SValuePtr &b)
 Comparison for unsigned values.
 
virtual SValuePtr isUnsignedGreaterThan (const SValuePtr &a, const SValuePtr &b)
 Comparison for unsigned values.
 
virtual SValuePtr isUnsignedGreaterThanOrEqual (const SValuePtr &a, const SValuePtr &b)
 Comparison for unsigned values.
 
virtual SValuePtr isSignedLessThan (const SValuePtr &a, const SValuePtr &b)
 Comparison for signed values.
 
virtual SValuePtr isSignedLessThanOrEqual (const SValuePtr &a, const SValuePtr &b)
 Comparison for signed values.
 
virtual SValuePtr isSignedGreaterThan (const SValuePtr &a, const SValuePtr &b)
 Comparison for signed values.
 
virtual SValuePtr isSignedGreaterThanOrEqual (const SValuePtr &a, const SValuePtr &b)
 Comparison for signed values.
 
virtual SValuePtr readRegister (RegisterDescriptor reg)
 Reads a value from a register.
 
SValuePtr peekRegister (RegisterDescriptor reg)
 Obtain a register value without side effects.
 

Static Public Member Functions

static RiscOperatorsPtr instanceFromRegisters (const RegisterDictionaryPtr &, const SmtSolverPtr &solver=SmtSolverPtr())
 Instantiates a new RiscOperators object and configures it to use semantic values and states that are defaults for TaintSemantics.
 
static RiscOperatorsPtr instanceFromProtoval (const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &solver=SmtSolverPtr())
 Instantiates a new RiscOperators object with specified prototypical values.
 
static RiscOperatorsPtr instanceFromState (const BaseSemantics::StatePtr &, const SmtSolverPtr &solver=SmtSolverPtr())
 Instantiates a new RiscOperators object with specified state.
 
static RiscOperatorsPtr promote (const BaseSemantics::RiscOperatorsPtr &)
 Run-time promotion of a base RiscOperators pointer to symbolic operators.
 
- Static Public Member Functions inherited from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators
static RiscOperatorsPtr instanceFromRegisters (const RegisterDictionaryPtr &, const SmtSolverPtr &solver=SmtSolverPtr())
 Instantiates a new RiscOperators object and configures it to use semantic values and states that are defaults for SymbolicSemantics.
 
static RiscOperatorsPtr instanceFromProtoval (const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &solver=SmtSolverPtr())
 Instantiates a new RiscOperators object with specified prototypical values.
 
static RiscOperatorsPtr instanceFromState (const BaseSemantics::StatePtr &, const SmtSolverPtr &solver=SmtSolverPtr())
 Instantiates a new RiscOperators object with specified state.
 
static RiscOperatorsPtr promote (const BaseSemantics::RiscOperatorsPtr &)
 Run-time promotion of a base RiscOperators pointer to symbolic operators.
 
static SgAsmFloatTypesgIsIeee754 (SgAsmType *)
 Tests whether a SgAsmType is an IEEE-754 floating-point type.
 
- Static Public Member Functions inherited from Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::RiscOperators
static RiscOperatorsPtr promote (const RiscOperatorsPtr &x)
 

Protected Member Functions

 RiscOperators (const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &)
 
 RiscOperators (const BaseSemantics::StatePtr &, const SmtSolverPtr &)
 
- Protected Member Functions inherited from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators
 RiscOperators (const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &solver)
 
 RiscOperators (const BaseSemantics::StatePtr &state, const SmtSolverPtr &solver)
 
SValuePtr svalueUndefined (size_t nbits)
 
SValuePtr svalueBottom (size_t nbits)
 
SValuePtr svalueUnspecified (size_t nbits)
 
SValuePtr svalueNumber (size_t nbits, uint64_t value)
 
SValuePtr svalueBoolean (bool b)
 
- Protected Member Functions inherited from Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::RiscOperators
 RiscOperators (const SValuePtr &protoval, const SmtSolverPtr &solver=SmtSolverPtr())
 
 RiscOperators (const StatePtr &state, const SmtSolverPtr &solver=SmtSolverPtr())
 

Additional Inherited Members

- Protected Attributes inherited from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators
bool omit_cur_insn
 
DefinersMode computingDefiners_
 
WritersMode computingMemoryWriters_
 
WritersMode computingRegisterWriters_
 
uint64_t trimThreshold_
 
bool reinterpretMemoryReads_
 
bool reinterpretRegisterReads_
 
size_t nTrimmed_ = 0
 

Member Typedef Documentation

◆ Super

Base type.

Definition at line 268 of file TaintSemantics.h.

◆ Ptr

Shared-ownership pointer.

Definition at line 271 of file TaintSemantics.h.

Constructor & Destructor Documentation

◆ ~RiscOperators()

Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::~RiscOperators ( )
virtual

Member Function Documentation

◆ instanceFromProtoval()

static RiscOperatorsPtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::instanceFromProtoval ( const BaseSemantics::SValuePtr protoval,
const SmtSolverPtr solver = SmtSolverPtr() 
)
static

Instantiates a new RiscOperators object with specified prototypical values.

An SMT solver may be specified as the second argument for convenience. See solver for details.

◆ instanceFromState()

static RiscOperatorsPtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::instanceFromState ( const BaseSemantics::StatePtr ,
const SmtSolverPtr solver = SmtSolverPtr() 
)
static

Instantiates a new RiscOperators object with specified state.

An SMT solver may be specified as the second argument for convenience. See solver for details.

◆ create() [1/2]

virtual BaseSemantics::RiscOperatorsPtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::create ( const BaseSemantics::SValuePtr protoval,
const SmtSolverPtr solver = SmtSolverPtr() 
) const
overridevirtual

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).

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ create() [2/2]

virtual BaseSemantics::RiscOperatorsPtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::create ( const BaseSemantics::StatePtr state,
const SmtSolverPtr solver = SmtSolverPtr() 
) const
overridevirtual

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).

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ promote()

static RiscOperatorsPtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::promote ( const BaseSemantics::RiscOperatorsPtr )
static

Run-time promotion of a base RiscOperators pointer to symbolic operators.

This is a checked conversion–it will fail if x does not point to a SymbolicSemantics::RiscOperators object.

◆ and_()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::and_ ( const BaseSemantics::SValuePtr a,
const BaseSemantics::SValuePtr b 
)
overridevirtual

Computes bit-wise AND of two values.

The operands must both have the same width; the result must be the same width as the operands.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ or_()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::or_ ( const BaseSemantics::SValuePtr a,
const BaseSemantics::SValuePtr b 
)
overridevirtual

Computes bit-wise OR of two values.

The operands a and b must have the same width; the return value width will be the same as a and b.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ xor_()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::xor_ ( const BaseSemantics::SValuePtr a,
const BaseSemantics::SValuePtr b 
)
overridevirtual

Computes bit-wise XOR of two values.

The operands a and b must have the same width; the result will be the same width as a and b.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ invert()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::invert ( const BaseSemantics::SValuePtr a)
overridevirtual

One's complement.

The result will be the same size as the operand.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ extract()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::extract ( const BaseSemantics::SValuePtr a,
size_t  begin_bit,
size_t  end_bit 
)
overridevirtual

Extracts bits from a value.

The specified bits from begin_bit (inclusive) through end_bit (exclusive) are copied into the low-order bits of the return value (other bits in the return value are cleared). The least significant bit is number zero. The begin_bit and end_bit values must be valid for the width of a.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ concat()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::concat ( const BaseSemantics::SValuePtr lowBits,
const BaseSemantics::SValuePtr highBits 
)
overridevirtual

Concatenates the bits of two values.

The bits of lowBits and highBits are concatenated so that the result has lowBits in the low-order bits and highBits in the high order bits. The width of the return value is the sum of the widths of lowBits and highBits.

Note that the order of arguments for this method is the reverse of the SymbolicExpression concatenation function.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ leastSignificantSetBit()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::leastSignificantSetBit ( const BaseSemantics::SValuePtr a)
overridevirtual

Returns position of least significant set bit; zero when no bits are set.

The return value will have the same width as the operand, although this can be safely truncated to the log-base-2 + 1 width.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ mostSignificantSetBit()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::mostSignificantSetBit ( const BaseSemantics::SValuePtr a)
overridevirtual

Returns position of most significant set bit; zero when no bits are set.

The return value will have the same width as the operand, although this can be safely truncated to the log-base-2 + 1 width.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ rotateLeft()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::rotateLeft ( const BaseSemantics::SValuePtr a,
const BaseSemantics::SValuePtr nbits 
)
overridevirtual

Rotate bits to the left.

The return value will have the same width as operand a. The nbits is interpreted as unsigned. The behavior is modulo the width of a regardless of whether the implementation makes that a special case or handles it naturally.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ rotateRight()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::rotateRight ( const BaseSemantics::SValuePtr a,
const BaseSemantics::SValuePtr nbits 
)
overridevirtual

Rotate bits to the right.

The return value will have the same width as operand a. The nbits is interpreted as unsigned. The behavior is modulo the width of a regardless of whether the implementation makes that a special case or handles it naturally.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ shiftLeft()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::shiftLeft ( const BaseSemantics::SValuePtr a,
const BaseSemantics::SValuePtr nbits 
)
overridevirtual

Returns arg shifted left.

The return value will have the same width as operand a. The nbits is interpreted as unsigned. New bits shifted into the value are zero. If nbits is equal to or larger than the width of a then the result is zero.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ shiftRight()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::shiftRight ( const BaseSemantics::SValuePtr a,
const BaseSemantics::SValuePtr nbits 
)
overridevirtual

Returns arg shifted right logically (no sign bit).

The return value will have the same width as operand a. The nbits is interpreted as unsigned. New bits shifted into the value are zero. If nbits is equal to or larger than the width of a then the result is zero.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ shiftRightArithmetic()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::shiftRightArithmetic ( const BaseSemantics::SValuePtr a,
const BaseSemantics::SValuePtr nbits 
)
overridevirtual

Returns arg shifted right arithmetically (with sign bit).

The return value will have the same width as operand a. The nbits is interpreted as unsigned. New bits shifted into the value are the same as the most significant bit (the "sign bit"). If nbits is equal to or larger than the width of a then the result has all bits cleared or all bits set depending on whether the most significant bit was originally clear or set.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ equalToZero()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::equalToZero ( const BaseSemantics::SValuePtr a)
overridevirtual

Determines whether a value is equal to zero.

Returns true, false, or undefined (in the semantic domain) depending on whether argument is zero.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ iteWithStatus()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::iteWithStatus ( const BaseSemantics::SValuePtr cond,
const BaseSemantics::SValuePtr a,
const BaseSemantics::SValuePtr b,
IteStatus status 
)
overridevirtual

If-then-else with status.

Returns operand a if cond is true, operand b if cond is false, or some other value if the condition is unknown. The condition must be one bit wide; the widths of a and b must be equal; the return value width will be the same as a and b.

The status is an output that indicates how the main return value was determined.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ unsignedExtend()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::unsignedExtend ( const BaseSemantics::SValuePtr a,
size_t  new_width 
)
overridevirtual

Extend (or shrink) operand a so it is nbits wide by adding or removing high-order bits.

Added bits are always zeros. The result will be the specified new_width.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ signExtend()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::signExtend ( const BaseSemantics::SValuePtr a,
size_t  new_width 
)
overridevirtual

Sign extends a value.

The result will be the specified new_width, which must be at least as large as the original width.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ add()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::add ( const BaseSemantics::SValuePtr a,
const BaseSemantics::SValuePtr b 
)
overridevirtual

Adds two integers of equal size.

The width of a and b must be equal; the return value will have the same width as a and b.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ addWithCarries()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::addWithCarries ( const BaseSemantics::SValuePtr a,
const BaseSemantics::SValuePtr b,
const BaseSemantics::SValuePtr c,
BaseSemantics::SValuePtr carry_out 
)
overridevirtual

Add two values of equal size and a carry bit.

Carry information is returned via carry_out argument. The carry_out value is the tick marks that are written above the first addend when doing long arithmetic like a 2nd grader would do (of course, they'd probably be adding two base-10 numbers). For instance, when adding 00110110 and 11100100:

'''..'.. <-- carry tick marks: '=carry .=no carry
00110110
+ 11100100
----------
100011010

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.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ negate()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::negate ( const BaseSemantics::SValuePtr a)
overridevirtual

Two's complement.

The return value will have the same width as the operand.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ signedDivide()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::signedDivide ( const BaseSemantics::SValuePtr dividend,
const BaseSemantics::SValuePtr divisor 
)
overridevirtual

Divides two signed values.

The width of the result will be the same as the width of the dividend.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ signedModulo()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::signedModulo ( const BaseSemantics::SValuePtr a,
const BaseSemantics::SValuePtr b 
)
overridevirtual

Calculates modulo with signed values.

The width of the result will be the same as the width of operand b.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ signedMultiply()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::signedMultiply ( const BaseSemantics::SValuePtr a,
const BaseSemantics::SValuePtr b 
)
overridevirtual

Multiplies two signed values.

The width of the result will be the sum of the widths of a and b.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ unsignedDivide()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::unsignedDivide ( const BaseSemantics::SValuePtr dividend,
const BaseSemantics::SValuePtr divisor 
)
overridevirtual

Divides two unsigned values.

The width of the result is the same as the width of the dividend.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ unsignedModulo()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::unsignedModulo ( const BaseSemantics::SValuePtr a,
const BaseSemantics::SValuePtr b 
)
overridevirtual

Calculates modulo with unsigned values.

The width of the result is the same as the width of operand b.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ unsignedMultiply()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::unsignedMultiply ( const BaseSemantics::SValuePtr a,
const BaseSemantics::SValuePtr b 
)
overridevirtual

Multiply two unsigned values.

The width of the result is the sum of the widths of a and b.

Reimplemented from Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ fpConvert()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::fpConvert ( const BaseSemantics::SValuePtr a,
SgAsmFloatType aType,
SgAsmFloatType retType 
)
overridevirtual

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::InstructionSemantics::SymbolicSemantics::RiscOperators.

◆ reinterpret()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::TaintSemantics::RiscOperators::reinterpret ( const BaseSemantics::SValuePtr a,
SgAsmType retType 
)
overridevirtual

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::InstructionSemantics::SymbolicSemantics::RiscOperators.


The documentation for this class was generated from the following file: