Binary Ninja API C++: Low Level IL

Classes
struct	BinaryNinja::LowLevelILLabel
class	BinaryNinja::LowLevelILFunction
struct	BinaryNinja::RegisterOrFlag
struct	BinaryNinja::SSARegister
struct	BinaryNinja::SSARegisterStack
struct	BinaryNinja::SSAFlag
struct	BinaryNinja::SSARegisterOrFlag
class	BinaryNinja::LowLevelILInstructionAccessException
class	BinaryNinja::LowLevelILIntegerList
class	BinaryNinja::LowLevelILIndexList
class	BinaryNinja::LowLevelILIndexMap
class	BinaryNinja::LowLevelILInstructionList
class	BinaryNinja::LowLevelILRegisterOrFlagList
class	BinaryNinja::LowLevelILSSARegisterList
class	BinaryNinja::LowLevelILSSARegisterStackList
class	BinaryNinja::LowLevelILSSAFlagList
class	BinaryNinja::LowLevelILSSARegisterOrFlagList
struct	BinaryNinja::LowLevelILInstructionBase
struct	BinaryNinja::LowLevelILInstruction
class	BinaryNinja::LowLevelILOperand
class	BinaryNinja::LowLevelILOperandList

Enumerations
enum	BinaryNinja::LowLevelILOperandType { BinaryNinja::IntegerLowLevelOperand , BinaryNinja::IndexLowLevelOperand , BinaryNinja::ExprLowLevelOperand , BinaryNinja::RegisterLowLevelOperand , BinaryNinja::RegisterStackLowLevelOperand , BinaryNinja::FlagLowLevelOperand , BinaryNinja::FlagConditionLowLevelOperand , BinaryNinja::IntrinsicLowLevelOperand , BinaryNinja::SemanticFlagClassLowLevelOperand , BinaryNinja::SemanticFlagGroupLowLevelOperand , BinaryNinja::SSARegisterLowLevelOperand , BinaryNinja::SSARegisterStackLowLevelOperand , BinaryNinja::SSAFlagLowLevelOperand , BinaryNinja::IndexListLowLevelOperand , BinaryNinja::IndexMapLowLevelOperand , BinaryNinja::ExprListLowLevelOperand , BinaryNinja::RegisterOrFlagListLowLevelOperand , BinaryNinja::SSARegisterListLowLevelOperand , BinaryNinja::SSARegisterStackListLowLevelOperand , BinaryNinja::SSAFlagListLowLevelOperand , BinaryNinja::SSARegisterOrFlagListLowLevelOperand , BinaryNinja::RegisterStackAdjustmentsLowLevelOperand , BinaryNinja::ConstraintLowLevelOperand }
enum	BinaryNinja::LowLevelILOperandUsage { BinaryNinja::SourceExprLowLevelOperandUsage , BinaryNinja::SourceRegisterLowLevelOperandUsage , BinaryNinja::SourceRegisterStackLowLevelOperandUsage , BinaryNinja::SourceFlagLowLevelOperandUsage , BinaryNinja::SourceSSARegisterLowLevelOperandUsage , BinaryNinja::SourceSSARegisterStackLowLevelOperandUsage , BinaryNinja::SourceSSAFlagLowLevelOperandUsage , BinaryNinja::DestExprLowLevelOperandUsage , BinaryNinja::DestRegisterLowLevelOperandUsage , BinaryNinja::DestRegisterStackLowLevelOperandUsage , BinaryNinja::DestFlagLowLevelOperandUsage , BinaryNinja::DestSSARegisterLowLevelOperandUsage , BinaryNinja::DestSSARegisterStackLowLevelOperandUsage , BinaryNinja::DestSSAFlagLowLevelOperandUsage , BinaryNinja::SemanticFlagClassLowLevelOperandUsage , BinaryNinja::SemanticFlagGroupLowLevelOperandUsage , BinaryNinja::PartialRegisterLowLevelOperandUsage , BinaryNinja::PartialSSARegisterStackSourceLowLevelOperandUsage , BinaryNinja::StackSSARegisterLowLevelOperandUsage , BinaryNinja::StackMemoryVersionLowLevelOperandUsage , BinaryNinja::TopSSARegisterLowLevelOperandUsage , BinaryNinja::LeftExprLowLevelOperandUsage , BinaryNinja::RightExprLowLevelOperandUsage , BinaryNinja::CarryExprLowLevelOperandUsage , BinaryNinja::ConditionExprLowLevelOperandUsage , BinaryNinja::HighRegisterLowLevelOperandUsage , BinaryNinja::HighSSARegisterLowLevelOperandUsage , BinaryNinja::LowRegisterLowLevelOperandUsage , BinaryNinja::LowSSARegisterLowLevelOperandUsage , BinaryNinja::IntrinsicLowLevelOperandUsage , BinaryNinja::ConstantLowLevelOperandUsage , BinaryNinja::VectorLowLevelOperandUsage , BinaryNinja::StackAdjustmentLowLevelOperandUsage , BinaryNinja::TargetLowLevelOperandUsage , BinaryNinja::TrueTargetLowLevelOperandUsage , BinaryNinja::FalseTargetLowLevelOperandUsage , BinaryNinja::BitIndexLowLevelOperandUsage , BinaryNinja::SourceMemoryVersionLowLevelOperandUsage , BinaryNinja::DestMemoryVersionLowLevelOperandUsage , BinaryNinja::FlagConditionLowLevelOperandUsage , BinaryNinja::OutputSSARegistersLowLevelOperandUsage , BinaryNinja::OutputMemoryVersionLowLevelOperandUsage , BinaryNinja::ParameterExprsLowLevelOperandUsage , BinaryNinja::SourceSSARegistersLowLevelOperandUsage , BinaryNinja::SourceSSARegisterStacksLowLevelOperandUsage , BinaryNinja::SourceSSAFlagsLowLevelOperandUsage , BinaryNinja::OutputRegisterOrFlagListLowLevelOperandUsage , BinaryNinja::OutputSSARegisterOrFlagListLowLevelOperandUsage , BinaryNinja::OutputMemoryIntrinsicLowLevelOperandUsage , BinaryNinja::SourceMemoryVersionsLowLevelOperandUsage , BinaryNinja::TargetsLowLevelOperandUsage , BinaryNinja::RegisterStackAdjustmentsLowLevelOperandUsage , BinaryNinja::OffsetLowLevelOperandUsage , BinaryNinja::ConstraintLowLevelOperandUsage }

◆ BinaryNinja::LowLevelILLabel

struct BinaryNinja::LowLevelILLabel

Public Member Functions
	LowLevelILLabel ()

◆ LowLevelILLabel()

LowLevelILLabel::LowLevelILLabel

(

)

◆ BinaryNinja::LowLevelILFunction

class BinaryNinja::LowLevelILFunction

Public Member Functions
	LowLevelILFunction (Architecture arch, Function func=nullptr)
	LowLevelILFunction (BNLowLevelILFunction *func)
Ref< Function >	GetFunction () const
Ref< Architecture >	GetArchitecture () const
void	PrepareToCopyFunction (LowLevelILFunction *func)
void	PrepareToCopyBlock (BasicBlock *block)
BNLowLevelILLabel *	GetLabelForSourceInstruction (size_t i)
	Get the LowLevelILLabel for a given source instruction.
uint64_t	GetCurrentAddress () const
	Get the current IL address.
void	SetCurrentAddress (Architecture *arch, uint64_t addr)
size_t	GetInstructionStart (Architecture *arch, uint64_t addr)
std::set< size_t >	GetInstructionsAt (Architecture *arch, uint64_t addr)
std::vector< size_t >	GetExitsForInstruction (size_t i)
void	ClearIndirectBranches ()
void	SetIndirectBranches (const std::vector< ArchAndAddr > &branches)
std::vector< uint32_t >	GetRegisters ()
	Get a list of registers used in the LLIL function.
std::vector< uint32_t >	GetRegisterStacks ()
	Get a list of used register stacks used in the LLIL function.
std::vector< uint32_t >	GetFlags ()
	Get the list of flags used in this LLIL function.
std::vector< SSARegister >	GetSSARegistersWithoutVersions ()
std::vector< SSARegisterStack >	GetSSARegisterStacksWithoutVersions ()
std::vector< SSAFlag >	GetSSAFlagsWithoutVersions ()
std::vector< SSARegister >	GetSSARegisters ()
std::vector< SSARegisterStack >	GetSSARegisterStacks ()
std::vector< SSAFlag >	GetSSAFlags ()
size_t	CachePossibleValueSet (const PossibleValueSet &pvs)
PossibleValueSet	GetCachedPossibleValueSet (size_t idx)
ExprId	AddExpr (BNLowLevelILOperation operation, size_t size, uint32_t flags, ExprId a=0, ExprId b=0, ExprId c=0, ExprId d=0)
ExprId	AddExprWithLocation (BNLowLevelILOperation operation, uint64_t addr, uint32_t sourceOperand, size_t size, uint32_t flags, ExprId a=0, ExprId b=0, ExprId c=0, ExprId d=0)
ExprId	AddExprWithLocation (BNLowLevelILOperation operation, const ILSourceLocation &loc, size_t size, uint32_t flags, ExprId a=0, ExprId b=0, ExprId c=0, ExprId d=0)
ExprId	AddInstruction (ExprId expr)
ExprId	Nop (const ILSourceLocation &loc=ILSourceLocation())
	No operation, this instruction does nothing.
