Description

Definition at line 42 of file LlvmSemantics.h.

Inheritance diagram for Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators:

Collaboration diagram for Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators:

Classes
struct	Indent
	Cause indentation until this object is destroyed. More...

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 &state, const SmtSolverPtr &solver=SmtSolverPtr()) const override
	Virtual allocating constructor.

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 void	writeMemory (RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &data, const BaseSemantics::SValuePtr &cond) override
	Writes a value to memory.

int	indent (int nlevels=1)
	Increase indentation by `nlevels` levels.

std::string	prefix () const
	Return indentation string.

virtual void	reset ()
	Reset to initial state.

virtual const RegisterDescriptors &	get_important_registers ()
	Return the list of registers that needs to be emitted to LLVM.

virtual RegisterDescriptors	get_stored_registers ()
	Return the list of important registers that are stored.

virtual RegisterDescriptors	get_modified_registers ()
	Return the list of important registers that have been modified since the last call to make_current().

virtual RegisterDescriptor	get_insn_pointer_register ()
	Return the descriptor for the instruction pointer register.

virtual SValuePtr	get_instruction_pointer ()
	Return the value of the instruction pointer.

virtual const TreeNodes &	get_memory_writes ()
	Return the list of memory writes that have occured since the last call to make_current().

virtual void	make_current ()
	Mark the current state as having been emitted.

virtual void	add_rewrite (const ExpressionPtr &from, const LeafPtr &to)
	Register a rewrite.

virtual std::string	add_variable (const LeafPtr &)
	Register an LLVM variable.

virtual std::string	get_variable (const LeafPtr &)
	Returns the LLVM name for a variable, including the sigil.

virtual void	emit_register_declarations (std::ostream &, const RegisterDescriptors &)
	Output LLVM global register declarations for the specified registers.

virtual void	emit_register_definitions (std::ostream &, const RegisterDescriptors &)
	Output LLVM global register definitions for the specified registers.

virtual void	emit_prerequisites (std::ostream &, const RegisterDescriptors &, const RegisterDictionaryPtr &)
	Output LLVM global variable reads that are needed to define the specified registers and pending memory writes.

virtual void	emit_next_eip (std::ostream &, SgAsmInstruction *latest_insn)
	Output an LLVM branch instruction.

virtual void	emit_memory_writes (std::ostream &)
	Output changed memory state.

virtual void	emit_changed_state (std::ostream &)
	Output LLVM to bring the LLVM state up to date with respect to the ROSE state.

virtual std::string	llvm_integer_type (size_t nbits)
	Obtain the LLVM type name for an integer.

virtual std::string	llvm_term (const ExpressionPtr &)
	Convert a ROSE variable or integer to an LLVM term.

virtual std::string	llvm_lvalue (const LeafPtr &)
	Convert a ROSE variable to an LLVM lvalue.

virtual LeafPtr	next_temporary (size_t nbits)
	Create a temporary variable.

virtual std::string	next_label ()
	Obtain the name for an LLVM label, excluding the "%" sigil.

virtual std::string	addr_label (rose_addr_t)
	Obtain a label for a virtual address.

virtual std::string	function_label (SgAsmFunction *)
	Obtain a label for a function.


int	llvmVersion () const
	Property: LLVM version.

void	llvmVersion (int v)
	Property: LLVM version.


virtual LeafPtr	emit_expression (std::ostream &, const SValuePtr &)
	Emit LLVM statements for an expression.

virtual LeafPtr	emit_expression (std::ostream &, const ExpressionPtr &)
	Emit LLVM statements for an expression.

virtual LeafPtr	emit_expression (std::ostream &, const LeafPtr &)
	Emit LLVM statements for an expression.

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

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	peekMemory (RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &dflt) override
	Read memory without side effects.

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, SValuePtr >	split (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 HotPatch &	hotPatch () const
	Property: Post-instruction hot patches.

HotPatch &	hotPatch ()
	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 SgAsmInstruction *	currentInstruction () 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 LlvmSemantics.

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 Llvm 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 SgAsmFloatType *	sgIsIeee754 (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 &)

virtual LeafPtr	emit_assignment (std::ostream &, const ExpressionPtr &rhs)
	Emit an assignment and add a rewrite rule.


virtual ExpressionPtr	emit_zero_extend (std::ostream &, const ExpressionPtr &value, size_t nbits)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_sign_extend (std::ostream &, const ExpressionPtr &value, size_t nbits)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_truncate (std::ostream &, const ExpressionPtr &value, size_t nbits)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_unsigned_resize (std::ostream &, const ExpressionPtr &value, size_t nbits)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_binary (std::ostream &, const std::string &llvm_op, const ExpressionPtr &, const ExpressionPtr &)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_signed_binary (std::ostream &, const std::string &llvm_op, const ExpressionPtr &, const ExpressionPtr &)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_unsigned_binary (std::ostream &, const std::string &llvm_op, const ExpressionPtr &, const ExpressionPtr &)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_logical_right_shift (std::ostream &, const ExpressionPtr &value, const ExpressionPtr &amount)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_logical_right_shift_ones (std::ostream &, const ExpressionPtr &value, const ExpressionPtr &amount)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_arithmetic_right_shift (std::ostream &, const ExpressionPtr &value, const ExpressionPtr &amount)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_left_shift (std::ostream &, const ExpressionPtr &value, const ExpressionPtr &amount)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_left_shift_ones (std::ostream &, const ExpressionPtr &value, const ExpressionPtr &amount)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_lssb (std::ostream &, const ExpressionPtr &)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_mssb (std::ostream &, const ExpressionPtr &)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_extract (std::ostream &, const ExpressionPtr &value, const ExpressionPtr &from, size_t result_nbits)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_invert (std::ostream &, const ExpressionPtr &value)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_left_associative (std::ostream &, const std::string &llvm_op, const TreeNodes &operands)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_concat (std::ostream &, TreeNodes operands)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_signed_divide (std::ostream &, const ExpressionPtr &numerator, const ExpressionPtr &denominator)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_unsigned_divide (std::ostream &, const ExpressionPtr &numerator, const ExpressionPtr &denominator)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_signed_modulo (std::ostream &, const ExpressionPtr &numerator, const ExpressionPtr &denominator)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_unsigned_modulo (std::ostream &, const ExpressionPtr &numerator, const ExpressionPtr &denominator)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_signed_multiply (std::ostream &, const TreeNodes &operands)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_unsigned_multiply (std::ostream &, const TreeNodes &operands)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_rotate_left (std::ostream &, const ExpressionPtr &value, const ExpressionPtr &amount)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_rotate_right (std::ostream &, const ExpressionPtr &value, const ExpressionPtr &amount)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_compare (std::ostream &, const std::string &llvm_op, const ExpressionPtr &, const ExpressionPtr &)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_ite (std::ostream &, const ExpressionPtr &cond, const ExpressionPtr &, const ExpressionPtr &)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_memory_read (std::ostream &, const ExpressionPtr &address, size_t nbits)
	Emit an operation as LLVM instructions.

virtual ExpressionPtr	emit_global_read (std::ostream &, const std::string &varname, size_t nbits)
	Emit an operation as LLVM instructions.

virtual void	emit_memory_write (std::ostream &, const ExpressionPtr &address, const ExpressionPtr &value)
	Emit an operation as LLVM instructions.

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

using Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::Super = SymbolicSemantics::RiscOperators

Base type.

Definition at line 45 of file LlvmSemantics.h.

◆ Ptr

using Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::Ptr = RiscOperatorsPtr

Shared-ownership pointer.

Definition at line 48 of file LlvmSemantics.h.

Constructor & Destructor Documentation

◆ ~RiscOperators()

Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::~RiscOperators ( )

virtual

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

Member Function Documentation

◆ create() [1/2]

virtual BaseSemantics::RiscOperatorsPtr Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::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::LlvmSemantics::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::LlvmSemantics::RiscOperators::promote ( const BaseSemantics::RiscOperatorsPtr & )

static

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

This is a checked-converstion–it will fail if x does not point to a LlvmSemantics::RiscOperators object.

◆ llvmVersion() [1/2]

int Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::llvmVersion ( ) const

inline

Property: LLVM version.

Different versions of LLVM have different assembly syntaxes which are not backward compatible, and this property which dialect is emitted. This property is set to a*x^2 + b*x + c where a, b, and c are the three-part LLVM version number "a.b.c" and x is 1000. The special value zero is reserved to mean that the version number is unknown.

Definition at line 112 of file LlvmSemantics.h.

◆ llvmVersion() [2/2]

void Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::llvmVersion ( int v )

inline

Property: LLVM version.

Different versions of LLVM have different assembly syntaxes which are not backward compatible, and this property which dialect is emitted. This property is set to a*x^2 + b*x + c where a, b, and c are the three-part LLVM version number "a.b.c" and x is 1000. The special value zero is reserved to mean that the version number is unknown.

Definition at line 113 of file LlvmSemantics.h.

◆ readMemory()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::readMemory	(	RegisterDescriptor	segreg,
		const BaseSemantics::SValuePtr &	addr,
		const BaseSemantics::SValuePtr &	dflt,
		const BaseSemantics::SValuePtr &	cond
	)

overridevirtual

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.

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

◆ writeMemory()

virtual void Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::writeMemory	(	RegisterDescriptor	segreg,
		const BaseSemantics::SValuePtr &	addr,
		const BaseSemantics::SValuePtr &	data,
		const BaseSemantics::SValuePtr &	cond
	)

overridevirtual

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.

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

◆ indent()

int Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::indent ( int nlevels = 1 )

inline

Increase indentation by nlevels levels.

Indentation is decreased if nlevels is negative. Returns the new indentation level. It is permissible for the indentation to become negative, but prefix() always returns a non-negative amount of space.

Definition at line 131 of file LlvmSemantics.h.

◆ get_important_registers()

virtual const RegisterDescriptors & Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::get_important_registers ( )

virtual

Return the list of registers that needs to be emitted to LLVM.

Regardless of what registers are written (e.g., AX), return a list of registers that we're keeping track of in global variables (e.g., EAX).

◆ get_stored_registers()

virtual RegisterDescriptors Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::get_stored_registers ( )

virtual

Return the list of important registers that are stored.

This is a subset of the value returned by get_important_registers().

◆ get_memory_writes()

virtual const TreeNodes & Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::get_memory_writes ( )

inlinevirtual

Return the list of memory writes that have occured since the last call to make_current().

Each item in the list is an OP_WRITE symbolic expression, and the list is in the order the write occurred (oldest to most recent). The memory states are each unique and not used for anything in particular.

Definition at line 179 of file LlvmSemantics.h.

◆ add_variable()

virtual std::string Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::add_variable ( const LeafPtr & )

virtual

Register an LLVM variable.

Returns the LLVM variable name including its sigil. If the variable doesn't exist yet then it's added to the list of known variables.

◆ get_variable()

virtual std::string Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::get_variable ( const LeafPtr & )

virtual

Returns the LLVM name for a variable, including the sigil.

If the specified ROSE variable has no corresponding LLVM definition, then the empty string is returned.

◆ emit_prerequisites()

virtual void Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::emit_prerequisites	(	std::ostream &	,
		const RegisterDescriptors &	,
		const RegisterDictionaryPtr &
	)

virtual

Output LLVM global variable reads that are needed to define the specified registers and pending memory writes.

Since registers are stored in global variables and we routinely emit more than one register definition at a time, we need to first make sure that any global prerequisites for the definitions are saved in temporaries. This is to handle cases like the following, where the values of eax and ebx are swapped using edx as a temporary:

mov edx, eax
mov eax, ebx
mov ebx, edx

If we emit all the register definitions at the end of these three x86 instructions, we should get LLVM output similar to the following:

%1 = @eax
%2 = @ebx
@eax = %2
@ebx = %1
@edx = %1

The dictionary is used to convert register names (that appear in symbolic variable comments, like "eax_0") to register descriptors. If a register reference (like "eax_0") corresponds to a register that we're not interested in, then don't bother emitting a temporary variable for the register.

◆ emit_next_eip()

virtual void Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::emit_next_eip	(	std::ostream &	,
		SgAsmInstruction *	latest_insn
	)

virtual

Output an LLVM branch instruction.

The latest_insn is the most recent instruction that was transcoded, usually the last instruction of a basic block.

◆ llvm_term()

virtual std::string Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::llvm_term ( const ExpressionPtr & )

virtual

Convert a ROSE variable or integer to an LLVM term.

A term must be a constant or a variable reference (rvalue).

◆ llvm_lvalue()

virtual std::string Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::llvm_lvalue ( const LeafPtr & )

virtual

Convert a ROSE variable to an LLVM lvalue.

The variable must not have been used as an lvalue previously since LLVM uses single static assignment (SSA) format.

◆ emit_expression() [1/3]

virtual LeafPtr Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::emit_expression	(	std::ostream &	,
		const SValuePtr &
	)

virtual

Emit LLVM statements for an expression.

This method transcodes an expression to LLVM and returns an LLVM terminal node (a constant or variable). The terminal node is not part of the output. For instance, an expression like:

(add[32] v1[32] v2[32] (negate[32] v3[32]))

Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators::add

virtual BaseSemantics::SValuePtr add(const BaseSemantics::SValuePtr &a_, const BaseSemantics::SValuePtr &b_) override

Adds two integers of equal size.

Rose::BinaryAnalysis::InstructionSemantics::SymbolicSemantics::RiscOperators::negate

virtual BaseSemantics::SValuePtr negate(const BaseSemantics::SValuePtr &a_) override

Two's complement.

Would produce the following LLVM

%4 = add i32 %1, i32 %2
%5 = sub i32 0, i32 %3
%6 = add i32 %4, i32 %5

and returns the symbolic variable "v6".

◆ emit_expression() [2/3]

virtual LeafPtr Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::emit_expression	(	std::ostream &	,
		const ExpressionPtr &
	)

virtual

Emit LLVM statements for an expression.

This method transcodes an expression to LLVM and returns an LLVM terminal node (a constant or variable). The terminal node is not part of the output. For instance, an expression like:

(add[32] v1[32] v2[32] (negate[32] v3[32]))

Would produce the following LLVM

%4 = add i32 %1, i32 %2
%5 = sub i32 0, i32 %3
%6 = add i32 %4, i32 %5

and returns the symbolic variable "v6".

◆ emit_expression() [3/3]

virtual LeafPtr Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::emit_expression	(	std::ostream &	,
		const LeafPtr &
	)

virtual

Emit LLVM statements for an expression.

This method transcodes an expression to LLVM and returns an LLVM terminal node (a constant or variable). The terminal node is not part of the output. For instance, an expression like:

(add[32] v1[32] v2[32] (negate[32] v3[32]))

Would produce the following LLVM

%4 = add i32 %1, i32 %2
%5 = sub i32 0, i32 %3
%6 = add i32 %4, i32 %5

and returns the symbolic variable "v6".

◆ emit_assignment()

virtual LeafPtr Rose::BinaryAnalysis::InstructionSemantics::LlvmSemantics::RiscOperators::emit_assignment	(	std::ostream &	,
		const ExpressionPtr &	rhs
	)

protectedvirtual

Emit an assignment and add a rewrite rule.

The left hand side is a new LLVM temporary variable (which is returned). If rhs is an LLVM unamed local variable then rhs is returned. Otherwise, a rewrite rule is added so that future appearances of the right hand side will be replaced by the left hand side in calls to emit_expression().