ExprId	SetRegister (size_t size, uint32_t reg, ExprId val, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Sets the register `reg` of size `size` to the expression `value`.
ExprId	SetRegisterSplit (size_t size, uint32_t high, uint32_t low, ExprId val, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Uses `hi` and `lo` as a single extended register setting `hi:lo` to the expression `value` .
ExprId	SetRegisterSSA (size_t size, const SSARegister &reg, ExprId val, const ILSourceLocation &loc=ILSourceLocation())
ExprId	SetRegisterSSAPartial (size_t size, const SSARegister &fullReg, uint32_t partialReg, ExprId val, const ILSourceLocation &loc=ILSourceLocation())
ExprId	SetRegisterSplitSSA (size_t size, const SSARegister &high, const SSARegister &low, ExprId val, const ILSourceLocation &loc=ILSourceLocation())
ExprId	SetRegisterStackTopRelative (size_t size, uint32_t regStack, ExprId entry, ExprId val, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Sets the top-relative entry `entry` of size `size` in register stack `reg_stack` to the expression `value`.
ExprId	RegisterStackPush (size_t size, uint32_t regStack, ExprId val, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Pushes the expression `value` of size `size` onto the top of the register stack `reg_stack`.
ExprId	SetRegisterStackTopRelativeSSA (size_t size, uint32_t regStack, size_t destVersion, size_t srcVersion, ExprId entry, const SSARegister &top, ExprId val, const ILSourceLocation &loc=ILSourceLocation())
ExprId	SetRegisterStackAbsoluteSSA (size_t size, uint32_t regStack, size_t destVersion, size_t srcVersion, uint32_t reg, ExprId val, const ILSourceLocation &loc=ILSourceLocation())
ExprId	SetFlag (uint32_t flag, ExprId val, const ILSourceLocation &loc=ILSourceLocation())
	Sets the flag `flag` to the ExpressionIndex `value`.
ExprId	SetFlagSSA (const SSAFlag &flag, ExprId val, const ILSourceLocation &loc=ILSourceLocation())
ExprId	ForceVer (size_t size, uint32_t reg, const ILSourceLocation &loc=ILSourceLocation())
ExprId	ForceVerSSA (size_t size, SSARegister dst, SSARegister src, const ILSourceLocation &loc=ILSourceLocation())
ExprId	Assert (size_t size, uint32_t reg, const PossibleValueSet &pvs, const ILSourceLocation &loc=ILSourceLocation())
ExprId	AssertSSA (size_t size, SSARegister reg, const PossibleValueSet &pvs, const ILSourceLocation &loc=ILSourceLocation())
ExprId	Load (size_t size, ExprId addr, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Reads `size` bytes from the expression `addr`.
ExprId	LoadSSA (size_t size, ExprId addr, size_t sourceMemoryVer, const ILSourceLocation &loc=ILSourceLocation())
ExprId	Store (size_t size, ExprId addr, ExprId val, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Writes `size` bytes to expression `addr` read from expression `val`.
ExprId	StoreSSA (size_t size, ExprId addr, ExprId val, size_t newMemoryVer, size_t prevMemoryVer, const ILSourceLocation &loc=ILSourceLocation())
ExprId	Push (size_t size, ExprId val, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Writes `size` bytes from expression `value` to the stack, adjusting the stack by `size` .
ExprId	Pop (size_t size, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Reads ``size`` bytes from the stack, adjusting the stack by ``size``.
ExprId	Register (size_t size, uint32_t reg, const ILSourceLocation &loc=ILSourceLocation())
	Returns a register of size `size` with name `reg`.
ExprId	RegisterSSA (size_t size, const SSARegister &reg, const ILSourceLocation &loc=ILSourceLocation())
ExprId	RegisterSSAPartial (size_t size, const SSARegister &fullReg, uint32_t partialReg, const ILSourceLocation &loc=ILSourceLocation())
ExprId	RegisterSplit (size_t size, uint32_t high, uint32_t low, const ILSourceLocation &loc=ILSourceLocation())
	Combines registers of size ``size`` with names ``hi`` and ``lo``.
ExprId	RegisterSplitSSA (size_t size, const SSARegister &high, const SSARegister &low, const ILSourceLocation &loc=ILSourceLocation())
ExprId	RegisterStackTopRelative (size_t size, uint32_t regStack, ExprId entry, const ILSourceLocation &loc=ILSourceLocation())
	Returns a register stack entry of size `size` at top-relative location `entry` in register stack with name `regStack`.
ExprId	RegisterStackPop (size_t size, uint32_t regStack, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Returns the top entry of size `size` in register stack with name `reg_stack` , and removes the entry from the stack.
ExprId	RegisterStackFreeReg (uint32_t reg, const ILSourceLocation &loc=ILSourceLocation())
ExprId	RegisterStackFreeTopRelative (uint32_t regStack, ExprId entry, const ILSourceLocation &loc=ILSourceLocation())
ExprId	RegisterStackTopRelativeSSA (size_t size, const SSARegisterStack &regStack, ExprId entry, const SSARegister &top, const ILSourceLocation &loc=ILSourceLocation())
ExprId	RegisterStackAbsoluteSSA (size_t size, const SSARegisterStack &regStack, uint32_t reg, const ILSourceLocation &loc=ILSourceLocation())
ExprId	RegisterStackFreeTopRelativeSSA (uint32_t regStack, size_t destVersion, size_t srcVersion, ExprId entry, const SSARegister &top, const ILSourceLocation &loc=ILSourceLocation())
ExprId	RegisterStackFreeAbsoluteSSA (uint32_t regStack, size_t destVersion, size_t srcVersion, uint32_t reg, const ILSourceLocation &loc=ILSourceLocation())
ExprId	Const (size_t size, uint64_t val, const ILSourceLocation &loc=ILSourceLocation())
	Returns an expression for the constant integer `value` with size `size`.
ExprId	ConstPointer (size_t size, uint64_t val, const ILSourceLocation &loc=ILSourceLocation())
	Returns an expression for the constant pointer `value` with size `size`.
ExprId	ExternPointer (size_t size, uint64_t val, uint64_t offset, const ILSourceLocation &loc=ILSourceLocation())
	Returns an expression for the constant relocated pointer ``value`` with size ``size``.
ExprId	FloatConstRaw (size_t size, uint64_t val, const ILSourceLocation &loc=ILSourceLocation())
	Returns an expression for the constant raw binary floating point value `value` with size `size`.
ExprId	FloatConstSingle (float val, const ILSourceLocation &loc=ILSourceLocation())
	Returns an expression for the single precision floating point value `value`.
ExprId	FloatConstDouble (double val, const ILSourceLocation &loc=ILSourceLocation())
	Returns an expression for the double precision floating point value `value`.
ExprId	Flag (uint32_t flag, const ILSourceLocation &loc=ILSourceLocation())
	Returns a flag expression for the given flag index.
ExprId	FlagSSA (const SSAFlag &flag, const ILSourceLocation &loc=ILSourceLocation())
ExprId	FlagBit (size_t size, uint32_t flag, size_t bitIndex, const ILSourceLocation &loc=ILSourceLocation())
	Sets the flag with index `flag` and size `size` to the constant integer value `bit`.
ExprId	FlagBitSSA (size_t size, const SSAFlag &flag, size_t bitIndex, const ILSourceLocation &loc=ILSourceLocation())
ExprId	Add (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Adds expression `a` to expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	AddCarry (size_t size, ExprId a, ExprId b, ExprId carry, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Adds with carry expression `a` to expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	Sub (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Subtracts expression `b` from expression `a` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	SubBorrow (size_t size, ExprId a, ExprId b, ExprId carry, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Subtracts with borrow expression `b` from expression `a` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	And (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Bitwise and's expression `a` and expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	Or (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Bitwise or's expression `a` and expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	Xor (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Xor's expression `a` with expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	ShiftLeft (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Shifts left expression `a` by expression `b` from expression `a` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	LogicalShiftRight (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Shifts logically right expression `a` by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	ArithShiftRight (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Shifts arithmetic right expression `a` by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	RotateLeft (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Bitwise rotates left expression `a` by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	RotateLeftCarry (size_t size, ExprId a, ExprId b, ExprId carry, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Bitwise rotates left with carry expression `a` by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	RotateRight (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Bitwise rotates right expression `a` by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	RotateRightCarry (size_t size, ExprId a, ExprId b, ExprId carry, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Bitwise rotates right with carry expression `a` by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	Mult (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Multiplies expression `a` by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	MultDoublePrecUnsigned (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Multiplies unsigned with double precision expression `a` by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	MultDoublePrecSigned (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Multiplies signed with double precision expression `a` by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	DivUnsigned (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Unsigned divide expression `a` by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	DivDoublePrecUnsigned (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Unsigned double precision divide using expression `a` as a single double precision register by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	DivSigned (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Signed divide expression `a` by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	DivDoublePrecSigned (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Signed double precision divide using expression `a` as a single double precision register by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	ModUnsigned (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Unsigned modulus expression `a` by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	ModDoublePrecUnsigned (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Unsigned double precision modulus using expression `a` as a single double precision register by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	ModSigned (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Signed modulus expression `a` by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	ModDoublePrecSigned (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Signed double precision modulus using expression `a` as a single double precision register by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	Neg (size_t size, ExprId a, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Two's complement sign negation of expression `value` of size `size` potentially setting flags.
ExprId	Not (size_t size, ExprId a, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Bitwise inverse of expression `value` of size `size` potentially setting flags.
ExprId	SignExtend (size_t size, ExprId a, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Two's complement sign-extends the expression in `value` to `size` bytes.
ExprId	ZeroExtend (size_t size, ExprId a, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Zero-extends the expression in `value` to `size` bytes.
ExprId	LowPart (size_t size, ExprId a, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Truncates `value` to `size` bytes.
ExprId	Jump (ExprId dest, const ILSourceLocation &loc=ILSourceLocation())
	Returns an expression which jumps (branches) to the expression `dest`.
ExprId	JumpTo (ExprId dest, const std::map< uint64_t, BNLowLevelILLabel * > &targets, const ILSourceLocation &loc=ILSourceLocation())
ExprId	Call (ExprId dest, const ILSourceLocation &loc=ILSourceLocation())
	Returns an expression which first pushes the address of the next instruction onto the stack then jumps (branches) to the expression `dest`.
ExprId	CallStackAdjust (ExprId dest, int64_t adjust, const std::map< uint32_t, int32_t > &regStackAdjust, const ILSourceLocation &loc=ILSourceLocation())
	Returns an expression which first pushes the address of the next instruction onto the stack then jumps (branches) to the expression `dest` .
ExprId	TailCall (ExprId dest, const ILSourceLocation &loc=ILSourceLocation())
	Returns an expression which jumps (branches) to the expression `dest`.
ExprId	CallSSA (const std::vector< SSARegister > &output, ExprId dest, const std::vector< ExprId > &params, const SSARegister &stack, size_t newMemoryVer, size_t prevMemoryVer, const ILSourceLocation &loc=ILSourceLocation())
ExprId	SystemCallSSA (const std::vector< SSARegister > &output, const std::vector< ExprId > &params, const SSARegister &stack, size_t newMemoryVer, size_t prevMemoryVer, const ILSourceLocation &loc=ILSourceLocation())
ExprId	TailCallSSA (const std::vector< SSARegister > &output, ExprId dest, const std::vector< ExprId > &params, const SSARegister &stack, size_t newMemoryVer, size_t prevMemoryVer, const ILSourceLocation &loc=ILSourceLocation())
ExprId	SeparateParamListSSA (const std::vector< ExprId > &params, const ILSourceLocation &loc=ILSourceLocation())
ExprId	SharedParamSlotSSA (const std::vector< ExprId > &params, const ILSourceLocation &loc=ILSourceLocation())
ExprId	Return (size_t dest, const ILSourceLocation &loc=ILSourceLocation())
	Returns an expression which jumps (branches) to the expression `dest` .
ExprId	NoReturn (const ILSourceLocation &loc=ILSourceLocation())
	Returns an expression that halts disassembly.
ExprId	FlagCondition (BNLowLevelILFlagCondition cond, uint32_t semClass=0, const ILSourceLocation &loc=ILSourceLocation())
	Returns a flag_condition expression for the given LowLevelILFlagCondition.
ExprId	FlagGroup (uint32_t semGroup, const ILSourceLocation &loc=ILSourceLocation())
	Returns a flag_group expression for the given semantic flag group.
ExprId	CompareEqual (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns comparison expression of size `size` checking if expression `a` is equal to expression `b`.
ExprId	CompareNotEqual (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns comparison expression of size `size` checking if expression `a` is not equal to expression `b`.
ExprId	CompareSignedLessThan (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns comparison expression of size `size` checking if expression `a` is signed less than expression `b`.
ExprId	CompareUnsignedLessThan (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns comparison expression of size `size` checking if expression `a` is unsigned less than expression `b`.
ExprId	CompareSignedLessEqual (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns comparison expression of size `size` checking if expression `a` is signed less than or equal to expression `b`.
ExprId	CompareUnsignedLessEqual (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns comparison expression of size `size` checking if expression `a` is unsigned less than or equal to expression `b`.
ExprId	CompareSignedGreaterEqual (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns comparison expression of size `size` checking if expression `a` is signed greater than or equal to expression `b`.
ExprId	CompareUnsignedGreaterEqual (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns comparison expression of size `size` checking if expression `a` is unsigned greater than or equal to expression `b`.
ExprId	CompareSignedGreaterThan (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns comparison expression of size `size` checking if expression `a` is signed greater than or equal to expression `b`.
ExprId	CompareUnsignedGreaterThan (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns comparison expression of size `size` checking if expression `a` is unsigned greater than or equal to expression `b`.
ExprId	TestBit (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
ExprId	BoolToInt (size_t size, ExprId a, const ILSourceLocation &loc=ILSourceLocation())
ExprId	SystemCall (const ILSourceLocation &loc=ILSourceLocation())
	Returns a system call expression.
ExprId	Intrinsic (const std::vector< RegisterOrFlag > &outputs, uint32_t intrinsic, const std::vector< ExprId > &params, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Returns an intrinsic expression.
ExprId	IntrinsicSSA (const std::vector< SSARegisterOrFlag > &outputs, uint32_t intrinsic, const std::vector< ExprId > &params, const ILSourceLocation &loc=ILSourceLocation())
ExprId	MemoryIntrinsicSSA (const std::vector< SSARegisterOrFlag > &outputs, uint32_t intrinsic, const std::vector< ExprId > &params, size_t newMemVersion, size_t prevMemVersion, const ILSourceLocation &loc=ILSourceLocation())
ExprId	Breakpoint (const ILSourceLocation &loc=ILSourceLocation())
	Returns a processor breakpoint expression.
ExprId	Trap (int64_t num, const ILSourceLocation &loc=ILSourceLocation())
	Returns a processor trap (interrupt) expression of the given integer `value` .
ExprId	Undefined (const ILSourceLocation &loc=ILSourceLocation())
	Returns the undefined expression.
ExprId	Unimplemented (const ILSourceLocation &loc=ILSourceLocation())
	Returns the unimplemented expression.
ExprId	UnimplementedMemoryRef (size_t size, ExprId addr, const ILSourceLocation &loc=ILSourceLocation())
	A memory reference to expression `addr` of size `size` with unimplemented operation.
ExprId	RegisterPhi (const SSARegister &dest, const std::vector< SSARegister > &sources, const ILSourceLocation &loc=ILSourceLocation())
ExprId	RegisterStackPhi (const SSARegisterStack &dest, const std::vector< SSARegisterStack > &sources, const ILSourceLocation &loc=ILSourceLocation())
ExprId	FlagPhi (const SSAFlag &dest, const std::vector< SSAFlag > &sources, const ILSourceLocation &loc=ILSourceLocation())
ExprId	MemoryPhi (size_t dest, const std::vector< size_t > &sources, const ILSourceLocation &loc=ILSourceLocation())
ExprId	FloatAdd (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Adds floating point expression `a` to expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	FloatSub (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Subtracts floating point expression `b` from expression `a` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	FloatMult (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Multiplies floating point expression `a` by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	FloatDiv (size_t size, ExprId a, ExprId b, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Divides floating point expression `a` by expression `b` potentially setting flags `flags` and returning an expression of `size` bytes.
ExprId	FloatSqrt (size_t size, ExprId a, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Returns the square root of floating point expression `value` of size `size` potentially setting flags.
ExprId	FloatNeg (size_t size, ExprId a, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Returns sign negation of floating point expression `value` of size `size` potentially setting flags.
ExprId	FloatAbs (size_t size, ExprId a, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Returns absolute value of floating point expression `value` of size `size` potentially setting flags.
ExprId	FloatToInt (size_t size, ExprId a, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Returns integer value of floating point expression `value` of size `size` potentially setting flags.
ExprId	IntToFloat (size_t size, ExprId a, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Returns floating point value of integer expression `value` of size `size` potentially setting flags.
ExprId	FloatConvert (size_t size, ExprId a, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
ExprId	RoundToInt (size_t size, ExprId a, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Rounds a floating point value to the nearest integer.
ExprId	Floor (size_t size, ExprId a, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Rounds a floating point value to an integer, towards negative infinity.
ExprId	Ceil (size_t size, ExprId a, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Rounds a floating point value to an integer, towards positive infinity.
ExprId	FloatTrunc (size_t size, ExprId a, uint32_t flags=0, const ILSourceLocation &loc=ILSourceLocation())
	Rounds a floating point value to an integer towards zero.
ExprId	FloatCompareEqual (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns floating point comparison expression of size `size` checking if expression `a` is equal to expression `b`.
ExprId	FloatCompareNotEqual (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns floating point comparison expression of size `size` checking if expression `a` is not equal to expression `b`.
ExprId	FloatCompareLessThan (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns floating point comparison expression of size `size` checking if expression `a` is less than expression `b`.
ExprId	FloatCompareLessEqual (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns floating point comparison expression of size `size` checking if expression `a` is less than or equal to expression `b`.
ExprId	FloatCompareGreaterEqual (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns floating point comparison expression of size `size` checking if expression `a` is greater than or equal to expression `b`.
ExprId	FloatCompareGreaterThan (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns floating point comparison expression of size `size` checking if expression `a` is greater than expression `b`.
ExprId	FloatCompareOrdered (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns floating point comparison expression of size `size` checking if expression `a` is ordered relative to expression `b`.
ExprId	FloatCompareUnordered (size_t size, ExprId a, ExprId b, const ILSourceLocation &loc=ILSourceLocation())
	Returns floating point comparison expression of size `size` checking if expression `a` is unordered relative to expression `b`.
ExprId	Goto (BNLowLevelILLabel &label, const ILSourceLocation &loc=ILSourceLocation())
	Returns a goto expression which jumps to the provided LowLevelILLabel.
void	MarkLabel (BNLowLevelILLabel &label)
	Returns the `if` expression which depending on condition `operand` jumps to the LowLevelILLabel `t` when the condition expression `operand` is non-zero and f`` when it's zero.
std::vector< uint64_t >	GetOperandList (ExprId i, size_t listOperand)
ExprId	AddLabelMap (const std::map< uint64_t, BNLowLevelILLabel * > &labels)
ExprId	AddOperandList (const std::vector< ExprId > operands)
ExprId	AddIndexList (const std::vector< size_t > operands)
ExprId	AddRegisterOrFlagList (const std::vector< RegisterOrFlag > &regs)
ExprId	AddSSARegisterList (const std::vector< SSARegister > &regs)
ExprId	AddSSARegisterStackList (const std::vector< SSARegisterStack > &regStacks)
ExprId	AddSSAFlagList (const std::vector< SSAFlag > &flags)
ExprId	AddSSARegisterOrFlagList (const std::vector< SSARegisterOrFlag > &regs)
ExprId	GetExprForRegisterOrConstant (const BNRegisterOrConstant &operand, size_t size)
ExprId	GetNegExprForRegisterOrConstant (const BNRegisterOrConstant &operand, size_t size)
ExprId	GetExprForFlagOrConstant (const BNRegisterOrConstant &operand)
ExprId	GetExprForRegisterOrConstantOperation (BNLowLevelILOperation op, size_t size, BNRegisterOrConstant *operands, size_t operandCount)
ExprId	Operand (size_t n, ExprId expr)
BNLowLevelILInstruction	GetRawExpr (size_t i) const
LowLevelILInstruction	operator[] (size_t i)
LowLevelILInstruction	GetInstruction (size_t i)
LowLevelILInstruction	GetExpr (size_t i)
size_t	GetIndexForInstruction (size_t i) const
size_t	GetInstructionForExpr (size_t expr) const
size_t	GetInstructionCount () const
size_t	GetExprCount () const
void	UpdateInstructionOperand (size_t i, size_t operandIndex, ExprId value)
void	ReplaceExpr (size_t expr, size_t newExpr)
void	SetExprAttributes (size_t expr, uint32_t attributes)
void	AddLabelForAddress (Architecture *arch, uint64_t addr)
BNLowLevelILLabel *	GetLabelForAddress (Architecture *arch, uint64_t addr)
	Get the LowLevelILLabel for a given address.
void	Finalize ()
	Ends the function and computes the list of basic blocks.
void	GenerateSSAForm ()
	Generate SSA form given the current LLIL.
bool	GetExprText (Architecture arch, ExprId expr, std::vector< InstructionTextToken > &tokens, DisassemblySettings settings=nullptr)
	Get the list of InstructionTextTokens for a given expression.
bool	GetInstructionText (Function func, Architecture arch, size_t i, std::vector< InstructionTextToken > &tokens, DisassemblySettings *settings=nullptr)
	Get the list of InstructionTextTokens for a given instruction.
uint32_t	GetTemporaryRegisterCount ()
uint32_t	GetTemporaryFlagCount ()
std::vector< Ref< BasicBlock > >	GetBasicBlocks () const
Ref< BasicBlock >	GetBasicBlockForInstruction (size_t i) const
Ref< LowLevelILFunction >	GetSSAForm () const
Ref< LowLevelILFunction >	GetNonSSAForm () const
size_t	GetSSAInstructionIndex (size_t instr) const
size_t	GetNonSSAInstructionIndex (size_t instr) const
size_t	GetSSAExprIndex (size_t instr) const
size_t	GetNonSSAExprIndex (size_t instr) const
size_t	GetSSARegisterDefinition (const SSARegister &reg) const
size_t	GetSSAFlagDefinition (const SSAFlag &flag) const
size_t	GetSSAMemoryDefinition (size_t version) const
std::set< size_t >	GetSSARegisterUses (const SSARegister &reg) const
std::set< size_t >	GetSSAFlagUses (const SSAFlag &flag) const
std::set< size_t >	GetSSAMemoryUses (size_t version) const
RegisterValue	GetSSARegisterValue (const SSARegister &reg)
RegisterValue	GetSSAFlagValue (const SSAFlag &flag)
RegisterValue	GetExprValue (size_t expr)
RegisterValue	GetExprValue (const LowLevelILInstruction &expr)
PossibleValueSet	GetPossibleExprValues (size_t expr, const std::set< BNDataFlowQueryOption > &options=std::set< BNDataFlowQueryOption >())
PossibleValueSet	GetPossibleExprValues (const LowLevelILInstruction &expr, const std::set< BNDataFlowQueryOption > &options=std::set< BNDataFlowQueryOption >())
RegisterValue	GetRegisterValueAtInstruction (uint32_t reg, size_t instr)
RegisterValue	GetRegisterValueAfterInstruction (uint32_t reg, size_t instr)
PossibleValueSet	GetPossibleRegisterValuesAtInstruction (uint32_t reg, size_t instr, const std::set< BNDataFlowQueryOption > &options=std::set< BNDataFlowQueryOption >())
PossibleValueSet	GetPossibleRegisterValuesAfterInstruction (uint32_t reg, size_t instr, const std::set< BNDataFlowQueryOption > &options=std::set< BNDataFlowQueryOption >())
RegisterValue	GetFlagValueAtInstruction (uint32_t flag, size_t instr)
RegisterValue	GetFlagValueAfterInstruction (uint32_t flag, size_t instr)
PossibleValueSet	GetPossibleFlagValuesAtInstruction (uint32_t flag, size_t instr, const std::set< BNDataFlowQueryOption > &options=std::set< BNDataFlowQueryOption >())
PossibleValueSet	GetPossibleFlagValuesAfterInstruction (uint32_t flag, size_t instr, const std::set< BNDataFlowQueryOption > &options=std::set< BNDataFlowQueryOption >())
RegisterValue	GetStackContentsAtInstruction (int32_t offset, size_t len, size_t instr)
RegisterValue	GetStackContentsAfterInstruction (int32_t offset, size_t len, size_t instr)
PossibleValueSet	GetPossibleStackContentsAtInstruction (int32_t offset, size_t len, size_t instr, const std::set< BNDataFlowQueryOption > &options=std::set< BNDataFlowQueryOption >())
PossibleValueSet	GetPossibleStackContentsAfterInstruction (int32_t offset, size_t len, size_t instr, const std::set< BNDataFlowQueryOption > &options=std::set< BNDataFlowQueryOption >())
Ref< MediumLevelILFunction >	GetMediumLevelIL () const
Ref< MediumLevelILFunction >	GetMappedMediumLevelIL () const
size_t	GetMediumLevelILInstructionIndex (size_t instr) const
size_t	GetMediumLevelILExprIndex (size_t expr) const
std::set< size_t >	GetMediumLevelILExprIndexes (size_t expr) const
size_t	GetMappedMediumLevelILInstructionIndex (size_t instr) const
size_t	GetMappedMediumLevelILExprIndex (size_t expr) const
Ref< FlowGraph >	CreateFunctionGraph (DisassemblySettings *settings=nullptr)
Ref< FlowGraph >	CreateFunctionGraphImmediate (DisassemblySettings *settings=nullptr)
Public Member Functions inherited from BinaryNinja::CoreRefCountObject< BNLowLevelILFunction, BNNewLowLevelILFunctionReference, BNFreeLowLevelILFunction >
	CoreRefCountObject ()
virtual	~CoreRefCountObject ()
BNLowLevelILFunction *	GetObject () const
void	AddRef ()
void	Release ()
void	AddRefForRegistration ()
void	ReleaseForRegistration ()
void	AddRefForCallback ()
void	ReleaseForCallback ()
Static Public Member Functions
static bool	IsConstantType (BNLowLevelILOperation type)

◆ LowLevelILFunction() [1/2]

◆ LowLevelILFunction() [2/2]

◆ GetFunction()

Ref< Function > LowLevelILFunction::GetFunction

(

)

const

◆ GetArchitecture()

◆ PrepareToCopyFunction()

void LowLevelILFunction::PrepareToCopyFunction

(

LowLevelILFunction *

func

)

◆ PrepareToCopyBlock()

void LowLevelILFunction::PrepareToCopyBlock

(

BasicBlock *

block

)

◆ GetLabelForSourceInstruction()

Get the LowLevelILLabel for a given source instruction.

The returned pointer is to an internal object with the same lifetime as the containing LowLevelILFunction.

Parameters

i	The source instruction index

Returns: The LowLevelILLabel for the source instruction

◆ GetCurrentAddress()

uint64_t LowLevelILFunction::GetCurrentAddress

(

)

const

Get the current IL address.

◆ SetCurrentAddress()

void LowLevelILFunction::SetCurrentAddress	(	Architecture *	arch,
		uint64_t	addr )

◆ GetInstructionStart()

size_t LowLevelILFunction::GetInstructionStart	(	Architecture *	arch,
		uint64_t	addr )

◆ GetInstructionsAt()

std::set< size_t > LowLevelILFunction::GetInstructionsAt	(	Architecture *	arch,
		uint64_t	addr )

◆ GetExitsForInstruction()

std::vector< size_t > LowLevelILFunction::GetExitsForInstruction

(

size_t

)

◆ ClearIndirectBranches()

void LowLevelILFunction::ClearIndirectBranches

(

)

◆ SetIndirectBranches()

void LowLevelILFunction::SetIndirectBranches

(

const std::vector< ArchAndAddr > &

branches

)

◆ GetRegisters()

std::vector< uint32_t > LowLevelILFunction::GetRegisters

(

)

◆ GetRegisterStacks()

std::vector< uint32_t > LowLevelILFunction::GetRegisterStacks

(

)

Get a list of used register stacks used in the LLIL function.

Returns: List of used register stacks

◆ GetFlags()

std::vector< uint32_t > LowLevelILFunction::GetFlags

(

)

◆ GetSSARegistersWithoutVersions()

std::vector< SSARegister > LowLevelILFunction::GetSSARegistersWithoutVersions

(

)

◆ GetSSARegisterStacksWithoutVersions()

std::vector< SSARegisterStack > LowLevelILFunction::GetSSARegisterStacksWithoutVersions

(

)

◆ GetSSAFlagsWithoutVersions()

std::vector< SSAFlag > LowLevelILFunction::GetSSAFlagsWithoutVersions

(

)

◆ GetSSARegisters()

std::vector< SSARegister > LowLevelILFunction::GetSSARegisters

(

)

◆ GetSSARegisterStacks()

std::vector< SSARegisterStack > LowLevelILFunction::GetSSARegisterStacks

(

)

◆ GetSSAFlags()

std::vector< SSAFlag > LowLevelILFunction::GetSSAFlags

(

)

◆ CachePossibleValueSet()

size_t LowLevelILFunction::CachePossibleValueSet

(

const PossibleValueSet &

pvs

)

◆ GetCachedPossibleValueSet()

◆ AddExpr()

◆ AddExprWithLocation() [1/2]

◆ AddExprWithLocation() [2/2]

◆ AddInstruction()

◆ Nop()

No operation, this instruction does nothing.

Parameters

loc	Optional IL Location this instruction was added from.

Returns

◆ SetRegister()

Sets the register reg of size size to the expression value.

Parameters

size	Size of the register parameter in bytes
reg	The register name
val	An expression to set the register to
flags	Which flags are set by this operation
loc	Optional IL Location this instruction was added from.

Returns: The expression reg = value

◆ SetRegisterSplit()

Uses hi and lo as a single extended register setting hi:lo to the expression value .

Parameters

size	Size of the register parameter in bytes
high	The high register name
low	The low register name
val	An expression to set the split registers to
flags	Which flags are set by this operation
loc	Optional IL Location this instruction was added from.

Returns: The expression hi:lo = value

◆ SetRegisterSSA()

◆ SetRegisterSSAPartial()

◆ SetRegisterSplitSSA()

◆ SetRegisterStackTopRelative()

Sets the top-relative entry entry of size size in register stack reg_stack to the expression value.

Parameters

size	Size of the register parameter in bytes
regStack	The register stack name
entry	An expression for which stack entry to set
val	An expression to set the entry to
flags	Which flags are set by this operation
loc	Optional IL Location this instruction was added from.

Returns: The expression reg_stack[entry] = value

◆ RegisterStackPush()

Pushes the expression value of size size onto the top of the register stack reg_stack.

Parameters

size	Size of the register parameter in bytes
regStack	The register stack name
val	An expression to push
flags	Which flags are set by this operation
loc	Optional IL Location this instruction was added from.

Returns: The expression reg_stack.push(value)

◆ SetRegisterStackTopRelativeSSA()

◆ SetRegisterStackAbsoluteSSA()

◆ SetFlag()

Sets the flag flag to the ExpressionIndex value.

Parameters

flag	Flag index
val	An expression to set the flag to
loc	Optional IL Location this instruction was added from.

Returns: The expression FLAG.flag = value

◆ SetFlagSSA()

◆ ForceVer()

◆ ForceVerSSA()

◆ Assert()

◆ AssertSSA()

◆ Load()

Reads size bytes from the expression addr.

Parameters

size	Number of bytes to read
addr	The expression to read memory from
flags	Flags set by this expression
loc	Optional IL Location this instruction was added from.

Returns: The expression [addr].size

◆ LoadSSA()

◆ Store()

Writes size bytes to expression addr read from expression val.

Parameters

size	Number of bytes to write
addr	The expression to write to
val	The expression to be written
flags	Which flags are set by this operation
loc	Optional IL Location this instruction was added from.

Returns: The expression [addr].size = value

◆ StoreSSA()

◆ Push()

Writes size bytes from expression value to the stack, adjusting the stack by size .

Parameters

size	Number of bytes to write and adjust the stack by
val	The expression to write
flags	Flags set by this expression
loc	Optional IL Location this instruction was added from.

Returns: The expression push(value)

◆ Pop()

Reads ``size`` bytes from the stack, adjusting the stack by ``size``.

Parameters

size	Number of bytes to read from the stack
flags	Flags set by this expression
loc	Optional IL Location this instruction was added from.

Returns: The expression pop

◆ Register()

Returns a register of size size with name reg.

Parameters

size	The size of the register in bytes
reg	The name of the register
loc	Optional IL Location this instruction was added from.

Returns: A register expression for the given register

◆ RegisterSSA()

◆ RegisterSSAPartial()

◆ RegisterSplit()

Combines registers of size ``size`` with names ``hi`` and ``lo``.

Parameters

size	The size of the register in bytes
high	Register holding high part of value
low	Register holding low part of value
loc	Optional IL Location this instruction was added from.

Returns: The expression hi:lo

◆ RegisterSplitSSA()

◆ RegisterStackTopRelative()

Returns a register stack entry of size size at top-relative location entry in register stack with name regStack.

Parameters

size	The size of the register in bytes
regStack	The index of the register stack
entry	An expression for which stack entry to fetch
loc	Optional IL Location this instruction was added from.

Returns: The expression reg_stack[entry]

◆ RegisterStackPop()

Returns the top entry of size size in register stack with name reg_stack , and removes the entry from the stack.

Parameters

size	The size of the register in bytes
regStack	The index of the register stack
flags	Any flags set by this expression
loc	Optional IL Location this instruction was added from.

Returns: The expression reg_stack.pop

◆ RegisterStackFreeReg()

◆ RegisterStackFreeTopRelative()

◆ RegisterStackTopRelativeSSA()

◆ RegisterStackAbsoluteSSA()

◆ RegisterStackFreeTopRelativeSSA()

◆ RegisterStackFreeAbsoluteSSA()

◆ Const()

Returns an expression for the constant integer value with size size.

Parameters

size	The size of the constant in bytes
val	Integer value of the constant
loc	Optional IL Location this instruction was added from.

Returns: A constant expression of given value and size

◆ ConstPointer()

Returns an expression for the constant pointer value with size size.

Parameters

size	The size of the pointer in bytes
val	Address referenced by pointer
loc	Optional IL Location this instruction was added from.

Returns: A constant pointer expression of given value and size

◆ ExternPointer()

Returns an expression for the constant relocated pointer ``value`` with size ``size``.

Parameters

size	The size of the pointer in bytes
val	Address referenced by pointer
offset
loc	Optional IL Location this instruction was added from.

Returns: A constant expression of given value and size

◆ FloatConstRaw()

Returns an expression for the constant raw binary floating point value value with size size.

To clarify, value here is the representation of the float if its bits were instead interpreted as an integer.

A given float could be converted to an integer value like so:

union {

float floatValue;

uint32_t integerValue;

} bits;

bits.floatValue = val;

uint32_t myIntValueToPassToThisFunction = bits.integerValue;

Do note this is exactly how FloatConstSingle and FloatConstDouble perform this conversion (and thus, converting it yourself is typically redundant.)

Parameters

size	The size of the constant in bytes
val	Integer value for the raw binary representation of the constant
loc	Optional IL Location this instruction was added from.

Returns: A constant expression of given value and size

◆ FloatConstSingle()

Returns an expression for the single precision floating point value value.

Parameters

val	Float value for the constant
loc	Optional IL Location this instruction was added from.

Returns: A constant expression of given value and size

◆ FloatConstDouble()

Returns an expression for the double precision floating point value value.

Parameters

val	Float value for the constant
loc	Optional IL Location this instruction was added from.

Returns: A constant expression of given value and size

◆ Flag()

Returns a flag expression for the given flag index.

Parameters

flag	Flag index
loc	Optional IL Location this expression was added from.

Returns: A flag expression for the given flag

◆ FlagSSA()

◆ FlagBit()

Sets the flag with index flag and size size to the constant integer value bit.

Parameters

size	The size of the flag
flag	Flag index
bitIndex	Bit of the flag to set
loc	Optional IL Location this expression was added from.

Returns: A constant expression of given value and size FLAG.reg = bit

◆ FlagBitSSA()

◆ Add()

Adds expression a to expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	flags to set
loc	Optional IL Location this expression was added from.

Returns: A constant expression of given value and size FLAG.reg = bit

◆ AddCarry()

Adds with carry expression a to expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
carry	Carry flag expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression adc.<size>{<flags>}(a, b, carry)

◆ Sub()

Subtracts expression b from expression a potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression sub.<size>{<flags>}(a, b)

◆ SubBorrow()

Subtracts with borrow expression b from expression a potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
carry	Carry flag expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression sbb.<size>{<flags>}(a, b, carry)

◆ And()

Bitwise and's expression a and expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression and.<size>{<flags>}(a, b)

◆ Or()

Bitwise or's expression a and expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression or.<size>{<flags>}(a, b)

◆ Xor()

Xor's expression a with expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression xor.<size>{<flags>}(a, b)

◆ ShiftLeft()

Shifts left expression a by expression b from expression a potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression lsl.<size>{<flags>}(a, b)

◆ LogicalShiftRight()

Shifts logically right expression a by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression lsr.<size>{<flags>}(a, b)

◆ ArithShiftRight()

Shifts arithmetic right expression a by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression asr.<size>{<flags>}(a, b)

◆ RotateLeft()

Bitwise rotates left expression a by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression rol.<size>{<flags>}(a, b)

◆ RotateLeftCarry()

Bitwise rotates left with carry expression a by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
carry	Carry flag expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression rlc.<size>{<flags>}(a, b, carry)

◆ RotateRight()

Bitwise rotates right expression a by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression ror.<size>{<flags>}(a, b)

◆ RotateRightCarry()

Bitwise rotates right with carry expression a by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
carry	Carry flag expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression rrc.<size>{<flags>}(a, b, carry)

◆ Mult()

Multiplies expression a by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression mul.<size>{<flags>}(a, b)

◆ MultDoublePrecUnsigned()

Multiplies unsigned with double precision expression a by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression mulu.dp.<size>{<flags>}(a, b)

◆ MultDoublePrecSigned()

Multiplies signed with double precision expression a by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression muls.dp.<size>{<flags>}(a, b)

◆ DivUnsigned()

Unsigned divide expression a by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression divu.<size>{<flags>}(a, b)

◆ DivDoublePrecUnsigned()

Unsigned double precision divide using expression a as a single double precision register by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression mods.dp.<size>{<flags>}(a, b)

◆ DivSigned()

Signed divide expression a by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression divs.<size>{<flags>}(a, b)

◆ DivDoublePrecSigned()

Signed double precision divide using expression a as a single double precision register by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression divs.dp.<size>{<flags>}(a, b)

◆ ModUnsigned()

Unsigned modulus expression a by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression modu.<size>{<flags>}(a, b)

◆ ModDoublePrecUnsigned()

Unsigned double precision modulus using expression a as a single double precision register by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression modu.dp.<size>{<flags>}(a, b)

◆ ModSigned()

Signed modulus expression a by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression mods.<size>{<flags>}(a, b)

◆ ModDoublePrecSigned()

Signed double precision modulus using expression a as a single double precision register by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression mods.dp.<size>{<flags>}(a, b)

◆ Neg()

Two's complement sign negation of expression value of size size potentially setting flags.

Parameters

size	The size of the result in bytes
a	The expression to negate
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression neg.<size>{<flags>}(value)

◆ Not()

Bitwise inverse of expression value of size size potentially setting flags.

Parameters

size	The size of the result in bytes
a	The expression to bitwise invert
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression not.<size>{<flags>}(value)

◆ SignExtend()

Two's complement sign-extends the expression in value to size bytes.

Parameters

size	The size of the result in bytes
a	The expression to sign extend
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression sx.<size>(value)

◆ ZeroExtend()

Zero-extends the expression in value to size bytes.

Parameters

size	The size of the result in bytes
a	The expression to zero extend
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression sx.<size>(value)

◆ LowPart()

Truncates value to size bytes.

Parameters

size	The size of the result in bytes
a	The expression to truncate
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression zx.<size>(value)

◆ Jump()

Returns an expression which jumps (branches) to the expression dest.

Parameters

dest	The expression to jump to
loc	Optional IL Location this expression was added from.

Returns: The expression jump(dest)

◆ JumpTo()

◆ Call()

Returns an expression which first pushes the address of the next instruction onto the stack then jumps (branches) to the expression dest.

Parameters

dest	The expression to call
loc	Optional IL Location this expression was added from.

Returns: The expression call(dest)

◆ CallStackAdjust()

Returns an expression which first pushes the address of the next instruction onto the stack then jumps (branches) to the expression dest .

After the function exits, stack_adjust is added to the stack pointer register.

Parameters

dest	The expression to call
adjust	Stack adjustment
regStackAdjust	Register stack adjustment
loc	Optional IL Location this expression was added from.

Returns: The expression call(dest), stack += stack_adjust

◆ TailCall()

Returns an expression which jumps (branches) to the expression dest.

Parameters

dest	The expression to jump to
loc	Optional IL Location this expression was added from.

Returns: The expression tailcall(dest)

◆ CallSSA()

◆ SystemCallSSA()

◆ TailCallSSA()

◆ SeparateParamListSSA()

◆ SharedParamSlotSSA()

◆ Return()

Returns an expression which jumps (branches) to the expression dest .

ret is a special alias for jump that makes the disassembler stop disassembling.

Parameters

dest	The expression to jump to
loc	Optional IL Location this expression was added from.

Returns: The expression jump(dest)

◆ NoReturn()

Returns an expression that halts disassembly.

Parameters

loc	Optional IL Location this expression was added from.

Returns: The expression noreturn

◆ FlagCondition()

Returns a flag_condition expression for the given LowLevelILFlagCondition.

Parameters

cond	Flag condition expression to retrieve
semClass	Optional semantic flag class
loc	Optional IL Location this expression was added from.

Returns: A flag_condition expression

◆ FlagGroup()

Returns a flag_group expression for the given semantic flag group.

Parameters

semGroup	Semantic flag group to access
loc	Optional IL Location this expression was added from.

Returns: A flag_group expression

◆ CompareEqual()

Returns comparison expression of size size checking if expression a is equal to expression b.

Parameters

size	Size in bytes
a	LHS of comparison
b	RHS of comparison
loc	Optional IL Location this expression was added from.

Returns: a comparison expression.

◆ CompareNotEqual()

Returns comparison expression of size size checking if expression a is not equal to expression b.

Parameters

size	Size in bytes
a	LHS of comparison
b	RHS of comparison
loc	Optional IL Location this expression was added from.

Returns: a comparison expression.

◆ CompareSignedLessThan()

Returns comparison expression of size size checking if expression a is signed less than expression b.

Parameters

size	Size in bytes
a	LHS of comparison
b	RHS of comparison
loc	Optional IL Location this expression was added from.

Returns: a comparison expression.

◆ CompareUnsignedLessThan()

Returns comparison expression of size size checking if expression a is unsigned less than expression b.

Parameters

size	Size in bytes
a	LHS of comparison
b	RHS of comparison
loc	Optional IL Location this expression was added from.

Returns: a comparison expression.

◆ CompareSignedLessEqual()

Returns comparison expression of size size checking if expression a is signed less than or equal to expression b.

Parameters

size	Size in bytes
a	LHS of comparison
b	RHS of comparison
loc	Optional IL Location this expression was added from.

Returns: a comparison expression.

◆ CompareUnsignedLessEqual()

Returns comparison expression of size size checking if expression a is unsigned less than or equal to expression b.

Parameters

size	Size in bytes
a	LHS of comparison
b	RHS of comparison
loc	Optional IL Location this expression was added from.

Returns: a comparison expression.

◆ CompareSignedGreaterEqual()

Returns comparison expression of size size checking if expression a is signed greater than or equal to expression b.

Parameters

size	Size in bytes
a	LHS of comparison
b	RHS of comparison
loc	Optional IL Location this expression was added from.

Returns: a comparison expression.

◆ CompareUnsignedGreaterEqual()

Returns comparison expression of size size checking if expression a is unsigned greater than or equal to expression b.

Parameters

size	Size in bytes
a	LHS of comparison
b	RHS of comparison
loc	Optional IL Location this expression was added from.

Returns: a comparison expression.

◆ CompareSignedGreaterThan()

Returns comparison expression of size size checking if expression a is signed greater than or equal to expression b.

Parameters

size	Size in bytes
a	LHS of comparison
b	RHS of comparison
loc	Optional IL Location this expression was added from.

Returns: a comparison expression.

◆ CompareUnsignedGreaterThan()

Returns comparison expression of size size checking if expression a is unsigned greater than or equal to expression b.

Parameters

size	Size in bytes
a	LHS of comparison
b	RHS of comparison
loc	Optional IL Location this expression was added from.

Returns: a comparison expression.

◆ TestBit()

◆ BoolToInt()

◆ SystemCall()

Returns a system call expression.

Parameters

loc	Optional IL Location this expression was added from.

Returns: System call expression.

◆ Intrinsic()

Returns an intrinsic expression.

'Intrinsics' are emitted and lifted as if they were builtin functions that do not exist in the binary.

Parameters

Returns: An intrinsic expression.

◆ IntrinsicSSA()

◆ MemoryIntrinsicSSA()

ExprId LowLevelILFunction::MemoryIntrinsicSSA	(	const std::vector< SSARegisterOrFlag > &	outputs,
		uint32_t	intrinsic,
		const std::vector< ExprId > &	params,
		size_t	newMemVersion,
		size_t	prevMemVersion,
		const ILSourceLocation &	loc = ILSourceLocation() )

◆ Breakpoint()

Returns a processor breakpoint expression.

Parameters

loc	Optional IL Location this expression was added from.

Returns: A breakpoint expression.

◆ Trap()

Returns a processor trap (interrupt) expression of the given integer value .

Parameters

num	trap (interrupt) number
loc	Optional IL Location this expression was added from.

Returns: A trap expression.

◆ Undefined()

Returns the undefined expression.

This should be used for instructions which perform functions but aren't important for dataflow or partial emulation purposes.

Parameters

loc	Optional IL Location this expression was added from.

Returns: The Undefined expression

◆ Unimplemented()

Returns the unimplemented expression.

This should be used for instructions which aren't implemented

Parameters

loc	Optional IL Location this expression was added from.

Returns: The unimplemented expression

◆ UnimplementedMemoryRef()

A memory reference to expression addr of size size with unimplemented operation.

Parameters

size	Size in bytes of the memory reference
addr	Expression to reference memory
loc	Optional IL Location this expression was added from.

Returns: The unimplemented memory reference expression.

◆ RegisterPhi()

◆ RegisterStackPhi()

◆ FlagPhi()

◆ MemoryPhi()

◆ FloatAdd()

Adds floating point expression a to expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression fadd.<size>{<flags>}(a, b)

◆ FloatSub()

Subtracts floating point expression b from expression a potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression fsub.<size>{<flags>}(a, b)

◆ FloatMult()

Multiplies floating point expression a by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression fmul.<size>{<flags>}(a, b)

◆ FloatDiv()

Divides floating point expression a by expression b potentially setting flags flags and returning an expression of size bytes.

Parameters

size	The size of the result in bytes
a	LHS expression
b	RHS expression
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression fdiv.<size>{<flags>}(a, b)

◆ FloatSqrt()

Returns the square root of floating point expression value of size size potentially setting flags.

Parameters

size	The size of the result in bytes
a	The expression to calculate the square root of
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression sqrt.<size>{<flags>}(value)

◆ FloatNeg()

Returns sign negation of floating point expression value of size size potentially setting flags.

Parameters

size	The size of the result in bytes
a	The expression to negate
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression fneg.<size>{<flags>}(value)

◆ FloatAbs()

Returns absolute value of floating point expression value of size size potentially setting flags.

Parameters

size	The size of the result in bytes
a	The expression to get the absolute value of
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression fabs.<size>{<flags>}(value)

◆ FloatToInt()

Returns integer value of floating point expression value of size size potentially setting flags.

Parameters

size	The size of the result in bytes
a	The float expression to convert to an int
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression int.<size>{<flags>}(value)

◆ IntToFloat()

Returns floating point value of integer expression value of size size potentially setting flags.

Parameters

size	The size of the result in bytes
a	The float expression to convert to a float
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression float.<size>{<flags>}(value)

◆ FloatConvert()

◆ RoundToInt()

Rounds a floating point value to the nearest integer.

Parameters

size	The size of the result in bytes
a	The expression to round to the nearest integer
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression roundint.<size>{<flags>}(value)

◆ Floor()

Rounds a floating point value to an integer, towards negative infinity.

Parameters

size	The size of the result in bytes
a	The expression to round down
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression roundint.<size>{<flags>}(value)

◆ Ceil()

Rounds a floating point value to an integer, towards positive infinity.

Parameters

size	The size of the result in bytes
a	The expression to round up
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression roundint.<size>{<flags>}(value)

◆ FloatTrunc()

Rounds a floating point value to an integer towards zero.

Parameters

size	The size of the result in bytes
a	The expression to truncate
flags	Flags to set
loc	Optional IL Location this expression was added from.

Returns: The expression roundint.<size>{<flags>}(value)

◆ FloatCompareEqual()

Returns floating point comparison expression of size size checking if expression a is equal to expression b.

Parameters

size	The size of the operands in bytes
a	LHS expression
b	RHS expression
loc	Optional IL Location this expression was added from.

Returns: The expression a f== b

◆ FloatCompareNotEqual()

Returns floating point comparison expression of size size checking if expression a is not equal to expression b.

Parameters

size	The size of the operands in bytes
a	LHS expression
b	RHS expression
loc	Optional IL Location this expression was added from.

Returns: The expression a f!= b

◆ FloatCompareLessThan()

Returns floating point comparison expression of size size checking if expression a is less than expression b.

Parameters

size	The size of the operands in bytes
a	LHS expression
b	RHS expression
loc	Optional IL Location this expression was added from.

Returns: The expression a f< b

◆ FloatCompareLessEqual()

Returns floating point comparison expression of size size checking if expression a is less than or equal to expression b.

Parameters

size	The size of the operands in bytes
a	LHS expression
b	RHS expression
loc	Optional IL Location this expression was added from.

Returns: The expression a f<= b

◆ FloatCompareGreaterEqual()

Returns floating point comparison expression of size size checking if expression a is greater than or equal to expression b.

Parameters

size	The size of the operands in bytes
a	LHS expression
b	RHS expression
loc	Optional IL Location this expression was added from.

Returns: The expression a f>= b

◆ FloatCompareGreaterThan()

Returns floating point comparison expression of size size checking if expression a is greater than expression b.

Parameters

size	The size of the operands in bytes
a	LHS expression
b	RHS expression
loc	Optional IL Location this expression was added from.

Returns: The expression a f> b

◆ FloatCompareOrdered()

Returns floating point comparison expression of size size checking if expression a is ordered relative to expression b.

Parameters

size	The size of the operands in bytes
a	LHS expression
b	RHS expression
loc	Optional IL Location this expression was added from.

Returns: The expression is_ordered(a, b)

◆ FloatCompareUnordered()

Returns floating point comparison expression of size size checking if expression a is unordered relative to expression b.

Parameters

size	The size of the operands in bytes
a	LHS expression
b	RHS expression
loc	Optional IL Location this expression was added from.

Returns: The expression is_unordered(a, b)

◆ Goto()

Returns a goto expression which jumps to the provided LowLevelILLabel.

Parameters

label	Label to jump to
loc	Optional IL Location this expression was added from.

Returns: a Goto expression

◆ MarkLabel()

Returns the if expression which depending on condition operand jumps to the LowLevelILLabel t when the condition expression operand is non-zero and f`` when it's zero.

Parameters

operand	Comparison expression to evaluate.
t	Label for the true branch
f	Label for the false branch
loc	Optional IL Location this expression was added from.

Returns: the ExpressionIndex for the if expression */ ExprId If(ExprId operand, BNLowLevelILLabel& t, BNLowLevelILLabel& f, const ILSourceLocation& loc = ILSourceLocation());

/*! Assigns a LowLevelILLabel to the current IL address.

Parameters

◆ GetOperandList()

vector< uint64_t > LowLevelILFunction::GetOperandList	(	ExprId	i,
		size_t	listOperand )

◆ AddLabelMap()

◆ AddOperandList()

ExprId LowLevelILFunction::AddOperandList

(

const std::vector< ExprId >

operands

)

◆ AddIndexList()

ExprId LowLevelILFunction::AddIndexList

(

const std::vector< size_t >

operands

)

◆ AddRegisterOrFlagList()

ExprId LowLevelILFunction::AddRegisterOrFlagList

(

const std::vector< RegisterOrFlag > &

regs

)

◆ AddSSARegisterList()

ExprId LowLevelILFunction::AddSSARegisterList

(

const std::vector< SSARegister > &

regs

)

◆ AddSSARegisterStackList()

ExprId LowLevelILFunction::AddSSARegisterStackList

(

const std::vector< SSARegisterStack > &

regStacks

)

◆ AddSSAFlagList()

ExprId LowLevelILFunction::AddSSAFlagList

(

const std::vector< SSAFlag > &

flags

)

◆ AddSSARegisterOrFlagList()

ExprId LowLevelILFunction::AddSSARegisterOrFlagList

(

const std::vector< SSARegisterOrFlag > &

regs

)

◆ GetExprForRegisterOrConstant()

◆ GetNegExprForRegisterOrConstant()

◆ GetExprForFlagOrConstant()

◆ GetExprForRegisterOrConstantOperation()

◆ Operand()

ExprId LowLevelILFunction::Operand	(	size_t	n,
		ExprId	expr )

◆ GetRawExpr()

◆ operator[]()

LowLevelILInstruction LowLevelILFunction::operator[]

(

size_t

)

◆ GetInstruction()

LowLevelILInstruction LowLevelILFunction::GetInstruction

(

size_t

)

◆ GetExpr()

LowLevelILInstruction LowLevelILFunction::GetExpr

(

size_t

)

◆ GetIndexForInstruction()

size_t LowLevelILFunction::GetIndexForInstruction

(

size_t

)

const

◆ GetInstructionForExpr()

size_t LowLevelILFunction::GetInstructionForExpr

(

size_t

expr

)

const

◆ GetInstructionCount()

size_t LowLevelILFunction::GetInstructionCount

(

)

const

◆ GetExprCount()

size_t LowLevelILFunction::GetExprCount

(

)

const

◆ UpdateInstructionOperand()

void LowLevelILFunction::UpdateInstructionOperand	(	size_t	i,
		size_t	operandIndex,
		ExprId	value )

◆ ReplaceExpr()

void LowLevelILFunction::ReplaceExpr	(	size_t	expr,
		size_t	newExpr )

◆ SetExprAttributes()

void LowLevelILFunction::SetExprAttributes	(	size_t	expr,
		uint32_t	attributes )

◆ AddLabelForAddress()

void LowLevelILFunction::AddLabelForAddress	(	Architecture *	arch,
		uint64_t	addr )

◆ GetLabelForAddress()

Get the LowLevelILLabel for a given address.

The returned pointer is to an internal object with the same lifetime as the containing LowLevelILFunction.

Parameters

[in]	arch	Architecture for the address
[in]	addr	Address to get the label for

Returns: The LowLevelILLabel for the address

◆ Finalize()

void LowLevelILFunction::Finalize

(

)

Ends the function and computes the list of basic blocks.

◆ GenerateSSAForm()

void LowLevelILFunction::GenerateSSAForm

(

)

Generate SSA form given the current LLIL.

◆ GetExprText()

Get the list of InstructionTextTokens for a given expression.

Parameters

[in]	arch	Architecture for the expression
[in]	expr	Expression to get the text for
[out]	tokens	Output reference to write the instruction tokens to
[in]	settings	Optional structure with settings for rendering text

Returns: True/False on success or failure

◆ GetInstructionText()

Get the list of InstructionTextTokens for a given instruction.

Parameters

[in]	func	Function containing the instruction
[in]	arch	Architecture for the instruction
[in]	i	Index of the instruction
[out]	tokens	Output reference to write the instruction tokens to
[in]	settings	Optional structure with settings for rendering text

Returns: True/False on success or failure

◆ GetTemporaryRegisterCount()

uint32_t LowLevelILFunction::GetTemporaryRegisterCount

(

)

◆ GetTemporaryFlagCount()

uint32_t LowLevelILFunction::GetTemporaryFlagCount

(

)

◆ GetBasicBlocks()

vector< Ref< BasicBlock > > LowLevelILFunction::GetBasicBlocks

(

)

const

◆ GetBasicBlockForInstruction()

Ref< BasicBlock > LowLevelILFunction::GetBasicBlockForInstruction

(

size_t

)

const

◆ GetSSAForm()

Ref< LowLevelILFunction > LowLevelILFunction::GetSSAForm

(

)

const

◆ GetNonSSAForm()

Ref< LowLevelILFunction > LowLevelILFunction::GetNonSSAForm

(

)

const

◆ GetSSAInstructionIndex()

size_t LowLevelILFunction::GetSSAInstructionIndex

(

size_t

instr

)

const

◆ GetNonSSAInstructionIndex()

size_t LowLevelILFunction::GetNonSSAInstructionIndex

(

size_t

instr

)

const

◆ GetSSAExprIndex()

size_t LowLevelILFunction::GetSSAExprIndex

(

size_t

instr

)

const

◆ GetNonSSAExprIndex()

size_t LowLevelILFunction::GetNonSSAExprIndex

(

size_t

instr

)

const

◆ GetSSARegisterDefinition()

size_t LowLevelILFunction::GetSSARegisterDefinition

(

const SSARegister &

reg

)

const

◆ GetSSAFlagDefinition()

size_t LowLevelILFunction::GetSSAFlagDefinition

(

const SSAFlag &

flag

)

const

◆ GetSSAMemoryDefinition()

size_t LowLevelILFunction::GetSSAMemoryDefinition

(

size_t

version

)

const

◆ GetSSARegisterUses()

set< size_t > LowLevelILFunction::GetSSARegisterUses

(

const SSARegister &

reg

)

const

◆ GetSSAFlagUses()

set< size_t > LowLevelILFunction::GetSSAFlagUses

(

const SSAFlag &

flag

)

const

◆ GetSSAMemoryUses()

set< size_t > LowLevelILFunction::GetSSAMemoryUses

(

size_t

version

)

const

◆ GetSSARegisterValue()

◆ GetSSAFlagValue()

◆ GetExprValue() [1/2]

◆ GetExprValue() [2/2]

◆ GetPossibleExprValues() [1/2]

◆ GetPossibleExprValues() [2/2]

◆ GetRegisterValueAtInstruction()

RegisterValue LowLevelILFunction::GetRegisterValueAtInstruction	(	uint32_t	reg,
		size_t	instr )

◆ GetRegisterValueAfterInstruction()

RegisterValue LowLevelILFunction::GetRegisterValueAfterInstruction	(	uint32_t	reg,
		size_t	instr )

◆ GetPossibleRegisterValuesAtInstruction()

◆ GetPossibleRegisterValuesAfterInstruction()

◆ GetFlagValueAtInstruction()

RegisterValue LowLevelILFunction::GetFlagValueAtInstruction	(	uint32_t	flag,
		size_t	instr )

◆ GetFlagValueAfterInstruction()

RegisterValue LowLevelILFunction::GetFlagValueAfterInstruction	(	uint32_t	flag,
		size_t	instr )

◆ GetPossibleFlagValuesAtInstruction()

◆ GetPossibleFlagValuesAfterInstruction()

◆ GetStackContentsAtInstruction()

RegisterValue LowLevelILFunction::GetStackContentsAtInstruction	(	int32_t	offset,
		size_t	len,
		size_t	instr )

◆ GetStackContentsAfterInstruction()

RegisterValue LowLevelILFunction::GetStackContentsAfterInstruction	(	int32_t	offset,
		size_t	len,
		size_t	instr )

◆ GetPossibleStackContentsAtInstruction()

◆ GetPossibleStackContentsAfterInstruction()

◆ GetMediumLevelIL()

◆ GetMappedMediumLevelIL()

◆ GetMediumLevelILInstructionIndex()

size_t LowLevelILFunction::GetMediumLevelILInstructionIndex

(

size_t

instr

)

const

◆ GetMediumLevelILExprIndex()

size_t LowLevelILFunction::GetMediumLevelILExprIndex

(

size_t

expr

)

const

◆ GetMediumLevelILExprIndexes()

set< size_t > LowLevelILFunction::GetMediumLevelILExprIndexes

(

size_t

expr

)

const

◆ GetMappedMediumLevelILInstructionIndex()

size_t LowLevelILFunction::GetMappedMediumLevelILInstructionIndex

(

size_t

instr

)

const

◆ GetMappedMediumLevelILExprIndex()

size_t LowLevelILFunction::GetMappedMediumLevelILExprIndex

(

size_t

expr

)

const

◆ IsConstantType()

◆ CreateFunctionGraph()

◆ CreateFunctionGraphImmediate()

◆ BinaryNinja::RegisterOrFlag

struct BinaryNinja::RegisterOrFlag

Public Member Functions
	RegisterOrFlag ()
	RegisterOrFlag (bool flag, uint32_t i)
	RegisterOrFlag (const RegisterOrFlag &v)
bool	IsRegister () const
bool	IsFlag () const
uint32_t	GetRegister () const
uint32_t	GetFlag () const
RegisterOrFlag &	operator= (const RegisterOrFlag &v)
bool	operator== (const RegisterOrFlag &v) const
bool	operator!= (const RegisterOrFlag &v) const
bool	operator< (const RegisterOrFlag &v) const
uint64_t	ToIdentifier () const
Static Public Member Functions
static RegisterOrFlag	FromIdentifier (uint64_t id)
static RegisterOrFlag	Register (uint32_t reg)
static RegisterOrFlag	Flag (uint32_t flag)
Public Attributes
bool	isFlag
uint32_t	index

◆ RegisterOrFlag() [1/3]

RegisterOrFlag::RegisterOrFlag

(

)

◆ RegisterOrFlag() [2/3]

RegisterOrFlag::RegisterOrFlag	(	bool	flag,
		uint32_t	i )

◆ RegisterOrFlag() [3/3]

RegisterOrFlag::RegisterOrFlag

(

const RegisterOrFlag &

)

◆ IsRegister()

bool BinaryNinja::RegisterOrFlag::IsRegister

(

)

const

inline

◆ IsFlag()

bool BinaryNinja::RegisterOrFlag::IsFlag

(

)

const

inline

◆ GetRegister()

uint32_t RegisterOrFlag::GetRegister

(

)

const

◆ GetFlag()

uint32_t RegisterOrFlag::GetFlag

(

)

const

◆ operator=()

RegisterOrFlag & RegisterOrFlag::operator=

(

const RegisterOrFlag &

)

◆ operator==()

bool RegisterOrFlag::operator==

(

const RegisterOrFlag &

)

const

◆ operator!=()

bool RegisterOrFlag::operator!=

(

const RegisterOrFlag &

)

const

◆ operator<()

bool RegisterOrFlag::operator<

(

const RegisterOrFlag &

)

const

◆ ToIdentifier()

uint64_t RegisterOrFlag::ToIdentifier

(

)

const

◆ FromIdentifier()

RegisterOrFlag RegisterOrFlag::FromIdentifier

(

uint64_t

)

static

◆ Register()

RegisterOrFlag BinaryNinja::RegisterOrFlag::Register

(

uint32_t

reg

)

inlinestatic

◆ Flag()

RegisterOrFlag BinaryNinja::RegisterOrFlag::Flag

(

uint32_t

flag

)

inlinestatic

◆ isFlag

bool BinaryNinja::RegisterOrFlag::isFlag

◆ index

uint32_t BinaryNinja::RegisterOrFlag::index

◆ BinaryNinja::SSARegister

struct BinaryNinja::SSARegister

Public Member Functions
	SSARegister ()
	SSARegister (uint32_t r, size_t i)
	SSARegister (const SSARegister &v)
SSARegister &	operator= (const SSARegister &v)
bool	operator== (const SSARegister &v) const
bool	operator!= (const SSARegister &v) const
bool	operator< (const SSARegister &v) const
Public Attributes
uint32_t	reg
size_t	version

◆ SSARegister() [1/3]

SSARegister::SSARegister

(

)

◆ SSARegister() [2/3]

SSARegister::SSARegister	(	uint32_t	r,
		size_t	i )

◆ SSARegister() [3/3]

SSARegister::SSARegister

(

const SSARegister &

)

◆ operator=()

SSARegister & SSARegister::operator=

(

const SSARegister &

)

◆ operator==()

bool SSARegister::operator==

(

const SSARegister &

)

const

◆ operator!=()

bool SSARegister::operator!=

(

const SSARegister &

)

const

◆ operator<()

bool SSARegister::operator<

(

const SSARegister &

)

const

◆ reg

uint32_t BinaryNinja::SSARegister::reg

◆ version

size_t BinaryNinja::SSARegister::version

◆ BinaryNinja::SSARegisterStack

struct BinaryNinja::SSARegisterStack

Public Member Functions
	SSARegisterStack ()
	SSARegisterStack (uint32_t r, size_t i)
	SSARegisterStack (const SSARegisterStack &v)
SSARegisterStack &	operator= (const SSARegisterStack &v)
bool	operator== (const SSARegisterStack &v) const
bool	operator!= (const SSARegisterStack &v) const
bool	operator< (const SSARegisterStack &v) const
Public Attributes
uint32_t	regStack
size_t	version

◆ SSARegisterStack() [1/3]

SSARegisterStack::SSARegisterStack

(

)

◆ SSARegisterStack() [2/3]

SSARegisterStack::SSARegisterStack	(	uint32_t	r,
		size_t	i )

◆ SSARegisterStack() [3/3]

SSARegisterStack::SSARegisterStack

(

const SSARegisterStack &

)

◆ operator=()

SSARegisterStack & SSARegisterStack::operator=

(

const SSARegisterStack &

)

◆ operator==()

bool SSARegisterStack::operator==

(

const SSARegisterStack &

)

const

◆ operator!=()

bool SSARegisterStack::operator!=

(

const SSARegisterStack &

)

const

◆ operator<()

bool SSARegisterStack::operator<

(

const SSARegisterStack &

)

const

◆ regStack

uint32_t BinaryNinja::SSARegisterStack::regStack

◆ version

size_t BinaryNinja::SSARegisterStack::version

◆ BinaryNinja::SSAFlag

struct BinaryNinja::SSAFlag

Public Member Functions
	SSAFlag ()
	SSAFlag (uint32_t f, size_t i)
	SSAFlag (const SSAFlag &v)
SSAFlag &	operator= (const SSAFlag &v)
bool	operator== (const SSAFlag &v) const
bool	operator!= (const SSAFlag &v) const
bool	operator< (const SSAFlag &v) const
Public Attributes
uint32_t	flag
size_t	version

◆ SSAFlag() [1/3]

◆ SSAFlag() [2/3]

SSAFlag::SSAFlag	(	uint32_t	f,
		size_t	i )

◆ SSAFlag() [3/3]

SSAFlag::SSAFlag

(

const SSAFlag &

)

◆ operator=()

SSAFlag & SSAFlag::operator=

(

const SSAFlag &

)

◆ operator==()

bool SSAFlag::operator==

(

const SSAFlag &

)

const

◆ operator!=()

bool SSAFlag::operator!=

(

const SSAFlag &

)

const

◆ operator<()

bool SSAFlag::operator<

(

const SSAFlag &

)

const

◆ flag

uint32_t BinaryNinja::SSAFlag::flag

◆ version

size_t BinaryNinja::SSAFlag::version

◆ BinaryNinja::SSARegisterOrFlag

struct BinaryNinja::SSARegisterOrFlag

Public Member Functions
	SSARegisterOrFlag ()
	SSARegisterOrFlag (const RegisterOrFlag &rf, size_t i)
	SSARegisterOrFlag (const SSARegister &v)
	SSARegisterOrFlag (const SSAFlag &v)
	SSARegisterOrFlag (const SSARegisterOrFlag &v)
SSARegisterOrFlag &	operator= (const SSARegisterOrFlag &v)
bool	operator== (const SSARegisterOrFlag &v) const
bool	operator!= (const SSARegisterOrFlag &v) const
bool	operator< (const SSARegisterOrFlag &v) const
Public Attributes
RegisterOrFlag	regOrFlag
size_t	version

◆ SSARegisterOrFlag() [1/5]

SSARegisterOrFlag::SSARegisterOrFlag

(

)

◆ SSARegisterOrFlag() [2/5]

SSARegisterOrFlag::SSARegisterOrFlag	(	const RegisterOrFlag &	rf,
		size_t	i )

◆ SSARegisterOrFlag() [3/5]

SSARegisterOrFlag::SSARegisterOrFlag

(

const SSARegister &

)

◆ SSARegisterOrFlag() [4/5]

SSARegisterOrFlag::SSARegisterOrFlag

(

const SSAFlag &

)

◆ SSARegisterOrFlag() [5/5]

SSARegisterOrFlag::SSARegisterOrFlag

(

const SSARegisterOrFlag &

)

◆ operator=()

SSARegisterOrFlag & SSARegisterOrFlag::operator=

(

const SSARegisterOrFlag &

)

◆ operator==()

bool SSARegisterOrFlag::operator==

(

const SSARegisterOrFlag &

)

const

◆ operator!=()

bool SSARegisterOrFlag::operator!=

(

const SSARegisterOrFlag &

)

const

◆ operator<()

bool SSARegisterOrFlag::operator<

(

const SSARegisterOrFlag &

)

const

◆ regOrFlag

RegisterOrFlag BinaryNinja::SSARegisterOrFlag::regOrFlag

◆ version

size_t BinaryNinja::SSARegisterOrFlag::version

◆ BinaryNinja::LowLevelILInstructionAccessException

class BinaryNinja::LowLevelILInstructionAccessException

◆ BinaryNinja::LowLevelILIntegerList

class BinaryNinja::LowLevelILIntegerList

Public Types
typedef ListIterator	const_iterator
Public Member Functions
	LowLevelILIntegerList (LowLevelILFunction *func, const BNLowLevelILInstruction &instr, size_t count)
const_iterator	begin () const
const_iterator	end () const
size_t	size () const
uint64_t	operator[] (size_t i) const
	operator std::vector< uint64_t > () const

◆ const_iterator

◆ LowLevelILIntegerList()

◆ begin()

LowLevelILIntegerList::const_iterator LowLevelILIntegerList::begin

(

)

const

◆ end()

LowLevelILIntegerList::const_iterator LowLevelILIntegerList::end

(

)

const

◆ size()

size_t LowLevelILIntegerList::size

(

)

const

◆ operator[]()

uint64_t LowLevelILIntegerList::operator[]

(

size_t

)

const

◆ operator std::vector< uint64_t >()

BinaryNinja::LowLevelILIntegerList::operator std::vector< uint64_t >

(

)

const

◆ BinaryNinja::LowLevelILIndexList

class BinaryNinja::LowLevelILIndexList

Public Types
typedef ListIterator	const_iterator
Public Member Functions
	LowLevelILIndexList (LowLevelILFunction *func, const BNLowLevelILInstruction &instr, size_t count)
const_iterator	begin () const
const_iterator	end () const
size_t	size () const
size_t	operator[] (size_t i) const
	operator std::vector< size_t > () const

◆ const_iterator

◆ LowLevelILIndexList()

◆ begin()

LowLevelILIndexList::const_iterator LowLevelILIndexList::begin

(

)

const

◆ end()

LowLevelILIndexList::const_iterator LowLevelILIndexList::end

(

)

const

◆ size()

size_t LowLevelILIndexList::size

(

)

const

◆ operator[]()

size_t LowLevelILIndexList::operator[]

(

size_t

)

const

◆ operator std::vector< size_t >()

BinaryNinja::LowLevelILIndexList::operator std::vector< size_t >

(

)

const

◆ BinaryNinja::LowLevelILIndexMap

class BinaryNinja::LowLevelILIndexMap

Public Types
typedef ListIterator	const_iterator
Public Member Functions
	LowLevelILIndexMap (LowLevelILFunction *func, const BNLowLevelILInstruction &instr, size_t count)
const_iterator	begin () const
const_iterator	end () const
size_t	size () const
size_t	operator[] (uint64_t value) const
	operator std::map< uint64_t, size_t > () const

◆ const_iterator

◆ LowLevelILIndexMap()

◆ begin()

LowLevelILIndexMap::const_iterator LowLevelILIndexMap::begin

(

)

const

◆ end()

LowLevelILIndexMap::const_iterator LowLevelILIndexMap::end

(

)

const

◆ size()

size_t LowLevelILIndexMap::size

(

)

const

◆ operator[]()

size_t LowLevelILIndexMap::operator[]

(

uint64_t

value

)

const

◆ operator std::map< uint64_t, size_t >()

BinaryNinja::LowLevelILIndexMap::operator std::map< uint64_t, size_t >

(

)

const

◆ BinaryNinja::LowLevelILInstructionList

class BinaryNinja::LowLevelILInstructionList

Public Types
typedef ListIterator	const_iterator
Public Member Functions
	LowLevelILInstructionList (LowLevelILFunction *func, const BNLowLevelILInstruction &instr, size_t count, size_t instrIndex)
const_iterator	begin () const
const_iterator	end () const
size_t	size () const
const LowLevelILInstruction	operator[] (size_t i) const
	operator std::vector< LowLevelILInstruction > () const

◆ const_iterator

◆ LowLevelILInstructionList()

LowLevelILInstructionList::LowLevelILInstructionList	(	LowLevelILFunction *	func,
		const BNLowLevelILInstruction &	instr,
		size_t	count,
		size_t	instrIndex )

◆ begin()

LowLevelILInstructionList::const_iterator LowLevelILInstructionList::begin

(

)

const

◆ end()

LowLevelILInstructionList::const_iterator LowLevelILInstructionList::end

(

)

const

◆ size()

size_t LowLevelILInstructionList::size

(

)

const

◆ operator[]()

const LowLevelILInstruction LowLevelILInstructionList::operator[]

(

size_t

)

const

◆ operator std::vector< LowLevelILInstruction >()

BinaryNinja::LowLevelILInstructionList::operator std::vector< LowLevelILInstruction >

(

)

const

◆ BinaryNinja::LowLevelILRegisterOrFlagList

class BinaryNinja::LowLevelILRegisterOrFlagList

Public Types
typedef ListIterator	const_iterator
Public Member Functions
	LowLevelILRegisterOrFlagList (LowLevelILFunction *func, const BNLowLevelILInstruction &instr, size_t count)
const_iterator	begin () const
const_iterator	end () const
size_t	size () const
const RegisterOrFlag	operator[] (size_t i) const
	operator std::vector< RegisterOrFlag > () const

◆ const_iterator

◆ LowLevelILRegisterOrFlagList()

◆ begin()

LowLevelILRegisterOrFlagList::const_iterator LowLevelILRegisterOrFlagList::begin

(

)

const

◆ end()

LowLevelILRegisterOrFlagList::const_iterator LowLevelILRegisterOrFlagList::end

(

)

const

◆ size()

size_t LowLevelILRegisterOrFlagList::size

(

)

const

◆ operator[]()

const RegisterOrFlag LowLevelILRegisterOrFlagList::operator[]

(

size_t

)

const

◆ operator std::vector< RegisterOrFlag >()

BinaryNinja::LowLevelILRegisterOrFlagList::operator std::vector< RegisterOrFlag >

(

)

const

◆ BinaryNinja::LowLevelILSSARegisterList

class BinaryNinja::LowLevelILSSARegisterList

Public Types
typedef ListIterator	const_iterator
Public Member Functions
	LowLevelILSSARegisterList (LowLevelILFunction *func, const BNLowLevelILInstruction &instr, size_t count)
const_iterator	begin () const
const_iterator	end () const
size_t	size () const
const SSARegister	operator[] (size_t i) const
	operator std::vector< SSARegister > () const

◆ const_iterator

◆ LowLevelILSSARegisterList()

◆ begin()

LowLevelILSSARegisterList::const_iterator LowLevelILSSARegisterList::begin

(

)

const

◆ end()

LowLevelILSSARegisterList::const_iterator LowLevelILSSARegisterList::end

(

)

const

◆ size()

size_t LowLevelILSSARegisterList::size

(

)

const

◆ operator[]()

const SSARegister LowLevelILSSARegisterList::operator[]

(

size_t

)

const

◆ operator std::vector< SSARegister >()

BinaryNinja::LowLevelILSSARegisterList::operator std::vector< SSARegister >

(

)

const

◆ BinaryNinja::LowLevelILSSARegisterStackList

class BinaryNinja::LowLevelILSSARegisterStackList

Public Types
typedef ListIterator	const_iterator
Public Member Functions
	LowLevelILSSARegisterStackList (LowLevelILFunction *func, const BNLowLevelILInstruction &instr, size_t count)
const_iterator	begin () const
const_iterator	end () const
size_t	size () const
const SSARegisterStack	operator[] (size_t i) const
	operator std::vector< SSARegisterStack > () const

◆ const_iterator

◆ LowLevelILSSARegisterStackList()

LowLevelILSSARegisterStackList::LowLevelILSSARegisterStackList	(	LowLevelILFunction *	func,
		const BNLowLevelILInstruction &	instr,
		size_t	count )

◆ begin()

LowLevelILSSARegisterStackList::const_iterator LowLevelILSSARegisterStackList::begin

(

)

const

◆ end()

LowLevelILSSARegisterStackList::const_iterator LowLevelILSSARegisterStackList::end

(

)

const

◆ size()

size_t LowLevelILSSARegisterStackList::size

(

)

const

◆ operator[]()

const SSARegisterStack LowLevelILSSARegisterStackList::operator[]

(

size_t

)

const

◆ operator std::vector< SSARegisterStack >()

BinaryNinja::LowLevelILSSARegisterStackList::operator std::vector< SSARegisterStack >

(

)

const

◆ BinaryNinja::LowLevelILSSAFlagList

class BinaryNinja::LowLevelILSSAFlagList

Public Types
typedef ListIterator	const_iterator
Public Member Functions
	LowLevelILSSAFlagList (LowLevelILFunction *func, const BNLowLevelILInstruction &instr, size_t count)
const_iterator	begin () const
const_iterator	end () const
size_t	size () const
const SSAFlag	operator[] (size_t i) const
	operator std::vector< SSAFlag > () const

◆ const_iterator

◆ LowLevelILSSAFlagList()

◆ begin()

LowLevelILSSAFlagList::const_iterator LowLevelILSSAFlagList::begin

(

)

const

◆ end()

LowLevelILSSAFlagList::const_iterator LowLevelILSSAFlagList::end

(

)

const

◆ size()

size_t LowLevelILSSAFlagList::size

(

)

const

◆ operator[]()

const SSAFlag LowLevelILSSAFlagList::operator[]

(

size_t

)

const

◆ operator std::vector< SSAFlag >()

BinaryNinja::LowLevelILSSAFlagList::operator std::vector< SSAFlag >

(

)

const

◆ BinaryNinja::LowLevelILSSARegisterOrFlagList

class BinaryNinja::LowLevelILSSARegisterOrFlagList

Public Types
typedef ListIterator	const_iterator
Public Member Functions
	LowLevelILSSARegisterOrFlagList (LowLevelILFunction *func, const BNLowLevelILInstruction &instr, size_t count)
const_iterator	begin () const
const_iterator	end () const
size_t	size () const
const SSARegisterOrFlag	operator[] (size_t i) const
	operator std::vector< SSARegisterOrFlag > () const

◆ const_iterator

◆ LowLevelILSSARegisterOrFlagList()

LowLevelILSSARegisterOrFlagList::LowLevelILSSARegisterOrFlagList	(	LowLevelILFunction *	func,
		const BNLowLevelILInstruction &	instr,
		size_t	count )

◆ begin()

LowLevelILSSARegisterOrFlagList::const_iterator LowLevelILSSARegisterOrFlagList::begin

(

)

const

◆ end()

LowLevelILSSARegisterOrFlagList::const_iterator LowLevelILSSARegisterOrFlagList::end

(

)

const

◆ size()

size_t LowLevelILSSARegisterOrFlagList::size

(

)

const

◆ operator[]()

const SSARegisterOrFlag LowLevelILSSARegisterOrFlagList::operator[]

(

size_t

)

const

◆ operator std::vector< SSARegisterOrFlag >()

BinaryNinja::LowLevelILSSARegisterOrFlagList::operator std::vector< SSARegisterOrFlag >

(

)

const

◆ BinaryNinja::LowLevelILInstructionBase

struct BinaryNinja::LowLevelILInstructionBase

Public Member Functions
LowLevelILOperandList	GetOperands () const
uint64_t	GetRawOperandAsInteger (size_t operand) const
uint32_t	GetRawOperandAsRegister (size_t operand) const
size_t	GetRawOperandAsIndex (size_t operand) const
BNLowLevelILFlagCondition	GetRawOperandAsFlagCondition (size_t operand) const
LowLevelILInstruction	GetRawOperandAsExpr (size_t operand) const
SSARegister	GetRawOperandAsSSARegister (size_t operand) const
SSARegisterStack	GetRawOperandAsSSARegisterStack (size_t operand) const
SSARegisterStack	GetRawOperandAsPartialSSARegisterStackSource (size_t operand) const
SSAFlag	GetRawOperandAsSSAFlag (size_t operand) const
LowLevelILIndexList	GetRawOperandAsIndexList (size_t operand) const
LowLevelILIndexMap	GetRawOperandAsIndexMap (size_t operand) const
LowLevelILInstructionList	GetRawOperandAsExprList (size_t operand) const
LowLevelILRegisterOrFlagList	GetRawOperandAsRegisterOrFlagList (size_t operand) const
LowLevelILSSARegisterList	GetRawOperandAsSSARegisterList (size_t operand) const
LowLevelILSSARegisterStackList	GetRawOperandAsSSARegisterStackList (size_t operand) const
LowLevelILSSAFlagList	GetRawOperandAsSSAFlagList (size_t operand) const
LowLevelILSSARegisterOrFlagList	GetRawOperandAsSSARegisterOrFlagList (size_t operand) const
std::map< uint32_t, int32_t >	GetRawOperandAsRegisterStackAdjustments (size_t operand) const
PossibleValueSet	GetRawOperandAsPossibleValueSet (size_t operand) const
void	UpdateRawOperand (size_t operandIndex, ExprId value)
void	UpdateRawOperandAsSSARegisterList (size_t operandIndex, const std::vector< SSARegister > &regs)
void	UpdateRawOperandAsSSARegisterOrFlagList (size_t operandIndex, const std::vector< SSARegisterOrFlag > &outputs)
RegisterValue	GetValue () const
PossibleValueSet	GetPossibleValues (const std::set< BNDataFlowQueryOption > &options=std::set< BNDataFlowQueryOption >()) const
RegisterValue	GetRegisterValue (uint32_t reg)
RegisterValue	GetRegisterValueAfter (uint32_t reg)
PossibleValueSet	GetPossibleRegisterValues (uint32_t reg)
PossibleValueSet	GetPossibleRegisterValuesAfter (uint32_t reg)
RegisterValue	GetFlagValue (uint32_t flag)
RegisterValue	GetFlagValueAfter (uint32_t flag)
PossibleValueSet	GetPossibleFlagValues (uint32_t flag)
PossibleValueSet	GetPossibleFlagValuesAfter (uint32_t flag)
RegisterValue	GetStackContents (int32_t offset, size_t len)
RegisterValue	GetStackContentsAfter (int32_t offset, size_t len)
PossibleValueSet	GetPossibleStackContents (int32_t offset, size_t len)
PossibleValueSet	GetPossibleStackContentsAfter (int32_t offset, size_t len)
size_t	GetSSAInstructionIndex () const
size_t	GetNonSSAInstructionIndex () const
size_t	GetSSAExprIndex () const
size_t	GetNonSSAExprIndex () const
LowLevelILInstruction	GetSSAForm () const
LowLevelILInstruction	GetNonSSAForm () const
size_t	GetMediumLevelILInstructionIndex () const
size_t	GetMediumLevelILExprIndex () const
size_t	GetMappedMediumLevelILInstructionIndex () const
size_t	GetMappedMediumLevelILExprIndex () const
bool	HasMediumLevelIL () const
bool	HasMappedMediumLevelIL () const
MediumLevelILInstruction	GetMediumLevelIL () const
MediumLevelILInstruction	GetMappedMediumLevelIL () const
char *	Dump () const
void	Replace (ExprId expr)
void	SetAttributes (uint32_t attributes)
void	SetAttribute (BNILInstructionAttribute attribute, bool state=true)
void	ClearAttribute (BNILInstructionAttribute attribute)
template<BNLowLevelILOperation N>
LowLevelILInstructionAccessor< N > &	As ()
LowLevelILOneOperandInstruction &	AsOneOperand ()
LowLevelILTwoOperandInstruction &	AsTwoOperand ()
LowLevelILTwoOperandWithCarryInstruction &	AsTwoOperandWithCarry ()
template<BNLowLevelILOperation N>
const LowLevelILInstructionAccessor< N > &	As () const
const LowLevelILConstantInstruction &	AsConstant () const
const LowLevelILOneOperandInstruction &	AsOneOperand () const
const LowLevelILTwoOperandInstruction &	AsTwoOperand () const
const LowLevelILTwoOperandWithCarryInstruction &	AsTwoOperandWithCarry () const
Public Attributes
Ref< LowLevelILFunction >	function
size_t	exprIndex
size_t	instructionIndex
Public Attributes inherited from BNLowLevelILInstruction
BNLowLevelILOperation	operation
uint32_t	attributes
size_t	size
uint32_t	flags
uint32_t	sourceOperand
uint64_t	operands [4]
uint64_t	address
Static Public Attributes
static std::unordered_map< LowLevelILOperandUsage, LowLevelILOperandType >	operandTypeForUsage
static std::unordered_map< BNLowLevelILOperation, std::vector< LowLevelILOperandUsage > >	operationOperandUsage
static std::unordered_map< BNLowLevelILOperation, std::unordered_map< LowLevelILOperandUsage, size_t > >	operationOperandIndex = GetOperandIndexForOperandUsages()

◆ GetOperands()

LowLevelILOperandList LowLevelILInstructionBase::GetOperands

(

)

const

◆ GetRawOperandAsInteger()

uint64_t LowLevelILInstructionBase::GetRawOperandAsInteger

(

size_t

operand

)

const

◆ GetRawOperandAsRegister()

uint32_t LowLevelILInstructionBase::GetRawOperandAsRegister

(

size_t

operand

)

const

◆ GetRawOperandAsIndex()

size_t LowLevelILInstructionBase::GetRawOperandAsIndex

(

size_t

operand

)

const

◆ GetRawOperandAsFlagCondition()

◆ GetRawOperandAsExpr()

LowLevelILInstruction LowLevelILInstructionBase::GetRawOperandAsExpr

(

size_t

operand

)

const

◆ GetRawOperandAsSSARegister()

SSARegister LowLevelILInstructionBase::GetRawOperandAsSSARegister

(

size_t

operand

)

const

◆ GetRawOperandAsSSARegisterStack()

SSARegisterStack LowLevelILInstructionBase::GetRawOperandAsSSARegisterStack

(

size_t

operand

)

const

◆ GetRawOperandAsPartialSSARegisterStackSource()

SSARegisterStack LowLevelILInstructionBase::GetRawOperandAsPartialSSARegisterStackSource

(

size_t

operand

)

const

◆ GetRawOperandAsSSAFlag()

SSAFlag LowLevelILInstructionBase::GetRawOperandAsSSAFlag

(

size_t

operand

)

const

◆ GetRawOperandAsIndexList()

LowLevelILIndexList LowLevelILInstructionBase::GetRawOperandAsIndexList

(

size_t

operand

)

const

◆ GetRawOperandAsIndexMap()

LowLevelILIndexMap LowLevelILInstructionBase::GetRawOperandAsIndexMap

(

size_t

operand

)

const

◆ GetRawOperandAsExprList()

LowLevelILInstructionList LowLevelILInstructionBase::GetRawOperandAsExprList

(

size_t

operand

)

const

◆ GetRawOperandAsRegisterOrFlagList()

LowLevelILRegisterOrFlagList LowLevelILInstructionBase::GetRawOperandAsRegisterOrFlagList

(

size_t

operand

)

const

◆ GetRawOperandAsSSARegisterList()

LowLevelILSSARegisterList LowLevelILInstructionBase::GetRawOperandAsSSARegisterList

(

size_t

operand

)

const

◆ GetRawOperandAsSSARegisterStackList()

LowLevelILSSARegisterStackList LowLevelILInstructionBase::GetRawOperandAsSSARegisterStackList

(

size_t

operand

)

const

◆ GetRawOperandAsSSAFlagList()

LowLevelILSSAFlagList LowLevelILInstructionBase::GetRawOperandAsSSAFlagList

(

size_t

operand

)

const

◆ GetRawOperandAsSSARegisterOrFlagList()

LowLevelILSSARegisterOrFlagList LowLevelILInstructionBase::GetRawOperandAsSSARegisterOrFlagList

(

size_t

operand

)

const

◆ GetRawOperandAsRegisterStackAdjustments()

map< uint32_t, int32_t > LowLevelILInstructionBase::GetRawOperandAsRegisterStackAdjustments

(

size_t

operand

)

const

◆ GetRawOperandAsPossibleValueSet()

PossibleValueSet LowLevelILInstructionBase::GetRawOperandAsPossibleValueSet

(

size_t

operand

)

const

◆ UpdateRawOperand()

void LowLevelILInstructionBase::UpdateRawOperand	(	size_t	operandIndex,
		ExprId	value )

◆ UpdateRawOperandAsSSARegisterList()

void LowLevelILInstructionBase::UpdateRawOperandAsSSARegisterList	(	size_t	operandIndex,
		const std::vector< SSARegister > &	regs )

◆ UpdateRawOperandAsSSARegisterOrFlagList()

void LowLevelILInstructionBase::UpdateRawOperandAsSSARegisterOrFlagList	(	size_t	operandIndex,
		const std::vector< SSARegisterOrFlag > &	outputs )

◆ GetValue()

◆ GetPossibleValues()

◆ GetRegisterValue()

RegisterValue LowLevelILInstructionBase::GetRegisterValue

(

uint32_t

reg

)

◆ GetRegisterValueAfter()

RegisterValue LowLevelILInstructionBase::GetRegisterValueAfter

(

uint32_t

reg

)

◆ GetPossibleRegisterValues()

PossibleValueSet LowLevelILInstructionBase::GetPossibleRegisterValues

(

uint32_t

reg

)

◆ GetPossibleRegisterValuesAfter()

PossibleValueSet LowLevelILInstructionBase::GetPossibleRegisterValuesAfter

(

uint32_t

reg

)

◆ GetFlagValue()

RegisterValue LowLevelILInstructionBase::GetFlagValue

(

uint32_t

flag

)

◆ GetFlagValueAfter()

RegisterValue LowLevelILInstructionBase::GetFlagValueAfter

(

uint32_t

flag

)

◆ GetPossibleFlagValues()

PossibleValueSet LowLevelILInstructionBase::GetPossibleFlagValues

(

uint32_t

flag

)

◆ GetPossibleFlagValuesAfter()

PossibleValueSet LowLevelILInstructionBase::GetPossibleFlagValuesAfter

(

uint32_t

flag

)

◆ GetStackContents()

RegisterValue LowLevelILInstructionBase::GetStackContents	(	int32_t	offset,
		size_t	len )

◆ GetStackContentsAfter()

RegisterValue LowLevelILInstructionBase::GetStackContentsAfter	(	int32_t	offset,
		size_t	len )

◆ GetPossibleStackContents()

PossibleValueSet LowLevelILInstructionBase::GetPossibleStackContents	(	int32_t	offset,
		size_t	len )

◆ GetPossibleStackContentsAfter()

PossibleValueSet LowLevelILInstructionBase::GetPossibleStackContentsAfter	(	int32_t	offset,
		size_t	len )

◆ GetSSAInstructionIndex()

size_t LowLevelILInstructionBase::GetSSAInstructionIndex

(

)

const

◆ GetNonSSAInstructionIndex()

size_t LowLevelILInstructionBase::GetNonSSAInstructionIndex

(

)

const

◆ GetSSAExprIndex()

size_t LowLevelILInstructionBase::GetSSAExprIndex

(

)

const

◆ GetNonSSAExprIndex()

size_t LowLevelILInstructionBase::GetNonSSAExprIndex

(

)

const

◆ GetSSAForm()

LowLevelILInstruction LowLevelILInstructionBase::GetSSAForm

(

)

const

◆ GetNonSSAForm()

LowLevelILInstruction LowLevelILInstructionBase::GetNonSSAForm

(

)

const

◆ GetMediumLevelILInstructionIndex()

size_t LowLevelILInstructionBase::GetMediumLevelILInstructionIndex

(

)

const

◆ GetMediumLevelILExprIndex()

size_t LowLevelILInstructionBase::GetMediumLevelILExprIndex

(

)

const

◆ GetMappedMediumLevelILInstructionIndex()

size_t LowLevelILInstructionBase::GetMappedMediumLevelILInstructionIndex

(

)

const

◆ GetMappedMediumLevelILExprIndex()

size_t LowLevelILInstructionBase::GetMappedMediumLevelILExprIndex

(

)

const

◆ HasMediumLevelIL()

bool LowLevelILInstructionBase::HasMediumLevelIL

(

)

const

◆ HasMappedMediumLevelIL()

bool LowLevelILInstructionBase::HasMappedMediumLevelIL

(

)

const

◆ GetMediumLevelIL()

◆ GetMappedMediumLevelIL()

◆ Dump()

char * LowLevelILInstructionBase::Dump

(

)

const

◆ Replace()

void LowLevelILInstructionBase::Replace

(

ExprId

expr

)

◆ SetAttributes()

void LowLevelILInstructionBase::SetAttributes

(

uint32_t

attributes

)

◆ SetAttribute()

◆ ClearAttribute()

◆ As() [1/2]

LowLevelILInstructionAccessor< N > & BinaryNinja::LowLevelILInstructionBase::As

(

)

inline

◆ AsOneOperand() [1/2]

◆ AsTwoOperand() [1/2]

◆ AsTwoOperandWithCarry() [1/2]

◆ As() [2/2]

const LowLevelILInstructionAccessor< N > & BinaryNinja::LowLevelILInstructionBase::As

(

)

const

inline

◆ AsConstant()

◆ AsOneOperand() [2/2]

◆ AsTwoOperand() [2/2]

◆ AsTwoOperandWithCarry() [2/2]

◆ function

Ref<LowLevelILFunction> BinaryNinja::LowLevelILInstructionBase::function

◆ exprIndex

size_t BinaryNinja::LowLevelILInstructionBase::exprIndex

◆ instructionIndex

size_t BinaryNinja::LowLevelILInstructionBase::instructionIndex

◆ operandTypeForUsage

unordered_map< LowLevelILOperandUsage, LowLevelILOperandType > LowLevelILInstructionBase::operandTypeForUsage

static

◆ operationOperandUsage

◆ operationOperandIndex

unordered_map< BNLowLevelILOperation, unordered_map< LowLevelILOperandUsage, size_t > > LowLevelILInstructionBase::operationOperandIndex = GetOperandIndexForOperandUsages()

static

◆ BinaryNinja::LowLevelILInstruction

struct BinaryNinja::LowLevelILInstruction

Public Member Functions
	LowLevelILInstruction ()
	LowLevelILInstruction (LowLevelILFunction *func, const BNLowLevelILInstruction &instr, size_t expr, size_t instrIdx)
	LowLevelILInstruction (const LowLevelILInstructionBase &instr)
void	VisitExprs (const std::function< bool(const LowLevelILInstruction &expr)> &func) const
ExprId	CopyTo (LowLevelILFunction *dest) const
ExprId	CopyTo (LowLevelILFunction *dest, const std::function< ExprId(const LowLevelILInstruction &subExpr)> &subExprHandler) const
template<BNLowLevelILOperation N>
LowLevelILInstruction	GetSourceExpr () const
template<BNLowLevelILOperation N>
uint32_t	GetSourceRegister () const
template<BNLowLevelILOperation N>
uint32_t	GetSourceRegisterStack () const
template<BNLowLevelILOperation N>
uint32_t	GetSourceFlag () const
template<BNLowLevelILOperation N>
SSARegister	GetSourceSSARegister () const
template<BNLowLevelILOperation N>
SSARegisterStack	GetSourceSSARegisterStack () const
template<BNLowLevelILOperation N>
SSAFlag	GetSourceSSAFlag () const
template<BNLowLevelILOperation N>
LowLevelILInstruction	GetDestExpr () const
template<BNLowLevelILOperation N>
uint32_t	GetDestRegister () const
template<BNLowLevelILOperation N>
uint32_t	GetDestRegisterStack () const
template<BNLowLevelILOperation N>
uint32_t	GetDestFlag () const
template<BNLowLevelILOperation N>
SSARegister	GetDestSSARegister () const
template<BNLowLevelILOperation N>
SSARegisterStack	GetDestSSARegisterStack () const
template<BNLowLevelILOperation N>
SSAFlag	GetDestSSAFlag () const
template<BNLowLevelILOperation N>
uint32_t	GetSemanticFlagClass () const
template<BNLowLevelILOperation N>
uint32_t	GetSemanticFlagGroup () const
template<BNLowLevelILOperation N>
uint32_t	GetPartialRegister () const
template<BNLowLevelILOperation N>
SSARegister	GetStackSSARegister () const
template<BNLowLevelILOperation N>
SSARegister	GetTopSSARegister () const
template<BNLowLevelILOperation N>
LowLevelILInstruction	GetLeftExpr () const
template<BNLowLevelILOperation N>
LowLevelILInstruction	GetRightExpr () const
template<BNLowLevelILOperation N>
LowLevelILInstruction	GetCarryExpr () const
template<BNLowLevelILOperation N>
LowLevelILInstruction	GetConditionExpr () const
template<BNLowLevelILOperation N>
uint32_t	GetHighRegister () const
template<BNLowLevelILOperation N>
SSARegister	GetHighSSARegister () const
template<BNLowLevelILOperation N>
uint32_t	GetLowRegister () const
template<BNLowLevelILOperation N>
SSARegister	GetLowSSARegister () const
template<BNLowLevelILOperation N>
uint32_t	GetIntrinsic () const
template<BNLowLevelILOperation N>
int64_t	GetConstant () const
template<BNLowLevelILOperation N>
uint64_t	GetOffset () const
template<BNLowLevelILOperation N>
int64_t	GetVector () const
template<BNLowLevelILOperation N>
int64_t	GetStackAdjustment () const
template<BNLowLevelILOperation N>
size_t	GetTarget () const
template<BNLowLevelILOperation N>
size_t	GetTrueTarget () const
template<BNLowLevelILOperation N>
size_t	GetFalseTarget () const
template<BNLowLevelILOperation N>
size_t	GetBitIndex () const
template<BNLowLevelILOperation N>
size_t	GetSourceMemoryVersion () const
template<BNLowLevelILOperation N>
size_t	GetDestMemoryVersion () const
template<BNLowLevelILOperation N>
BNLowLevelILFlagCondition	GetFlagCondition () const
template<BNLowLevelILOperation N>
LowLevelILSSARegisterList	GetOutputSSARegisters () const
template<BNLowLevelILOperation N>
LowLevelILInstructionList	GetParameterExprs () const
template<BNLowLevelILOperation N>
LowLevelILSSARegisterList	GetSourceSSARegisters () const
template<BNLowLevelILOperation N>
LowLevelILSSARegisterStackList	GetSourceSSARegisterStacks () const
template<BNLowLevelILOperation N>
LowLevelILSSAFlagList	GetSourceSSAFlags () const
template<BNLowLevelILOperation N>
LowLevelILRegisterOrFlagList	GetOutputRegisterOrFlagList () const
template<BNLowLevelILOperation N>
LowLevelILSSARegisterOrFlagList	GetOutputSSARegisterOrFlagList () const
template<BNLowLevelILOperation N>
LowLevelILIndexList	GetSourceMemoryVersions () const
template<BNLowLevelILOperation N>
LowLevelILIndexMap	GetTargets () const
template<BNLowLevelILOperation N>
std::map< uint32_t, int32_t >	GetRegisterStackAdjustments () const
template<BNLowLevelILOperation N>
void	SetDestSSAVersion (size_t version)
template<BNLowLevelILOperation N>
void	SetSourceSSAVersion (size_t version)
template<BNLowLevelILOperation N>
void	SetHighSSAVersion (size_t version)
template<BNLowLevelILOperation N>
void	SetLowSSAVersion (size_t version)
template<BNLowLevelILOperation N>
void	SetStackSSAVersion (size_t version)
template<BNLowLevelILOperation N>
void	SetTopSSAVersion (size_t version)
template<BNLowLevelILOperation N>
void	SetDestMemoryVersion (size_t version)
template<BNLowLevelILOperation N>
void	SetSourceMemoryVersion (size_t version)
template<BNLowLevelILOperation N>
void	SetOutputSSARegisters (const std::vector< SSARegister > &regs)
template<BNLowLevelILOperation N>
void	SetOutputSSARegisterOrFlagList (const std::vector< SSARegisterOrFlag > &outputs)
template<BNLowLevelILOperation N>
PossibleValueSet	GetConstraint () const
bool	GetOperandIndexForUsage (LowLevelILOperandUsage usage, size_t &operandIndex) const
LowLevelILInstruction	GetSourceExpr () const
uint32_t	GetSourceRegister () const
uint32_t	GetSourceRegisterStack () const
uint32_t	GetSourceFlag () const
SSARegister	GetSourceSSARegister () const
SSARegisterStack	GetSourceSSARegisterStack () const
SSAFlag	GetSourceSSAFlag () const
LowLevelILInstruction	GetDestExpr () const
uint32_t	GetDestRegister () const
uint32_t	GetDestRegisterStack () const
uint32_t	GetDestFlag () const
SSARegister	GetDestSSARegister () const
SSARegisterStack	GetDestSSARegisterStack () const
SSAFlag	GetDestSSAFlag () const
uint32_t	GetSemanticFlagClass () const
uint32_t	GetSemanticFlagGroup () const
uint32_t	GetPartialRegister () const
SSARegister	GetStackSSARegister () const
SSARegister	GetTopSSARegister () const
LowLevelILInstruction	GetLeftExpr () const
LowLevelILInstruction	GetRightExpr () const
LowLevelILInstruction	GetCarryExpr () const
LowLevelILInstruction	GetConditionExpr () const
uint32_t	GetHighRegister () const
SSARegister	GetHighSSARegister () const
uint32_t	GetLowRegister () const
SSARegister	GetLowSSARegister () const
uint32_t	GetIntrinsic () const
int64_t	GetConstant () const
uint64_t	GetOffset () const
int64_t	GetVector () const
int64_t	GetStackAdjustment () const
size_t	GetTarget () const
size_t	GetTrueTarget () const
size_t	GetFalseTarget () const
size_t	GetBitIndex () const
size_t	GetSourceMemoryVersion () const
size_t	GetDestMemoryVersion () const
BNLowLevelILFlagCondition	GetFlagCondition () const
LowLevelILSSARegisterList	GetOutputSSARegisters () const
LowLevelILInstructionList	GetParameterExprs () const
LowLevelILSSARegisterList	GetSourceSSARegisters () const
LowLevelILSSARegisterStackList	GetSourceSSARegisterStacks () const
LowLevelILSSAFlagList	GetSourceSSAFlags () const
LowLevelILRegisterOrFlagList	GetOutputRegisterOrFlagList () const
LowLevelILSSARegisterOrFlagList	GetOutputSSARegisterOrFlagList () const
LowLevelILIndexList	GetSourceMemoryVersions () const
LowLevelILIndexMap	GetTargets () const
std::map< uint32_t, int32_t >	GetRegisterStackAdjustments () const
Public Member Functions inherited from BinaryNinja::LowLevelILInstructionBase
LowLevelILOperandList	GetOperands () const
uint64_t	GetRawOperandAsInteger (size_t operand) const
uint32_t	GetRawOperandAsRegister (size_t operand) const
size_t	GetRawOperandAsIndex (size_t operand) const
BNLowLevelILFlagCondition	GetRawOperandAsFlagCondition (size_t operand) const
LowLevelILInstruction	GetRawOperandAsExpr (size_t operand) const
SSARegister	GetRawOperandAsSSARegister (size_t operand) const
SSARegisterStack	GetRawOperandAsSSARegisterStack (size_t operand) const
SSARegisterStack	GetRawOperandAsPartialSSARegisterStackSource (size_t operand) const
SSAFlag	GetRawOperandAsSSAFlag (size_t operand) const
LowLevelILIndexList	GetRawOperandAsIndexList (size_t operand) const
LowLevelILIndexMap	GetRawOperandAsIndexMap (size_t operand) const
LowLevelILInstructionList	GetRawOperandAsExprList (size_t operand) const
LowLevelILRegisterOrFlagList	GetRawOperandAsRegisterOrFlagList (size_t operand) const
LowLevelILSSARegisterList	GetRawOperandAsSSARegisterList (size_t operand) const
LowLevelILSSARegisterStackList	GetRawOperandAsSSARegisterStackList (size_t operand) const
LowLevelILSSAFlagList	GetRawOperandAsSSAFlagList (size_t operand) const
LowLevelILSSARegisterOrFlagList	GetRawOperandAsSSARegisterOrFlagList (size_t operand) const
std::map< uint32_t, int32_t >	GetRawOperandAsRegisterStackAdjustments (size_t operand) const
PossibleValueSet	GetRawOperandAsPossibleValueSet (size_t operand) const
void	UpdateRawOperand (size_t operandIndex, ExprId value)
void	UpdateRawOperandAsSSARegisterList (size_t operandIndex, const std::vector< SSARegister > &regs)
void	UpdateRawOperandAsSSARegisterOrFlagList (size_t operandIndex, const std::vector< SSARegisterOrFlag > &outputs)
RegisterValue	GetValue () const
PossibleValueSet	GetPossibleValues (const std::set< BNDataFlowQueryOption > &options=std::set< BNDataFlowQueryOption >()) const
RegisterValue	GetRegisterValue (uint32_t reg)
RegisterValue	GetRegisterValueAfter (uint32_t reg)
PossibleValueSet	GetPossibleRegisterValues (uint32_t reg)
PossibleValueSet	GetPossibleRegisterValuesAfter (uint32_t reg)
RegisterValue	GetFlagValue (uint32_t flag)
RegisterValue	GetFlagValueAfter (uint32_t flag)
PossibleValueSet	GetPossibleFlagValues (uint32_t flag)
PossibleValueSet	GetPossibleFlagValuesAfter (uint32_t flag)
RegisterValue	GetStackContents (int32_t offset, size_t len)
RegisterValue	GetStackContentsAfter (int32_t offset, size_t len)
PossibleValueSet	GetPossibleStackContents (int32_t offset, size_t len)
PossibleValueSet	GetPossibleStackContentsAfter (int32_t offset, size_t len)
size_t	GetSSAInstructionIndex () const
size_t	GetNonSSAInstructionIndex () const
size_t	GetSSAExprIndex () const
size_t	GetNonSSAExprIndex () const
LowLevelILInstruction	GetSSAForm () const
LowLevelILInstruction	GetNonSSAForm () const
size_t	GetMediumLevelILInstructionIndex () const
size_t	GetMediumLevelILExprIndex () const
size_t	GetMappedMediumLevelILInstructionIndex () const
size_t	GetMappedMediumLevelILExprIndex () const
bool	HasMediumLevelIL () const
bool	HasMappedMediumLevelIL () const
MediumLevelILInstruction	GetMediumLevelIL () const
MediumLevelILInstruction	GetMappedMediumLevelIL () const
char *	Dump () const
void	Replace (ExprId expr)
void	SetAttributes (uint32_t attributes)
void	SetAttribute (BNILInstructionAttribute attribute, bool state=true)
void	ClearAttribute (BNILInstructionAttribute attribute)
template<BNLowLevelILOperation N>
LowLevelILInstructionAccessor< N > &	As ()
LowLevelILOneOperandInstruction &	AsOneOperand ()
LowLevelILTwoOperandInstruction &	AsTwoOperand ()
LowLevelILTwoOperandWithCarryInstruction &	AsTwoOperandWithCarry ()
template<BNLowLevelILOperation N>
const LowLevelILInstructionAccessor< N > &	As () const
const LowLevelILConstantInstruction &	AsConstant () const
const LowLevelILOneOperandInstruction &	AsOneOperand () const
const LowLevelILTwoOperandInstruction &	AsTwoOperand () const
const LowLevelILTwoOperandWithCarryInstruction &	AsTwoOperandWithCarry () const

Additional Inherited Members
Public Attributes inherited from BinaryNinja::LowLevelILInstructionBase
Ref< LowLevelILFunction >	function
size_t	exprIndex
size_t	instructionIndex
Public Attributes inherited from BNLowLevelILInstruction
BNLowLevelILOperation	operation
uint32_t	attributes
size_t	size
uint32_t	flags
uint32_t	sourceOperand
uint64_t	operands [4]
uint64_t	address
Static Public Attributes inherited from BinaryNinja::LowLevelILInstructionBase
static std::unordered_map< LowLevelILOperandUsage, LowLevelILOperandType >	operandTypeForUsage
static std::unordered_map< BNLowLevelILOperation, std::vector< LowLevelILOperandUsage > >	operationOperandUsage
static std::unordered_map< BNLowLevelILOperation, std::unordered_map< LowLevelILOperandUsage, size_t > >	operationOperandIndex = GetOperandIndexForOperandUsages()

◆ LowLevelILInstruction() [1/3]

LowLevelILInstruction::LowLevelILInstruction

(

)

◆ LowLevelILInstruction() [2/3]

LowLevelILInstruction::LowLevelILInstruction	(	LowLevelILFunction *	func,
		const BNLowLevelILInstruction &	instr,
		size_t	expr,
		size_t	instrIdx )

◆ LowLevelILInstruction() [3/3]

LowLevelILInstruction::LowLevelILInstruction

(

const LowLevelILInstructionBase &

instr

)

◆ VisitExprs()

void LowLevelILInstruction::VisitExprs

(

const std::function< bool(const LowLevelILInstruction &expr)> &

func

)

const

◆ CopyTo() [1/2]

ExprId LowLevelILInstruction::CopyTo

(

LowLevelILFunction *

dest

)

const

◆ CopyTo() [2/2]

ExprId LowLevelILInstruction::CopyTo	(	LowLevelILFunction *	dest,
		const std::function< ExprId(const LowLevelILInstruction &subExpr)> &	subExprHandler ) const

◆ GetSourceExpr() [1/2]

LowLevelILInstruction BinaryNinja::LowLevelILInstruction::GetSourceExpr

(

)

const

inline

◆ GetSourceRegister() [1/2]

uint32_t BinaryNinja::LowLevelILInstruction::GetSourceRegister

(

)

const

inline

◆ GetSourceRegisterStack() [1/2]

uint32_t BinaryNinja::LowLevelILInstruction::GetSourceRegisterStack

(

)

const

inline

◆ GetSourceFlag() [1/2]

uint32_t BinaryNinja::LowLevelILInstruction::GetSourceFlag

(

)

const

inline

◆ GetSourceSSARegister() [1/2]

SSARegister BinaryNinja::LowLevelILInstruction::GetSourceSSARegister

(

)

const

inline

◆ GetSourceSSARegisterStack() [1/2]

SSARegisterStack BinaryNinja::LowLevelILInstruction::GetSourceSSARegisterStack

(

)

const

inline

◆ GetSourceSSAFlag() [1/2]

SSAFlag BinaryNinja::LowLevelILInstruction::GetSourceSSAFlag

(

)

const

inline

◆ GetDestExpr() [1/2]

LowLevelILInstruction BinaryNinja::LowLevelILInstruction::GetDestExpr

(

)

const

inline

◆ GetDestRegister() [1/2]

uint32_t BinaryNinja::LowLevelILInstruction::GetDestRegister

(

)

const

inline

◆ GetDestRegisterStack() [1/2]

uint32_t BinaryNinja::LowLevelILInstruction::GetDestRegisterStack

(

)

const

inline

◆ GetDestFlag() [1/2]

uint32_t BinaryNinja::LowLevelILInstruction::GetDestFlag

(

)

const

inline

◆ GetDestSSARegister() [1/2]

SSARegister BinaryNinja::LowLevelILInstruction::GetDestSSARegister

(

)

const

inline

◆ GetDestSSARegisterStack() [1/2]

SSARegisterStack BinaryNinja::LowLevelILInstruction::GetDestSSARegisterStack

(

)

const

inline

◆ GetDestSSAFlag() [1/2]

SSAFlag BinaryNinja::LowLevelILInstruction::GetDestSSAFlag

(

)

const

inline

◆ GetSemanticFlagClass() [1/2]

uint32_t BinaryNinja::LowLevelILInstruction::GetSemanticFlagClass

(

)

const

inline

◆ GetSemanticFlagGroup() [1/2]

uint32_t BinaryNinja::LowLevelILInstruction::GetSemanticFlagGroup

(

)

const

inline

◆ GetPartialRegister() [1/2]

uint32_t BinaryNinja::LowLevelILInstruction::GetPartialRegister

(

)

const

inline

◆ GetStackSSARegister() [1/2]

SSARegister BinaryNinja::LowLevelILInstruction::GetStackSSARegister

(

)

const

inline

◆ GetTopSSARegister() [1/2]

SSARegister BinaryNinja::LowLevelILInstruction::GetTopSSARegister

(

)

const

inline

◆ GetLeftExpr() [1/2]

LowLevelILInstruction BinaryNinja::LowLevelILInstruction::GetLeftExpr

(

)

const

inline

◆ GetRightExpr() [1/2]

LowLevelILInstruction BinaryNinja::LowLevelILInstruction::GetRightExpr

(

)

const

inline

◆ GetCarryExpr() [1/2]

LowLevelILInstruction BinaryNinja::LowLevelILInstruction::GetCarryExpr

(

)

const

inline

◆ GetConditionExpr() [1/2]

LowLevelILInstruction BinaryNinja::LowLevelILInstruction::GetConditionExpr

(

)

const

inline

◆ GetHighRegister() [1/2]

uint32_t BinaryNinja::LowLevelILInstruction::GetHighRegister

(

)

const

inline

◆ GetHighSSARegister() [1/2]

SSARegister BinaryNinja::LowLevelILInstruction::GetHighSSARegister

(

)

const

inline

◆ GetLowRegister() [1/2]

uint32_t BinaryNinja::LowLevelILInstruction::GetLowRegister

(

)

const

inline

◆ GetLowSSARegister() [1/2]

SSARegister BinaryNinja::LowLevelILInstruction::GetLowSSARegister

(

)

const

inline

◆ GetIntrinsic() [1/2]

uint32_t BinaryNinja::LowLevelILInstruction::GetIntrinsic

(

)

const

inline

◆ GetConstant() [1/2]

int64_t BinaryNinja::LowLevelILInstruction::GetConstant

(

)

const

inline

◆ GetOffset() [1/2]

uint64_t BinaryNinja::LowLevelILInstruction::GetOffset

(

)

const

inline

◆ GetVector() [1/2]

int64_t BinaryNinja::LowLevelILInstruction::GetVector

(

)

const

inline

◆ GetStackAdjustment() [1/2]

int64_t BinaryNinja::LowLevelILInstruction::GetStackAdjustment

(

)

const

inline

◆ GetTarget() [1/2]

size_t BinaryNinja::LowLevelILInstruction::GetTarget

(

)

const

inline

◆ GetTrueTarget() [1/2]

size_t BinaryNinja::LowLevelILInstruction::GetTrueTarget

(

)

const

inline

◆ GetFalseTarget() [1/2]

size_t BinaryNinja::LowLevelILInstruction::GetFalseTarget

(

)

const

inline

◆ GetBitIndex() [1/2]

size_t BinaryNinja::LowLevelILInstruction::GetBitIndex

(

)

const

inline

◆ GetSourceMemoryVersion() [1/2]

size_t BinaryNinja::LowLevelILInstruction::GetSourceMemoryVersion

(

)

const

inline

◆ GetDestMemoryVersion() [1/2]

size_t BinaryNinja::LowLevelILInstruction::GetDestMemoryVersion

(

)

const

inline

◆ GetFlagCondition() [1/2]

◆ GetOutputSSARegisters() [1/2]

LowLevelILSSARegisterList BinaryNinja::LowLevelILInstruction::GetOutputSSARegisters

(

)

const

inline

◆ GetParameterExprs() [1/2]

LowLevelILInstructionList BinaryNinja::LowLevelILInstruction::GetParameterExprs

(

)

const

inline

◆ GetSourceSSARegisters() [1/2]

LowLevelILSSARegisterList BinaryNinja::LowLevelILInstruction::GetSourceSSARegisters

(

)

const

inline

◆ GetSourceSSARegisterStacks() [1/2]

LowLevelILSSARegisterStackList BinaryNinja::LowLevelILInstruction::GetSourceSSARegisterStacks

(

)

const

inline

◆ GetSourceSSAFlags() [1/2]

LowLevelILSSAFlagList BinaryNinja::LowLevelILInstruction::GetSourceSSAFlags

(

)

const

inline

◆ GetOutputRegisterOrFlagList() [1/2]

LowLevelILRegisterOrFlagList BinaryNinja::LowLevelILInstruction::GetOutputRegisterOrFlagList

(

)

const

inline

◆ GetOutputSSARegisterOrFlagList() [1/2]

LowLevelILSSARegisterOrFlagList BinaryNinja::LowLevelILInstruction::GetOutputSSARegisterOrFlagList

(

)

const

inline

◆ GetSourceMemoryVersions() [1/2]

LowLevelILIndexList BinaryNinja::LowLevelILInstruction::GetSourceMemoryVersions

(

)

const

inline

◆ GetTargets() [1/2]

LowLevelILIndexMap BinaryNinja::LowLevelILInstruction::GetTargets

(

)

const

inline

◆ GetRegisterStackAdjustments() [1/2]

std::map< uint32_t, int32_t > BinaryNinja::LowLevelILInstruction::GetRegisterStackAdjustments

(

)

const

inline

◆ SetDestSSAVersion()

void BinaryNinja::LowLevelILInstruction::SetDestSSAVersion

(

size_t

version

)

inline

◆ SetSourceSSAVersion()

void BinaryNinja::LowLevelILInstruction::SetSourceSSAVersion

(

size_t

version

)

inline

◆ SetHighSSAVersion()

void BinaryNinja::LowLevelILInstruction::SetHighSSAVersion

(

size_t

version

)

inline

◆ SetLowSSAVersion()

void BinaryNinja::LowLevelILInstruction::SetLowSSAVersion

(

size_t

version

)

inline

◆ SetStackSSAVersion()

void BinaryNinja::LowLevelILInstruction::SetStackSSAVersion

(

size_t

version

)

inline

◆ SetTopSSAVersion()

void BinaryNinja::LowLevelILInstruction::SetTopSSAVersion

(

size_t

version

)

inline

◆ SetDestMemoryVersion()

void BinaryNinja::LowLevelILInstruction::SetDestMemoryVersion

(

size_t

version

)

inline

◆ SetSourceMemoryVersion()

void BinaryNinja::LowLevelILInstruction::SetSourceMemoryVersion

(

size_t

version

)

inline

◆ SetOutputSSARegisters()

void BinaryNinja::LowLevelILInstruction::SetOutputSSARegisters

(

const std::vector< SSARegister > &

regs

)

inline

◆ SetOutputSSARegisterOrFlagList()

void BinaryNinja::LowLevelILInstruction::SetOutputSSARegisterOrFlagList

(

const std::vector< SSARegisterOrFlag > &

outputs

)

inline

◆ GetConstraint()

PossibleValueSet BinaryNinja::LowLevelILInstruction::GetConstraint

(

)

const

inline

◆ GetOperandIndexForUsage()

bool LowLevelILInstruction::GetOperandIndexForUsage	(	LowLevelILOperandUsage	usage,
		size_t &	operandIndex ) const

◆ GetSourceExpr() [2/2]

LowLevelILInstruction LowLevelILInstruction::GetSourceExpr

(

)

const

◆ GetSourceRegister() [2/2]

uint32_t LowLevelILInstruction::GetSourceRegister

(

)

const

◆ GetSourceRegisterStack() [2/2]

uint32_t LowLevelILInstruction::GetSourceRegisterStack

(

)

const

◆ GetSourceFlag() [2/2]

uint32_t LowLevelILInstruction::GetSourceFlag

(

)

const

◆ GetSourceSSARegister() [2/2]

SSARegister LowLevelILInstruction::GetSourceSSARegister

(

)

const

◆ GetSourceSSARegisterStack() [2/2]

SSARegisterStack LowLevelILInstruction::GetSourceSSARegisterStack

(

)

const

◆ GetSourceSSAFlag() [2/2]

SSAFlag LowLevelILInstruction::GetSourceSSAFlag

(

)

const

◆ GetDestExpr() [2/2]

LowLevelILInstruction LowLevelILInstruction::GetDestExpr

(

)

const

◆ GetDestRegister() [2/2]

uint32_t LowLevelILInstruction::GetDestRegister

(

)

const

◆ GetDestRegisterStack() [2/2]

uint32_t LowLevelILInstruction::GetDestRegisterStack

(

)

const

◆ GetDestFlag() [2/2]

uint32_t LowLevelILInstruction::GetDestFlag

(

)

const

◆ GetDestSSARegister() [2/2]

SSARegister LowLevelILInstruction::GetDestSSARegister

(

)

const

◆ GetDestSSARegisterStack() [2/2]

SSARegisterStack LowLevelILInstruction::GetDestSSARegisterStack

(

)

const

◆ GetDestSSAFlag() [2/2]

SSAFlag LowLevelILInstruction::GetDestSSAFlag

(

)

const

◆ GetSemanticFlagClass() [2/2]

uint32_t LowLevelILInstruction::GetSemanticFlagClass

(

)

const

◆ GetSemanticFlagGroup() [2/2]

uint32_t LowLevelILInstruction::GetSemanticFlagGroup

(

)

const

◆ GetPartialRegister() [2/2]

uint32_t LowLevelILInstruction::GetPartialRegister

(

)

const

◆ GetStackSSARegister() [2/2]

SSARegister LowLevelILInstruction::GetStackSSARegister

(

)

const

◆ GetTopSSARegister() [2/2]

SSARegister LowLevelILInstruction::GetTopSSARegister

(

)

const

◆ GetLeftExpr() [2/2]

LowLevelILInstruction LowLevelILInstruction::GetLeftExpr

(

)

const

◆ GetRightExpr() [2/2]

LowLevelILInstruction LowLevelILInstruction::GetRightExpr

(

)

const

◆ GetCarryExpr() [2/2]

LowLevelILInstruction LowLevelILInstruction::GetCarryExpr

(

)

const

◆ GetConditionExpr() [2/2]

LowLevelILInstruction LowLevelILInstruction::GetConditionExpr

(

)

const

◆ GetHighRegister() [2/2]

uint32_t LowLevelILInstruction::GetHighRegister

(

)

const

◆ GetHighSSARegister() [2/2]

SSARegister LowLevelILInstruction::GetHighSSARegister

(

)

const

◆ GetLowRegister() [2/2]

uint32_t LowLevelILInstruction::GetLowRegister

(

)

const

◆ GetLowSSARegister() [2/2]

SSARegister LowLevelILInstruction::GetLowSSARegister

(

)

const

◆ GetIntrinsic() [2/2]

uint32_t LowLevelILInstruction::GetIntrinsic

(

)

const

◆ GetConstant() [2/2]

int64_t LowLevelILInstruction::GetConstant

(

)

const

◆ GetOffset() [2/2]

uint64_t LowLevelILInstruction::GetOffset

(

)

const

◆ GetVector() [2/2]

int64_t LowLevelILInstruction::GetVector

(

)

const

◆ GetStackAdjustment() [2/2]

int64_t LowLevelILInstruction::GetStackAdjustment

(

)

const

◆ GetTarget() [2/2]

size_t LowLevelILInstruction::GetTarget

(

)

const

◆ GetTrueTarget() [2/2]

size_t LowLevelILInstruction::GetTrueTarget

(

)

const

◆ GetFalseTarget() [2/2]

size_t LowLevelILInstruction::GetFalseTarget

(

)

const

◆ GetBitIndex() [2/2]

size_t LowLevelILInstruction::GetBitIndex

(

)

const

◆ GetSourceMemoryVersion() [2/2]

size_t LowLevelILInstruction::GetSourceMemoryVersion

(

)

const

◆ GetDestMemoryVersion() [2/2]

size_t LowLevelILInstruction::GetDestMemoryVersion

(

)

const

◆ GetFlagCondition() [2/2]

◆ GetOutputSSARegisters() [2/2]

LowLevelILSSARegisterList LowLevelILInstruction::GetOutputSSARegisters

(

)

const

◆ GetParameterExprs() [2/2]

LowLevelILInstructionList LowLevelILInstruction::GetParameterExprs

(

)

const

◆ GetSourceSSARegisters() [2/2]

LowLevelILSSARegisterList LowLevelILInstruction::GetSourceSSARegisters

(

)

const

◆ GetSourceSSARegisterStacks() [2/2]

LowLevelILSSARegisterStackList LowLevelILInstruction::GetSourceSSARegisterStacks

(

)

const

◆ GetSourceSSAFlags() [2/2]

LowLevelILSSAFlagList LowLevelILInstruction::GetSourceSSAFlags

(

)

const

◆ GetOutputRegisterOrFlagList() [2/2]

LowLevelILRegisterOrFlagList LowLevelILInstruction::GetOutputRegisterOrFlagList

(

)

const

◆ GetOutputSSARegisterOrFlagList() [2/2]

LowLevelILSSARegisterOrFlagList LowLevelILInstruction::GetOutputSSARegisterOrFlagList

(

)

const

◆ GetSourceMemoryVersions() [2/2]

LowLevelILIndexList LowLevelILInstruction::GetSourceMemoryVersions

(

)

const

◆ GetTargets() [2/2]

LowLevelILIndexMap LowLevelILInstruction::GetTargets

(

)

const

◆ GetRegisterStackAdjustments() [2/2]

map< uint32_t, int32_t > LowLevelILInstruction::GetRegisterStackAdjustments

(

)

const

◆ BinaryNinja::LowLevelILOperand

class BinaryNinja::LowLevelILOperand

Public Member Functions
	LowLevelILOperand (const LowLevelILInstruction &instr, LowLevelILOperandUsage usage, size_t operandIndex)
LowLevelILOperandType	GetType () const
LowLevelILOperandUsage	GetUsage () const
uint64_t	GetInteger () const
size_t	GetIndex () const
LowLevelILInstruction	GetExpr () const
uint32_t	GetRegister () const
uint32_t	GetRegisterStack () const
uint32_t	GetFlag () const
uint32_t	GetSemanticFlagClass () const
uint32_t	GetSemanticFlagGroup () const
uint32_t	GetIntrinsic () const
BNLowLevelILFlagCondition	GetFlagCondition () const
SSARegister	GetSSARegister () const
SSARegisterStack	GetSSARegisterStack () const
SSAFlag	GetSSAFlag () const
LowLevelILIndexList	GetIndexList () const
LowLevelILIndexMap	GetIndexMap () const
LowLevelILInstructionList	GetExprList () const
LowLevelILSSARegisterList	GetSSARegisterList () const
LowLevelILSSARegisterStackList	GetSSARegisterStackList () const
LowLevelILSSAFlagList	GetSSAFlagList () const
LowLevelILRegisterOrFlagList	GetRegisterOrFlagList () const
LowLevelILSSARegisterOrFlagList	GetSSARegisterOrFlagList () const
std::map< uint32_t, int32_t >	GetRegisterStackAdjustments () const

◆ LowLevelILOperand()

LowLevelILOperand::LowLevelILOperand	(	const LowLevelILInstruction &	instr,
		LowLevelILOperandUsage	usage,
		size_t	operandIndex )

◆ GetType()

LowLevelILOperandType BinaryNinja::LowLevelILOperand::GetType

(

)

const

inline

◆ GetUsage()

LowLevelILOperandUsage BinaryNinja::LowLevelILOperand::GetUsage

(

)

const

inline

◆ GetInteger()

uint64_t LowLevelILOperand::GetInteger

(

)

const

◆ GetIndex()

size_t LowLevelILOperand::GetIndex

(

)

const

◆ GetExpr()

LowLevelILInstruction LowLevelILOperand::GetExpr

(

)

const

◆ GetRegister()

uint32_t LowLevelILOperand::GetRegister

(

)

const

◆ GetRegisterStack()

uint32_t LowLevelILOperand::GetRegisterStack

(

)

const

◆ GetFlag()

uint32_t LowLevelILOperand::GetFlag

(

)

const

◆ GetSemanticFlagClass()

uint32_t LowLevelILOperand::GetSemanticFlagClass

(

)

const

◆ GetSemanticFlagGroup()

uint32_t LowLevelILOperand::GetSemanticFlagGroup

(

)

const

◆ GetIntrinsic()

uint32_t LowLevelILOperand::GetIntrinsic

(

)

const

◆ GetFlagCondition()

◆ GetSSARegister()

SSARegister LowLevelILOperand::GetSSARegister

(

)

const

◆ GetSSARegisterStack()

SSARegisterStack LowLevelILOperand::GetSSARegisterStack

(

)

const

◆ GetSSAFlag()

SSAFlag LowLevelILOperand::GetSSAFlag

(

)

const

◆ GetIndexList()

LowLevelILIndexList LowLevelILOperand::GetIndexList

(

)

const

◆ GetIndexMap()

LowLevelILIndexMap LowLevelILOperand::GetIndexMap

(

)

const

◆ GetExprList()

LowLevelILInstructionList LowLevelILOperand::GetExprList

(

)

const

◆ GetSSARegisterList()

LowLevelILSSARegisterList LowLevelILOperand::GetSSARegisterList

(

)

const

◆ GetSSARegisterStackList()

LowLevelILSSARegisterStackList LowLevelILOperand::GetSSARegisterStackList

(

)

const

◆ GetSSAFlagList()

LowLevelILSSAFlagList LowLevelILOperand::GetSSAFlagList

(

)

const

◆ GetRegisterOrFlagList()

LowLevelILRegisterOrFlagList LowLevelILOperand::GetRegisterOrFlagList

(

)

const

◆ GetSSARegisterOrFlagList()

LowLevelILSSARegisterOrFlagList LowLevelILOperand::GetSSARegisterOrFlagList

(

)

const

◆ GetRegisterStackAdjustments()

map< uint32_t, int32_t > LowLevelILOperand::GetRegisterStackAdjustments

(

)

const

◆ BinaryNinja::LowLevelILOperandList

class BinaryNinja::LowLevelILOperandList

Public Types
typedef ListIterator	const_iterator
Public Member Functions
	LowLevelILOperandList (const LowLevelILInstruction &instr, const std::vector< LowLevelILOperandUsage > &usageList, const std::unordered_map< LowLevelILOperandUsage, size_t > &operandIndexMap)
const_iterator	begin () const
const_iterator	end () const
size_t	size () const
const LowLevelILOperand	operator[] (size_t i) const
	operator std::vector< LowLevelILOperand > () const

◆ const_iterator

◆ LowLevelILOperandList()

LowLevelILOperandList::LowLevelILOperandList	(	const LowLevelILInstruction &	instr,
		const std::vector< LowLevelILOperandUsage > &	usageList,
		const std::unordered_map< LowLevelILOperandUsage, size_t > &	operandIndexMap )

◆ begin()

LowLevelILOperandList::const_iterator LowLevelILOperandList::begin

(

)

const

◆ end()

LowLevelILOperandList::const_iterator LowLevelILOperandList::end

(

)

const

◆ size()

size_t LowLevelILOperandList::size

(

)

const

◆ operator[]()

const LowLevelILOperand LowLevelILOperandList::operator[]

(

size_t

)

const

◆ operator std::vector< LowLevelILOperand >()

BinaryNinja::LowLevelILOperandList::operator std::vector< LowLevelILOperand >

(

)

const

◆ LowLevelILOperandType

Enumerator
IntegerLowLevelOperand
IndexLowLevelOperand
ExprLowLevelOperand
RegisterLowLevelOperand
RegisterStackLowLevelOperand
FlagLowLevelOperand
FlagConditionLowLevelOperand
IntrinsicLowLevelOperand
SemanticFlagClassLowLevelOperand
SemanticFlagGroupLowLevelOperand
SSARegisterLowLevelOperand
SSARegisterStackLowLevelOperand
SSAFlagLowLevelOperand
IndexListLowLevelOperand
IndexMapLowLevelOperand
ExprListLowLevelOperand
RegisterOrFlagListLowLevelOperand
SSARegisterListLowLevelOperand
SSARegisterStackListLowLevelOperand
SSAFlagListLowLevelOperand
SSARegisterOrFlagListLowLevelOperand
RegisterStackAdjustmentsLowLevelOperand
ConstraintLowLevelOperand

◆ LowLevelILOperandUsage

Enumerator
SourceExprLowLevelOperandUsage
SourceRegisterLowLevelOperandUsage
SourceRegisterStackLowLevelOperandUsage
SourceFlagLowLevelOperandUsage
SourceSSARegisterLowLevelOperandUsage
SourceSSARegisterStackLowLevelOperandUsage
SourceSSAFlagLowLevelOperandUsage
DestExprLowLevelOperandUsage
DestRegisterLowLevelOperandUsage
DestRegisterStackLowLevelOperandUsage
DestFlagLowLevelOperandUsage
DestSSARegisterLowLevelOperandUsage
DestSSARegisterStackLowLevelOperandUsage
DestSSAFlagLowLevelOperandUsage
SemanticFlagClassLowLevelOperandUsage
SemanticFlagGroupLowLevelOperandUsage
PartialRegisterLowLevelOperandUsage
PartialSSARegisterStackSourceLowLevelOperandUsage
StackSSARegisterLowLevelOperandUsage
StackMemoryVersionLowLevelOperandUsage
TopSSARegisterLowLevelOperandUsage
LeftExprLowLevelOperandUsage
RightExprLowLevelOperandUsage
CarryExprLowLevelOperandUsage
ConditionExprLowLevelOperandUsage
HighRegisterLowLevelOperandUsage
HighSSARegisterLowLevelOperandUsage
LowRegisterLowLevelOperandUsage
LowSSARegisterLowLevelOperandUsage
IntrinsicLowLevelOperandUsage
ConstantLowLevelOperandUsage
VectorLowLevelOperandUsage
StackAdjustmentLowLevelOperandUsage
TargetLowLevelOperandUsage
TrueTargetLowLevelOperandUsage
FalseTargetLowLevelOperandUsage
BitIndexLowLevelOperandUsage
SourceMemoryVersionLowLevelOperandUsage
DestMemoryVersionLowLevelOperandUsage
FlagConditionLowLevelOperandUsage
OutputSSARegistersLowLevelOperandUsage
OutputMemoryVersionLowLevelOperandUsage
ParameterExprsLowLevelOperandUsage
SourceSSARegistersLowLevelOperandUsage
SourceSSARegisterStacksLowLevelOperandUsage
SourceSSAFlagsLowLevelOperandUsage
OutputRegisterOrFlagListLowLevelOperandUsage
OutputSSARegisterOrFlagListLowLevelOperandUsage
OutputMemoryIntrinsicLowLevelOperandUsage
SourceMemoryVersionsLowLevelOperandUsage
TargetsLowLevelOperandUsage
RegisterStackAdjustmentsLowLevelOperandUsage
OffsetLowLevelOperandUsage
ConstraintLowLevelOperandUsage

Classes

Enumerations

◆ BinaryNinja::LowLevelILLabel

Public Member Functions

◆ LowLevelILLabel()

◆ BinaryNinja::LowLevelILFunction

Public Member Functions

Static Public Member Functions

◆ LowLevelILFunction() [1/2]

◆ LowLevelILFunction() [2/2]

◆ GetFunction()

◆ GetArchitecture()

◆ PrepareToCopyFunction()

◆ PrepareToCopyBlock()

◆ GetLabelForSourceInstruction()

◆ GetCurrentAddress()

◆ SetCurrentAddress()

◆ GetInstructionStart()

◆ GetInstructionsAt()

◆ GetExitsForInstruction()

◆ ClearIndirectBranches()

◆ SetIndirectBranches()

◆ GetRegisters()

◆ GetRegisterStacks()

◆ GetFlags()

◆ GetSSARegistersWithoutVersions()

◆ GetSSARegisterStacksWithoutVersions()

◆ GetSSAFlagsWithoutVersions()

◆ GetSSARegisters()

◆ GetSSARegisterStacks()

◆ GetSSAFlags()

◆ CachePossibleValueSet()

◆ GetCachedPossibleValueSet()

◆ AddExpr()

◆ AddExprWithLocation() [1/2]

◆ AddExprWithLocation() [2/2]

◆ AddInstruction()

◆ Nop()

◆ SetRegister()

◆ SetRegisterSplit()

◆ SetRegisterSSA()

◆ SetRegisterSSAPartial()

◆ SetRegisterSplitSSA()

◆ SetRegisterStackTopRelative()

◆ RegisterStackPush()

◆ SetRegisterStackTopRelativeSSA()

◆ SetRegisterStackAbsoluteSSA()

◆ SetFlag()

◆ SetFlagSSA()

◆ ForceVer()

◆ ForceVerSSA()

◆ Assert()

◆ AssertSSA()

◆ Load()

◆ LoadSSA()

◆ Store()

◆ StoreSSA()

◆ Push()

◆ Pop()

◆ Register()

◆ RegisterSSA()

◆ RegisterSSAPartial()

◆ RegisterSplit()

◆ RegisterSplitSSA()

◆ RegisterStackTopRelative()

◆ RegisterStackPop()

◆ RegisterStackFreeReg()

◆ RegisterStackFreeTopRelative()

◆ RegisterStackTopRelativeSSA()

◆ RegisterStackAbsoluteSSA()

◆ RegisterStackFreeTopRelativeSSA()

◆ RegisterStackFreeAbsoluteSSA()

◆ Const()

◆ ConstPointer()

◆ ExternPointer()

◆ FloatConstRaw()

◆ FloatConstSingle()

◆ FloatConstDouble()

◆ Flag()

◆ FlagSSA()