lowlevelil module¶
Class |
Description |
---|---|
The |
|
|
|
|
|
|
|
- class CoreLowLevelILInstruction[source]
Bases:
object
CoreLowLevelILInstruction(operation: binaryninja.enums.LowLevelILOperation, attributes: int, size: int, flags: int, source_operand: binaryninja.lowlevelil.ExpressionIndex, operands: Tuple[binaryninja.lowlevelil.ExpressionIndex, binaryninja.lowlevelil.ExpressionIndex, binaryninja.lowlevelil.ExpressionIndex, binaryninja.lowlevelil.ExpressionIndex], address: int)
- __init__(operation: LowLevelILOperation, attributes: int, size: int, flags: int, source_operand: ExpressionIndex, operands: Tuple[ExpressionIndex, ExpressionIndex, ExpressionIndex, ExpressionIndex], address: int) None
- classmethod from_BNLowLevelILInstruction(instr: BNLowLevelILInstruction) CoreLowLevelILInstruction [source]
- Parameters:
instr (BNLowLevelILInstruction) –
- Return type:
- address: int
- attributes: int
- flags: int
- operands: Tuple[ExpressionIndex, ExpressionIndex, ExpressionIndex, ExpressionIndex]
- operation: LowLevelILOperation
- size: int
- source_operand: ExpressionIndex
- class ILFlag[source]
Bases:
object
ILFlag(arch: ‘architecture.Architecture’, index: ‘architecture.FlagIndex’)
- __init__(arch: Architecture, index: FlagIndex) None
- Parameters:
arch (Architecture) –
index (FlagIndex) –
- Return type:
None
- arch: Architecture
- index: FlagIndex
- property name: FlagName
- property temp: bool
- class ILIntrinsic[source]
Bases:
object
ILIntrinsic(arch: ‘architecture.Architecture’, index: ‘architecture.IntrinsicIndex’)
- __init__(arch: Architecture, index: IntrinsicIndex) None
- Parameters:
arch (Architecture) –
index (IntrinsicIndex) –
- Return type:
None
- arch: Architecture
- index: IntrinsicIndex
- property inputs: List[IntrinsicInput]
inputs
is only available if the IL intrinsic is an Architecture intrinsic
- property name: IntrinsicName
- class ILRegister[source]
Bases:
object
ILRegister(arch: ‘architecture.Architecture’, index: ‘architecture.RegisterIndex’)
- __init__(arch: Architecture, index: RegisterIndex) None
- Parameters:
arch (Architecture) –
index (RegisterIndex) –
- Return type:
None
- arch: Architecture
- index: RegisterIndex
- property info: RegisterInfo
- property name: RegisterName
- property temp: bool
- class ILRegisterStack[source]
Bases:
object
ILRegisterStack(arch: ‘architecture.Architecture’, index: ‘architecture.RegisterStackIndex’)
- __init__(arch: Architecture, index: RegisterStackIndex) None
- Parameters:
arch (Architecture) –
index (RegisterStackIndex) –
- Return type:
None
- arch: Architecture
- index: RegisterStackIndex
- property info: RegisterStackInfo
- property name: RegisterStackName
- class ILSemanticFlagClass[source]
Bases:
object
ILSemanticFlagClass(arch: ‘architecture.Architecture’, index: ‘architecture.SemanticClassIndex’)
- __init__(arch: Architecture, index: SemanticClassIndex) None
- Parameters:
arch (Architecture) –
index (SemanticClassIndex) –
- Return type:
None
- arch: Architecture
- index: SemanticClassIndex
- property name: SemanticClassName
- class ILSemanticFlagGroup[source]
Bases:
object
ILSemanticFlagGroup(arch: ‘architecture.Architecture’, index: ‘architecture.SemanticGroupIndex’)
- __init__(arch: Architecture, index: SemanticGroupIndex) None
- Parameters:
arch (Architecture) –
index (SemanticGroupIndex) –
- Return type:
None
- arch: Architecture
- index: SemanticGroupIndex
- property name: SemanticGroupName
- class LowLevelILAdc[source]
Bases:
LowLevelILCarryBase
LowLevelILAdc(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILAdd[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAdd(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILAddOverflow[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAddOverflow(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILAnd[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAnd(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILAsr[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAsr(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILAssert[source]
Bases:
LowLevelILInstruction
LowLevelILAssert(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property constraint: PossibleValueSet
- property src: ILRegister
- class LowLevelILAssertSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILAssertSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property constraint: PossibleValueSet
- property src: SSARegister
- class LowLevelILBasicBlock[source]
Bases:
BasicBlock
The
LogLevelILBasicBlock
object is returned during analysis and should not be directly instantiated.- __init__(handle: LP_BNBasicBlock, owner: LowLevelILFunction, view: BinaryView | None)[source]
- Parameters:
handle (LP_BNBasicBlock) –
owner (LowLevelILFunction) –
view (BinaryView | None) –
- property il_function: LowLevelILFunction
IL Function of which this block is a part, if the block is part of an IL Function.
- property instruction_count: int
- class LowLevelILBinaryBase[source]
Bases:
LowLevelILInstruction
,BinaryOperation
LowLevelILBinaryBase(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property left: LowLevelILInstruction
- property right: LowLevelILInstruction
- class LowLevelILBoolToInt[source]
Bases:
LowLevelILInstruction
LowLevelILBoolToInt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILBp[source]
Bases:
LowLevelILInstruction
,Terminal
LowLevelILBp(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILCall[source]
Bases:
LowLevelILInstruction
,Localcall
LowLevelILCall(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- class LowLevelILCallOutputSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILCallOutputSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: List[SSARegister]
- property dest_memory: int
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- class LowLevelILCallParam[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILCallParam(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: List[LowLevelILInstruction]
- class LowLevelILCallSsa[source]
Bases:
LowLevelILInstruction
,Localcall
,SSA
LowLevelILCallSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property output: List[SSARegister]
- property param: LowLevelILCallParam
- property params: List[LowLevelILInstruction]
- property stack: LowLevelILInstruction
- class LowLevelILCallStackAdjust[source]
Bases:
LowLevelILInstruction
,Localcall
LowLevelILCallStackAdjust(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property stack_adjustment: int
- class LowLevelILCallStackSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILCallStackSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: SSARegister
- property src_memory: int
- class LowLevelILCarryBase[source]
Bases:
LowLevelILInstruction
,Carry
LowLevelILCarryBase(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property carry: LowLevelILInstruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property left: LowLevelILInstruction
- property right: LowLevelILInstruction
- class LowLevelILCeil[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILCeil(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILCmpE[source]
Bases:
LowLevelILComparisonBase
LowLevelILCmpE(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILCmpNe[source]
Bases:
LowLevelILComparisonBase
LowLevelILCmpNe(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILCmpSge[source]
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSge(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILCmpSgt[source]
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSgt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILCmpSle[source]
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSle(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILCmpSlt[source]
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSlt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILCmpUge[source]
Bases:
LowLevelILComparisonBase
LowLevelILCmpUge(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILCmpUgt[source]
Bases:
LowLevelILComparisonBase
LowLevelILCmpUgt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILCmpUle[source]
Bases:
LowLevelILComparisonBase
LowLevelILCmpUle(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILCmpUlt[source]
Bases:
LowLevelILComparisonBase
LowLevelILCmpUlt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILComparisonBase[source]
Bases:
LowLevelILBinaryBase
,Comparison
LowLevelILComparisonBase(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILConst[source]
Bases:
LowLevelILConstantBase
LowLevelILConst(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILConstPtr[source]
Bases:
LowLevelILConstantBase
LowLevelILConstPtr(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILConstantBase[source]
Bases:
LowLevelILInstruction
,Constant
LowLevelILConstantBase(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property constant: int
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- class LowLevelILDivs[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
,Signed
LowLevelILDivs(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILDivsDp[source]
Bases:
LowLevelILBinaryBase
,DoublePrecision
,Signed
LowLevelILDivsDp(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILDivu[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILDivu(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILDivuDp[source]
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILDivuDp(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILExpr[source]
Bases:
object
class LowLevelILExpr
hold the index of IL Expressions.Note
Deprecated. Use ExpressionIndex instead
- __init__(index: ExpressionIndex)[source]
- Parameters:
index (ExpressionIndex) –
- property index: ExpressionIndex
- class LowLevelILExternPtr[source]
Bases:
LowLevelILConstantBase
LowLevelILExternPtr(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property constant: int
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property offset: int
- class LowLevelILFabs[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFabs(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILFadd[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFadd(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILFcmpE[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpE(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILFcmpGe[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpGe(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILFcmpGt[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpGt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILFcmpLe[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpLe(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILFcmpLt[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpLt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILFcmpNe[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpNe(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILFcmpO[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpO(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILFcmpUo[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpUo(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILFdiv[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFdiv(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILFlag[source]
Bases:
LowLevelILInstruction
LowLevelILFlag(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: ILFlag
- class LowLevelILFlagBit[source]
Bases:
LowLevelILInstruction
LowLevelILFlagBit(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property bit: int
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: ILFlag
- class LowLevelILFlagBitSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILFlagBitSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property bit: int
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: SSAFlag
- class LowLevelILFlagCond[source]
Bases:
LowLevelILInstruction
LowLevelILFlagCond(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property condition: LowLevelILFlagCondition
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property semantic_class: ILSemanticFlagClass | None
- class LowLevelILFlagGroup[source]
Bases:
LowLevelILInstruction
LowLevelILFlagGroup(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property semantic_group: ILSemanticFlagGroup
- class LowLevelILFlagPhi[source]
Bases:
LowLevelILInstruction
,Phi
LowLevelILFlagPhi(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: SSAFlag
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- class LowLevelILFlagSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILFlagSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: SSAFlag
- class LowLevelILFloatConst[source]
Bases:
LowLevelILConstantBase
,FloatingPoint
LowLevelILFloatConst(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- class LowLevelILFloatConv[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFloatConv(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILFloatToInt[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFloatToInt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILFloor[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFloor(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILFmul[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFmul(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILFneg[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFneg(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILForceVer[source]
Bases:
LowLevelILInstruction
LowLevelILForceVer(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: ILRegister
- class LowLevelILForceVerSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILForceVerSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: SSARegister
- property src: SSARegister
- class LowLevelILFsqrt[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFsqrt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILFsub[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFsub(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILFtrunc[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFtrunc(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILFunction[source]
Bases:
object
class LowLevelILFunction
contains the list of ExpressionIndex objects that make up a function. ExpressionIndex objects can be added to the LowLevelILFunction by callingappend
and passing the result of the various class methods which return ExpressionIndex objects.LowLevelILFlagCondition values used as parameters in the
flag_condition
method.LowLevelILFlagCondition
Operator
Description
LLFC_E
==
Equal
LLFC_NE
!=
Not equal
LLFC_SLT
s<
Signed less than
LLFC_ULT
u<
Unsigned less than
LLFC_SLE
s<=
Signed less than or equal
LLFC_ULE
u<=
Unsigned less than or equal
LLFC_SGE
s>=
Signed greater than or equal
LLFC_UGE
u>=
Unsigned greater than or equal
LLFC_SGT
s>
Signed greater than
LLFC_UGT
u>
Unsigned greater than
LLFC_NEG
Negative
LLFC_POS
Positive
LLFC_O
overflow
Overflow
LLFC_NO
!overflow
No overflow
- __init__(arch: Architecture | None = None, handle: BNLowLevelILFunction | None = None, source_func: Function | None = None)[source]
- Parameters:
arch (Architecture | None) –
handle (BNLowLevelILFunction | None) –
source_func (Function | None) –
- add(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
add
adds expressiona
to expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
add.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- add_carry(size: int, a: ExpressionIndex, b: ExpressionIndex, carry: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
add_carry
adds with carry expressiona
to expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
carry (ExpressionIndex) – Carry flag expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
adc.<size>{<flags>}(a, b, carry)
- Return type:
ExpressionIndex
- add_index_list(indices: List[int]) ExpressionIndex [source]
add_index_list
returns an index list expression for the given list of integers.- Parameters:
indices (List(int)) – list of numbers
- Returns:
an operand list expression
- Return type:
ExpressionIndex
- add_label_for_address(arch: Architecture, addr: int) None [source]
add_label_for_address
adds a low-level IL label for the given architecturearch
at the given virtual addressaddr
- Parameters:
arch (Architecture) – Architecture to add labels for
addr (int) – the IL address to add a label at
- Return type:
None
- add_label_map(labels: Dict[int, LowLevelILLabel], loc: ILSourceLocation | None = None) ExpressionIndex [source]
add_label_map
returns a label list expression for the given list of LowLevelILLabel objects.- Parameters:
labels (dict(int, LowLevelILLabel)) – the list of LowLevelILLabel to get a label list expression from
loc (ILSourceLocation) – location of returned expression
- Returns:
the label list expression
- Return type:
ExpressionIndex
- add_operand_list(operands: List[ExpressionIndex]) ExpressionIndex [source]
add_operand_list
returns an operand list expression for the given list of integer operands.- Parameters:
operands (List(Union[ExpressionIndex, ExpressionIndex])) – list of operand numbers
- Returns:
an operand list expression
- Return type:
ExpressionIndex
- and_expr(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
and_expr
bitwise and’s expressiona
and expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
and.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- append(expr: ExpressionIndex) InstructionIndex [source]
append
adds the ExpressionIndexexpr
to the current LowLevelILFunction.- Parameters:
expr (ExpressionIndex) – the ExpressionIndex to add to the current LowLevelILFunction
- Returns:
Index of added instruction in the current function
- Return type:
- arith_shift_right(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
arith_shift_right
shifts arithmetic right expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
asr.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- assert_expr(size: int, src: architecture.RegisterType, constraint: PossibleValueSet, loc: ILSourceLocation | None = None) ExpressionIndex [source]
assert_expr
assertconstraint
is the value of the given registersrc
. Used when setting user variable values.- Parameters:
size (int) – size of value in the constraint
src (RegisterType) – register to constrain
constraint (PossibleValueSet) – asserted value of register
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
ASSERT(reg, constraint)
- Return type:
ExpressionIndex
- bool_to_int(size: int, a: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
bool_to_int
returns an expression of sizesize
converting the boolean expressiona
to an integer- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – boolean expression to be converted
loc (ILSourceLocation) – location of returned expression
- Returns:
the converted integer expression.
- Return type:
ExpressionIndex
- breakpoint(loc: ILSourceLocation | None = None) ExpressionIndex [source]
breakpoint
returns a processor breakpoint expression.- Parameters:
loc (ILSourceLocation) – location of returned expression
- Returns:
a breakpoint expression.
- Return type:
ExpressionIndex
- cache_possible_value_set(pvs: PossibleValueSet) int [source]
Cache a PossibleValueSet in the IL function, returning its index for use in an expression operand :param pvs: PossibleValueSet to cache :return: Index of the PossibleValueSet in the cache
- Parameters:
pvs (PossibleValueSet) –
- Return type:
- call(dest: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
call
returns an expression which first pushes the address of the next instruction onto the stack then jumps (branches) to the expressiondest
- Parameters:
dest (ExpressionIndex) – the expression to call
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
call(dest)
- Return type:
ExpressionIndex
- call_stack_adjust(dest: ExpressionIndex, stack_adjust: int, reg_stack_adjustments: Dict[architecture.RegisterStackType, int] | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
call_stack_adjust
returns an expression which first pushes the address of the next instruction onto the stack then jumps (branches) to the expressiondest
. After the function exits,stack_adjust
is added to the stack pointer register.- Parameters:
dest (ExpressionIndex) – the expression to call
loc (ILSourceLocation) – location of returned expression
stack_adjust (int) –
reg_stack_adjustments (Dict[architecture.RegisterStackType, int] | None) –
- Returns:
The expression
call(dest), stack += stack_adjust
- Return type:
ExpressionIndex
- ceil(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
ceil
rounds a floating point value to an integer towards positive infinity- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to round up
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
roundint.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- compare_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
compare_equal
returns comparison expression of sizesize
checking if expressiona
is equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_not_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
compare_not_equal
returns comparison expression of sizesize
checking if expressiona
is not equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_signed_greater_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
compare_signed_greater_equal
returns comparison expression of sizesize
checking if expressiona
is signed greater than or equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_signed_greater_than(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
compare_signed_greater_than
returns comparison expression of sizesize
checking if expressiona
is signed greater than or equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_signed_less_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
compare_signed_less_equal
returns comparison expression of sizesize
checking if expressiona
is signed less than or equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_signed_less_than(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
compare_signed_less_than
returns comparison expression of sizesize
checking if expressiona
is signed less than expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_unsigned_greater_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
compare_unsigned_greater_equal
returns comparison expression of sizesize
checking if expressiona
is unsigned greater than or equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_unsigned_greater_than(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
compare_unsigned_greater_than
returns comparison expression of sizesize
checking if expressiona
is unsigned greater than or equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_unsigned_less_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
compare_unsigned_less_equal
returns comparison expression of sizesize
checking if expressiona
is unsigned less than or equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_unsigned_less_than(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
compare_unsigned_less_than
returns comparison expression of sizesize
checking if expressiona
is unsigned less than expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- const(size: int, value: int, loc: ILSourceLocation | None = None) ExpressionIndex [source]
const
returns an expression for the constant integervalue
with sizesize
- Parameters:
size (int) – the size of the constant in bytes
value (int) – integer value of the constant
loc (ILSourceLocation) – location of returned expression
- Returns:
A constant expression of given value and size
- Return type:
ExpressionIndex
- const_pointer(size: int, value: int, loc: ILSourceLocation | None = None) ExpressionIndex [source]
const_pointer
returns an expression for the constant pointervalue
with sizesize
- Parameters:
size (int) – the size of the pointer in bytes
value (int) – address referenced by pointer
loc (ILSourceLocation) – location of returned expression
- Returns:
A constant expression of given value and size
- Return type:
ExpressionIndex
- copy_expr(original: LowLevelILInstruction) ExpressionIndex [source]
copy_expr
adds an expression to the function which is equivalent to the given expressionWarning
This function should ONLY be called as a part of a lifter or workflow. It will otherwise not do anything useful as analysis will not be running.
- Parameters:
original (LowLevelILInstruction) – the original IL Instruction you want to copy
- Returns:
The index of the newly copied expression
- Return type:
ExpressionIndex
- copy_expr_to(expr: LowLevelILInstruction, dest: LowLevelILFunction, sub_expr_handler: Callable[[LowLevelILInstruction], ExpressionIndex] | None = None) ExpressionIndex [source]
copy_expr_to
deep copies an expression from this function into a target function If provided, the functionsub_expr_handler
will be called on every copied sub-expressionWarning
This function should ONLY be called as a part of a lifter or workflow. It will otherwise not do anything useful as analysis will not be running.
- Parameters:
expr (LowLevelILInstruction) – Expression in this function to copy
dest (LowLevelILFunction) – Function to copy the expression to
sub_expr_handler (Callable[[LowLevelILInstruction], ExpressionIndex] | None) – Optional function to call on every copied sub-expression
- Returns:
Index of the copied expression in the target function
- Return type:
ExpressionIndex
- create_graph(settings: DisassemblySettings | None = None) CoreFlowGraph [source]
- Parameters:
settings (DisassemblySettings | None) –
- Return type:
- create_graph_immediate(settings: DisassemblySettings | None = None) CoreFlowGraph [source]
- Parameters:
settings (DisassemblySettings | None) –
- Return type:
- div_double_prec_signed(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
div_double_prec_signed
signed double precision divide using expressiona
as a single double precision register by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
divs.dp.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- div_double_prec_unsigned(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
div_double_prec_unsigned
unsigned double precision divide using expressiona
as a single double precision register by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
divu.dp.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- div_signed(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
div_signed
signed divide expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
divs.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- div_unsigned(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
div_unsigned
unsigned divide expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
divu.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- expr(operation, a: ExpressionIndex = 0, b: ExpressionIndex = 0, c: ExpressionIndex = 0, d: ExpressionIndex = 0, size: int = 0, flags: architecture.FlagWriteTypeName | architecture.FlagType | architecture.FlagIndex | int | None = None, source_location: ILSourceLocation | None = None) ExpressionIndex [source]
- Parameters:
a (ExpressionIndex) –
b (ExpressionIndex) –
c (ExpressionIndex) –
d (ExpressionIndex) –
size (int) –
flags (architecture.FlagWriteTypeName | architecture.FlagType | architecture.FlagIndex | int | None) –
source_location (ILSourceLocation | None) –
- Return type:
ExpressionIndex
- extern_pointer(size: int, value: int, offset: int, loc: ILSourceLocation | None = None) ExpressionIndex [source]
extern_pointer
returns an expression for the constant external pointervalue
with sizesize
at offsetoffset
- Parameters:
size (int) – the size of the pointer in bytes
value (int) – address referenced by pointer
offset (int) – offset into external pointer
loc (ILSourceLocation) – location of returned expression
- Returns:
A constant expression of given value and size
- Return type:
ExpressionIndex
- finalize() None [source]
finalize
ends the function and computes the list of basic blocks.- Return type:
None
- flag(flag: architecture.FlagType, loc: ILSourceLocation | None = None) ExpressionIndex [source]
flag
returns a flag expression for the given flag name.- Parameters:
flag (architecture.FlagType) – flag expression to retrieve
loc (ILSourceLocation) – location of returned expression
- Returns:
A flag expression of given flag name
- Return type:
ExpressionIndex
- flag_bit(size: int, flag: architecture.FlagType, bit: int, loc: ILSourceLocation | None = None) ExpressionIndex [source]
flag_bit
sets the flag namedflag
and sizesize
to the constant integer valuebit
- Parameters:
size (int) – the size of the flag
flag (str) – flag value
bit (int) – integer value to set the bit to
loc (ILSourceLocation) – location of returned expression
- Returns:
A constant expression of given value and size
FLAG.flag = bit
- Return type:
ExpressionIndex
- flag_condition(cond: str | LowLevelILFlagCondition | int, sem_class: architecture.SemanticClassType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
flag_condition
returns a flag_condition expression for the given LowLevelILFlagCondition- Parameters:
cond (LowLevelILFlagCondition) – Flag condition expression to retrieve
sem_class (str) – Optional semantic flag class
loc (ILSourceLocation) – location of returned expression
- Returns:
A flag_condition expression
- Return type:
ExpressionIndex
- flag_group(sem_group: SemanticGroupName, loc: ILSourceLocation | None = None) ExpressionIndex [source]
flag_group
returns a flag_group expression for the given semantic flag group- Parameters:
sem_group (SemanticGroupName) – Semantic flag group to access
loc (ILSourceLocation) – location of returned expression
- Returns:
A flag_group expression
- Return type:
ExpressionIndex
- float_abs(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_abs
returns absolute value of floating point expressionvalue
of sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to get the absolute value of
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
fabs.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- float_add(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_add
adds floating point expressiona
to expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
fadd.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- float_compare_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_compare_equal
returns floating point comparison expression of sizesize
checking if expressiona
is equal to expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
a f== b
- Return type:
ExpressionIndex
- float_compare_greater_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_compare_greater_equal
returns floating point comparison expression of sizesize
checking if expressiona
is greater than or equal to expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
a f>= b
- Return type:
ExpressionIndex
- float_compare_greater_than(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_compare_greater_than
returns floating point comparison expression of sizesize
checking if expressiona
is greater than expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
a f> b
- Return type:
ExpressionIndex
- float_compare_less_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_compare_less_equal
returns floating point comparison expression of sizesize
checking if expressiona
is less than or equal to expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
a f<= b
- Return type:
ExpressionIndex
- float_compare_less_than(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_compare_less_than
returns floating point comparison expression of sizesize
checking if expressiona
is less than expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
a f< b
- Return type:
ExpressionIndex
- float_compare_not_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_compare_not_equal
returns floating point comparison expression of sizesize
checking if expressiona
is not equal to expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
a f!= b
- Return type:
ExpressionIndex
- float_compare_ordered(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_compare_ordered
returns floating point comparison expression of sizesize
checking if expressiona
is ordered relative to expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
is_ordered(a, b)
- Return type:
ExpressionIndex
- float_compare_unordered(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_compare_unordered
returns floating point comparison expression of sizesize
checking if expressiona
is unordered relative to expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
is_unordered(a, b)
- Return type:
ExpressionIndex
- float_const_double(value: float, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_const_double
returns an expression for the double precision floating point valuevalue
- Parameters:
value (float) – float value for the constant
loc (ILSourceLocation) – location of returned expression
- Returns:
A constant expression of given value and size
- Return type:
ExpressionIndex
- float_const_raw(size: int, value: int, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_const_raw
returns an expression for the constant raw binary floating point valuevalue
with sizesize
- Parameters:
size (int) – the size of the constant in bytes
value (int) – integer value for the raw binary representation of the constant
loc (ILSourceLocation) – location of returned expression
- Returns:
A constant expression of given value and size
- Return type:
ExpressionIndex
- float_const_single(value: float, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_const_single
returns an expression for the single precision floating point valuevalue
- Parameters:
value (float) – float value for the constant
loc (ILSourceLocation) – location of returned expression
- Returns:
A constant expression of given value and size
- Return type:
ExpressionIndex
- float_convert(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
int_to_float
converts floating point value of expressionvalue
to sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to negate
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
fconvert.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- float_div(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_div
divides floating point expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
fdiv.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- float_mult(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_mult
multiplies floating point expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
fmul.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- float_neg(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_neg
returns sign negation of floating point expressionvalue
of sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to negate
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
fneg.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- float_sqrt(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_sqrt
returns square root of floating point expressionvalue
of sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to calculate the square root of
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
sqrt.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- float_sub(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_sub
subtracts floating point expressionb
from expressiona
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
fsub.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- float_to_int(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_to_int
returns integer value of floating point expressionvalue
of sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to convert to an int
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
int.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- float_trunc(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
float_trunc
rounds a floating point value to an integer towards zero- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to truncate
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
roundint.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- floor(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
floor
rounds a floating point value to an integer towards negative infinity- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to round down
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
roundint.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- force_ver(size: int, dest: architecture.RegisterType, loc: ILSourceLocation | None = None) ExpressionIndex [source]
force_ver
creates a new version of the registerdest
Effectively, this is like saying r0#2 = r0#1 which MLIL can then use as a new variable definition site.- Parameters:
size (int) – size of the register
dest (RegisterType) – the register to force a new version of
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
FORCE_VER(reg)
- Return type:
ExpressionIndex
- generate_ssa_form() None [source]
generate_ssa_form
generate SSA form given the current LLIL- Return type:
None
- get_basic_block_at(index: int) BasicBlock | None [source]
get_basic_block_at
returns the BasicBlock at the given LLIL instructionindex
.- Parameters:
index (int) – Index of the LLIL instruction of the BasicBlock to retrieve.
- Example:
>>> current_il_function.get_basic_block_at(current_il_index) <llil block: x86@19-26>
- Return type:
BasicBlock | None
- get_expr(index: ExpressionIndex) LowLevelILInstruction | None [source]
get_expr
retrieves the IL expression at a given expression index in the function.Warning
Not all IL expressions are valid, even if their index is within the bounds of the function, they might not be used by the function and might not contain properly structured data.
- Parameters:
index (ExpressionIndex) – Index of desired expression in function
- Returns:
A LowLevelILInstruction object for the expression, if it exists. Otherwise, None
- Return type:
LowLevelILInstruction | None
- get_expr_count() int [source]
get_expr_count
gives a the total number of expressions in this IL functionYou can use this to enumerate all expressions in conjunction with
get_expr
Warning
Not all IL expressions are valid, even if their index is within the returned value from this, they might not be used by the function and might not contain properly structured data.
- Returns:
The number of expressions in the function
- Return type:
- get_expr_index_for_instruction(instr: InstructionIndex) ExpressionIndex [source]
- Parameters:
instr (InstructionIndex) –
- Return type:
ExpressionIndex
- get_high_level_il_expr_index(expr: ExpressionIndex) ExpressionIndex | None [source]
- Parameters:
expr (ExpressionIndex) –
- Return type:
ExpressionIndex | None
- get_high_level_il_instruction_index(instr: InstructionIndex) InstructionIndex | None [source]
- Parameters:
instr (InstructionIndex) –
- Return type:
InstructionIndex | None
- get_instruction_index_for_expr(expr: ExpressionIndex) InstructionIndex | None [source]
- Parameters:
expr (ExpressionIndex) –
- Return type:
InstructionIndex | None
- get_instruction_start(addr: int, arch: Architecture | None = None) InstructionIndex | None [source]
- Parameters:
addr (int) –
arch (Architecture | None) –
- Return type:
InstructionIndex | None
- get_label_for_address(arch: Architecture, addr: int) LowLevelILLabel | None [source]
get_label_for_address
returns the LowLevelILLabel for the given Architecturearch
and IL addressaddr
.- Parameters:
arch (Architecture) –
addr (int) – IL Address label to retrieve
- Returns:
the LowLevelILLabel for the given IL address
- Return type:
- get_label_for_source_instruction(i: InstructionIndex) LowLevelILLabel | None [source]
Get the LowLevelILLabel for a given source instruction. The returned label is to an internal object with the same lifetime as the containing LowLevelILFunction.
- Parameters:
i (InstructionIndex) – The source instruction index
- Returns:
The LowLevelILLabel for the source instruction
- Return type:
LowLevelILLabel | None
- get_mapped_medium_level_il_expr_index(expr: ExpressionIndex) ExpressionIndex | None [source]
- Parameters:
expr (ExpressionIndex) –
- Return type:
ExpressionIndex | None
- get_mapped_medium_level_il_instruction_index(instr: InstructionIndex) InstructionIndex | None [source]
- Parameters:
instr (InstructionIndex) –
- Return type:
InstructionIndex | None
- get_medium_level_il_expr_index(expr: ExpressionIndex) ExpressionIndex | None [source]
- Parameters:
expr (ExpressionIndex) –
- Return type:
ExpressionIndex | None
- get_medium_level_il_expr_indexes(expr: ExpressionIndex) List[ExpressionIndex] [source]
- Parameters:
expr (ExpressionIndex) –
- Return type:
List[ExpressionIndex]
- get_medium_level_il_instruction_index(instr: InstructionIndex) InstructionIndex | None [source]
- Parameters:
instr (InstructionIndex) –
- Return type:
InstructionIndex | None
- get_non_ssa_instruction_index(instr: InstructionIndex) InstructionIndex [source]
- Parameters:
instr (InstructionIndex) –
- Return type:
InstructionIndex
- get_ssa_flag_definition(flag_ssa: SSAFlag) LowLevelILInstruction | None [source]
- Parameters:
flag_ssa (SSAFlag) –
- Return type:
LowLevelILInstruction | None
- get_ssa_flag_uses(flag_ssa: SSAFlag) List[LowLevelILInstruction] [source]
- Parameters:
flag_ssa (SSAFlag) –
- Return type:
- get_ssa_flag_value(flag_ssa: SSAFlag) RegisterValue [source]
- Parameters:
flag_ssa (SSAFlag) –
- Return type:
- get_ssa_instruction_index(instr: InstructionIndex) InstructionIndex [source]
- Parameters:
instr (InstructionIndex) –
- Return type:
InstructionIndex
- get_ssa_memory_definition(index: int) LowLevelILInstruction | None [source]
- Parameters:
index (int) –
- Return type:
LowLevelILInstruction | None
- get_ssa_memory_uses(index: int) List[LowLevelILInstruction] [source]
- Parameters:
index (int) –
- Return type:
- get_ssa_reg_definition(reg_ssa: SSARegister) LowLevelILInstruction | None [source]
- Parameters:
reg_ssa (SSARegister) –
- Return type:
LowLevelILInstruction | None
- get_ssa_reg_uses(reg_ssa: SSARegister) List[LowLevelILInstruction] [source]
- Parameters:
reg_ssa (SSARegister) –
- Return type:
- get_ssa_reg_value(reg_ssa: SSARegister) RegisterValue [source]
- Parameters:
reg_ssa (SSARegister) –
- Return type:
- goto(label: LowLevelILLabel, loc: ILSourceLocation | None = None) ExpressionIndex [source]
goto
returns a goto expression which jumps to the provided LowLevelILLabel.- Parameters:
label (LowLevelILLabel) – Label to jump to
loc (ILSourceLocation) – location of returned expression
- Returns:
the ExpressionIndex that jumps to the provided label
- Return type:
ExpressionIndex
- if_expr(operand: ExpressionIndex, t: LowLevelILLabel, f: LowLevelILLabel, loc: ILSourceLocation | None = None) ExpressionIndex [source]
if_expr
returns theif
expression which depending on conditionoperand
jumps to the LowLevelILLabelt
when the condition expressionoperand
is non-zero andf
when it’s zero.- Parameters:
operand (ExpressionIndex) – comparison expression to evaluate.
t (LowLevelILLabel) – Label for the true branch
f (LowLevelILLabel) – Label for the false branch
loc (ILSourceLocation) – location of returned expression
- Returns:
the ExpressionIndex for the if expression
- Return type:
ExpressionIndex
- int_to_float(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
int_to_float
returns floating point value of integer expressionvalue
of sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to convert to a float
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
float.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- intrinsic(outputs: List[str | ILRegister | int | ILFlag | RegisterInfo], intrinsic: architecture.IntrinsicType, params: List[ExpressionIndex], flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None)[source]
intrinsic
return an intrinsic expression.- Parameters:
loc (ILSourceLocation) – location of returned expression
outputs (List[str | ILRegister | int | ILFlag | RegisterInfo]) –
intrinsic (architecture.IntrinsicType) –
params (List[ExpressionIndex]) –
flags (architecture.FlagType | None) –
- Returns:
an intrinsic expression.
- Return type:
ExpressionIndex
- jump(dest: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
jump
returns an expression which jumps (branches) to the expressiondest
- Parameters:
dest (ExpressionIndex) – the expression to jump to
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
jump(dest)
- Return type:
ExpressionIndex
- jump_to(dest: ExpressionIndex, targets: Dict[int, LowLevelILLabel], loc: ILSourceLocation | None = None) ExpressionIndex [source]
jump_to
returns an expression which jumps (branches) various targets intargets
choosing the target intargets
based on the value calculated bydest
- Parameters:
dest (ExpressionIndex) – the expression choosing which jump target to use
targets (Dict[int, LowLevelILLabel]) – the list of targets for jump locations
loc (ILSourceLocation) – location of returned expression
targets –
- Returns:
The expression
jump(dest)
- Return type:
ExpressionIndex
- load(size: int, addr: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
load
Readssize
bytes from the expressionaddr
- Parameters:
size (int) – number of bytes to read
addr (ExpressionIndex) – the expression to read memory from
flags (FlagType) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
[addr].size
- Return type:
ExpressionIndex
- logical_shift_right(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
logical_shift_right
shifts logically right expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
lsr.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- low_part(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
low_part
truncatesvalue
tosize
bytes- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to truncate
loc (ILSourceLocation) – location of returned expression
flags (architecture.FlagType | None) –
- Returns:
The expression
(value).<size>
- Return type:
ExpressionIndex
- mark_label(label: LowLevelILLabel) None [source]
mark_label
assigns a LowLevelILLabel to the current IL address.- Parameters:
label (LowLevelILLabel) –
- Return type:
None
- mod_double_prec_signed(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
mod_double_prec_signed
signed double precision modulus using expressiona
as a single double precision register by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
mods.dp.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- mod_double_prec_unsigned(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
mod_double_prec_unsigned
unsigned double precision modulus using expressiona
as a single double precision register by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
modu.dp.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- mod_signed(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
mod_signed
signed modulus expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
mods.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- mod_unsigned(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
mod_unsigned
unsigned modulus expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
modu.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- mult(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
mult
multiplies expressiona
by expressionb
potentially setting flagsflags
and returning an expression. Both the operands and return value aresize
bytes as the product’s upper half is discarded.- Parameters:
size (int) – the size of the result and input operands, in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
mul.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- mult_double_prec_signed(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
mult_double_prec_signed
multiplies signed with double (2*size bytes) precision expressiona
by expressionb
, eachsize
bytes and potentially setting flagsflags
and returning an expression of2*size
bytes.Note
The output expression is
2*size
bytes in size, but will be rendered asmuls.dp.<size>
.- Parameters:
size (int) – the size of the input operands, in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
muls.dp.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- mult_double_prec_unsigned(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
mult_double_prec_unsigned
multiplies unsigned with double (2*size bytes) precision expressiona
by expressionb
, eachsize
bytes and potentially setting flagsflags
and returning an expression of2*size
bytes.Note
The output expression is
2*size
bytes in size, but will be rendered asmulu.dp.<size>
.- Parameters:
size (int) – the size of the input operands, in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
mulu.dp.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- neg_expr(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
neg_expr
two’s complement sign negation of expressionvalue
of sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to negate
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
neg.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- no_ret(loc: ILSourceLocation | None = None) ExpressionIndex [source]
no_ret
returns an expression that halts disassembly- Parameters:
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
noreturn
- Return type:
ExpressionIndex
- nop(loc: ILSourceLocation | None = None) ExpressionIndex [source]
nop
no operation, this instruction does nothing- Parameters:
loc (ILSourceLocation) – location of returned expression
- Returns:
The no operation expression
- Return type:
ExpressionIndex
- not_expr(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
not_expr
bitwise inverse of expressionvalue
of sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to bitwise invert
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
not.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- operand(n: int, expr: ExpressionIndex) ExpressionIndex [source]
operand
sets the operand number of the expressionexpr
and passes backexpr
without modification.- Parameters:
n (int) –
expr (ExpressionIndex) –
- Returns:
returns the expression
expr
unmodified- Return type:
ExpressionIndex
- or_expr(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
or_expr
bitwise or’s expressiona
and expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
or.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- pop(size: int, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
pop
readssize
bytes from the stack, adjusting the stack bysize
.- Parameters:
size (int) – number of bytes to read from the stack
flags (FlagType) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
pop
- Return type:
ExpressionIndex
- prepare_to_copy_block(src: LowLevelILBasicBlock)[source]
prepare_to_copy_block
sets up state when copying a function in preparation of copying the instructions from the blocksrc
- Parameters:
src (LowLevelILBasicBlock) – block about to be copied from
- prepare_to_copy_function(src: LowLevelILFunction)[source]
prepare_to_copy_function
sets up state in this LLIL function in preparation of copying instructions fromsrc
- Parameters:
src (LowLevelILFunction) – function about to be copied from
- push(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
push
writessize
bytes from expressionvalue
to the stack, adjusting the stack bysize
.- Parameters:
size (int) – number of bytes to write and adjust the stack by
value (ExpressionIndex) – the expression to write
flags (FlagType) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression push(value)
- Return type:
ExpressionIndex
- reg(size: int, reg: architecture.RegisterType, loc: ILSourceLocation | None = None) ExpressionIndex [source]
reg
returns a register of sizesize
with namereg
- Parameters:
size (int) – the size of the register in bytes
reg (str) – the name of the register
loc (ILSourceLocation) – location of returned expression
- Returns:
A register expression for the given string
- Return type:
ExpressionIndex
- reg_split(size: int, hi: architecture.RegisterType, lo: architecture.RegisterType, loc: ILSourceLocation | None = None) ExpressionIndex [source]
reg_split
combines registers of sizesize
with nameshi
andlo
- Parameters:
size (int) – the size of the register in bytes
hi (str) – register holding high part of value
lo (str) – register holding low part of value
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
hi:lo
- Return type:
ExpressionIndex
- reg_stack_free_reg(reg: architecture.RegisterType, loc: ILSourceLocation | None = None) ExpressionIndex [source]
reg_stack_free_reg
clears the given registerreg
from its register stack without affecting the register at the top of the register stack.- Parameters:
reg (str) – the register being marked free
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
__free_slot(reg)
- Return type:
ExpressionIndex
- reg_stack_free_top_relative(reg_stack: architecture.RegisterStackType, entry: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
reg_stack_free_top_relative
clears an entry in the register stackreg_stack
at a top-relative position specified by the value ofentry
.- Parameters:
reg_stack (str) – the register stack name
entry (ExpressionIndex) – expression to calculate the top-relative position
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
__free_slot(reg_stack[entry])
- Return type:
ExpressionIndex
- reg_stack_pop(size: int, reg_stack: architecture.RegisterStackType, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
reg_stack_pop
returns the top entry of sizesize
in register stack with namereg_stack
, and removes the entry from the stack- Parameters:
size (int) – the size of the register in bytes
reg_stack (str) – the name of the register stack
flags (FlagType) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
reg_stack.pop
- Return type:
ExpressionIndex
- reg_stack_push(size: int, reg_stack: architecture.RegisterStackType, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
reg_stack_push
pushes the expressionvalue
of sizesize
onto the top of the register stackreg_stack
- Parameters:
size (int) – size of the register parameter in bytes
reg_stack (str) – the register stack name
value (ExpressionIndex) – an expression to push
flags (str) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
reg_stack.push(value)
- Return type:
ExpressionIndex
- reg_stack_top_relative(size: int, reg_stack: architecture.RegisterStackType, entry: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
reg_stack_top_relative
returns a register stack entry of sizesize
at top-relative locationentry
in register stack with namereg_stack
- Parameters:
size (int) – the size of the register in bytes
reg_stack (str) – the name of the register stack
entry (ExpressionIndex) – an expression for which stack entry to fetch
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
reg_stack[entry]
- Return type:
ExpressionIndex
- replace_expr(original: LowLevelILInstruction | ExpressionIndex | InstructionIndex, new: LowLevelILInstruction | ExpressionIndex | InstructionIndex) None [source]
replace_expr
allows modification of expressions but ONLY during lifting.Warning
This function should ONLY be called as a part of a lifter or workflow. It will otherwise not do anything useful as analysis will not be running.
- Parameters:
original (ExpressionIndex) – the ExpressionIndex to replace (may also be an expression index)
new (ExpressionIndex) – the ExpressionIndex to add to the current LowLevelILFunction (may also be an expression index)
- Return type:
None
- ret(dest: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
ret
returns an expression which jumps (branches) to the expressiondest
.ret
is a special alias for jump that makes the disassembler stop disassembling.- Parameters:
dest (ExpressionIndex) – the expression to jump to
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
jump(dest)
- Return type:
ExpressionIndex
- rotate_left(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
rotate_left
bitwise rotates left expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
rol.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- rotate_left_carry(size: int, a: ExpressionIndex, b: ExpressionIndex, carry: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
rotate_left_carry
bitwise rotates left with carry expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
carry (ExpressionIndex) – Carry flag expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
rlc.<size>{<flags>}(a, b, carry)
- Return type:
ExpressionIndex
- rotate_right(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
rotate_right
bitwise rotates right expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
ror.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- rotate_right_carry(size: int, a: ExpressionIndex, b: ExpressionIndex, carry: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
rotate_right_carry
bitwise rotates right with carry expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
carry (ExpressionIndex) – Carry flag expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
rrc.<size>{<flags>}(a, b, carry)
- Return type:
ExpressionIndex
- round_to_int(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
round_to_int
rounds a floating point value to the nearest integer- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to round to the nearest integer
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
roundint.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- set_current_address(value: int, arch: Architecture | None = None) None [source]
- Parameters:
value (int) –
arch (Architecture | None) –
- Return type:
None
- set_expr_attributes(expr: LowLevelILInstruction | ExpressionIndex | InstructionIndex, value: Set[ILInstructionAttribute] | List[ILInstructionAttribute])[source]
set_expr_attributes
allows modification of instruction attributes but ONLY during lifting.Warning
This function should ONLY be called as a part of a lifter or workflow. It will otherwise not do anything useful as analysis will not be running.
- Parameters:
expr (ExpressionIndex) – the ExpressionIndex to replace (may also be an expression index)
value (set(ILInstructionAttribute)) – the set of attributes to place on the instruction
- Return type:
None
- set_flag(flag: architecture.FlagType, value: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
set_flag
sets the flagflag
to the ExpressionIndexvalue
- Parameters:
flag (str) – the low register name
value (ExpressionIndex) – an expression to set the flag to
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression FLAG.flag = value
- Return type:
ExpressionIndex
- set_indirect_branches(branches: List[Tuple[Architecture, int]]) None [source]
- Parameters:
branches (List[Tuple[Architecture, int]]) –
- Return type:
None
- set_reg(size: int, reg: architecture.RegisterType, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
set_reg
sets the registerreg
of sizesize
to the expressionvalue
- Parameters:
size (int) – size of the register parameter in bytes
reg (str) – the register name
value (ExpressionIndex) – an expression to set the register to
flags (str) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
reg = value
- Return type:
ExpressionIndex
- set_reg_split(size: int, hi: architecture.RegisterType, lo: architecture.RegisterType, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
set_reg_split
useshi
andlo
as a single extended register settinghi:lo
to the expressionvalue
.- Parameters:
size (int) – size of the register parameter in bytes
hi (str) – the high register name
lo (str) – the low register name
value (ExpressionIndex) – an expression to set the split registers to
flags (str) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
hi:lo = value
- Return type:
ExpressionIndex
- set_reg_stack_top_relative(size: int, reg_stack: architecture.RegisterStackType, entry: ExpressionIndex, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
set_reg_stack_top_relative
sets the top-relative entryentry
of sizesize
in register stackreg_stack
to the expressionvalue
- Parameters:
size (int) – size of the register parameter in bytes
reg_stack (str) – the register stack name
entry (ExpressionIndex) – an expression for which stack entry to set
value (ExpressionIndex) – an expression to set the entry to
flags (str) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
reg_stack[entry] = value
- Return type:
ExpressionIndex
- shift_left(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
shift_left
shifts left expressiona
by expressionb
from expressiona
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
lsl.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- sign_extend(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
sign_extend
two’s complement sign-extends the expression invalue
tosize
bytes- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to sign extend
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
sx.<size>(value)
- Return type:
ExpressionIndex
- store(size: int, addr: ExpressionIndex, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
store
Writessize
bytes to expressionaddr
read from expressionvalue
- Parameters:
size (int) – number of bytes to write
addr (ExpressionIndex) – the expression to write to
value (ExpressionIndex) – the expression to be written
flags (FlagType) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
[addr].size = value
- Return type:
ExpressionIndex
- sub(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
sub
subtracts expressionb
from expressiona
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
sub.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- sub_borrow(size: int, a: ExpressionIndex, b: ExpressionIndex, carry: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
sub_borrow
subtracts with borrow expressionb
from expressiona
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
carry (ExpressionIndex) – Carry flag expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
sbb.<size>{<flags>}(a, b, carry)
- Return type:
ExpressionIndex
- system_call(loc: ILSourceLocation | None = None) ExpressionIndex [source]
system_call
return a system call expression.- Parameters:
loc (ILSourceLocation) – location of returned expression
- Returns:
a system call expression.
- Return type:
ExpressionIndex
- tailcall(dest: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
tailcall
returns an expression which jumps (branches) to the expressiondest
- Parameters:
dest (ExpressionIndex) – the expression to jump to
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
tailcall(dest)
- Return type:
ExpressionIndex
- test_bit(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
test_bit
returns an expression of sizesize
that tells whether expressiona
has its bit with an index of the expressionb
is set- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – an expression to be tested
b (ExpressionIndex) – an expression for the index of the big
loc (ILSourceLocation) – location of returned expression
- Returns:
the result expression.
- Return type:
ExpressionIndex
- translate(expr_handler: Callable[[LowLevelILFunction, LowLevelILBasicBlock, LowLevelILInstruction], ExpressionIndex]) LowLevelILFunction [source]
translate
clones an IL function and modifies its expressions as specified by a givenexpr_handler
, returning the updated IL function.- Parameters:
expr_handler (Callable[[LowLevelILFunction, LowLevelILBasicBlock, LowLevelILInstruction], ExpressionIndex]) –
Function to modify an expression and copy it to the new function. The function should have the following signature:
expr_handler(new_func: LowLevelILFunction, old_block: LowLevelILBasicBlock, old_instr: LowLevelILInstruction) -> ExpressionIndex
- Where:
new_func (LowLevelILFunction): New function to receive translated instructions
old_block (LowLevelILBasicBlock): Original block containing old_instr
old_instr (LowLevelILInstruction): Original instruction
returns (ExpressionIndex): Expression index of newly created instruction in
new_func
- Returns:
Cloned IL function with modifications
- Return type:
- trap(value: int, loc: ILSourceLocation | None = None) ExpressionIndex [source]
trap
returns a processor trap (interrupt) expression of the given integervalue
.- Parameters:
value (int) – trap (interrupt) number
loc (ILSourceLocation) – location of returned expression
- Returns:
a trap expression.
- Return type:
ExpressionIndex
- traverse(cb: Callable[[LowLevelILInstruction, Any], Any], *args: Any, **kwargs: Any) Iterator[Any] [source]
traverse
iterates through all the instructions in the LowLevelILFunction and calls the callback function for each instruction and sub-instruction. See the Developer Docs for more examples.- Parameters:
cb (Callable[[LowLevelILInstruction, Any], Any]) – The callback function to call for each node in the LowLevelILInstruction
args (Any) – Custom user-defined arguments
kwargs (Any) – Custom user-defined keyword arguments
cb –
- Returns:
An iterator of the results of the callback function
- Return type:
Iterator[Any]
- Example:
>>> def find_constants(instr) -> Optional[int]: ... if isinstance(instr, Constant): ... return instr.constant >>> print(list(current_il_function.traverse(find_constants)))
- undefined(loc: ILSourceLocation | None = None) ExpressionIndex [source]
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 (ILSourceLocation) – location of returned expression
- Returns:
the undefined expression.
- Return type:
ExpressionIndex
- unimplemented(loc: ILSourceLocation | None = None) ExpressionIndex [source]
unimplemented
returns the unimplemented expression. This should be used for all instructions which aren’t implemented.- Parameters:
loc (ILSourceLocation) – location of returned expression
- Returns:
the unimplemented expression.
- Return type:
ExpressionIndex
- unimplemented_memory_ref(size: int, addr: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]
unimplemented_memory_ref
a memory reference to expressionaddr
of sizesize
with unimplemented operation.- Parameters:
size (int) – size in bytes of the memory reference
addr (ExpressionIndex) – expression to reference memory
loc (ILSourceLocation) – location of returned expression
- Returns:
the unimplemented memory reference expression.
- Return type:
ExpressionIndex
- visit(cb: Callable[[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str, LowLevelILInstruction | None], bool]) bool [source]
Iterates over all the instructions in the function and calls the callback function for each instruction and each sub-instruction.
- Parameters:
cb (LowLevelILVisitorCallback) – Callback function that takes the name of the operand, the operand, operand type, and parent instruction
- Returns:
True if all instructions were visited, False if the callback function returned False.
- Return type:
Deprecated since version 4.0.4907: Use
LowLevelILFunction.traverse
instead.
- visit_all(cb: Callable[[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str, LowLevelILInstruction | None], bool]) bool [source]
Iterates over all the instructions in the function and calls the callback function for each instruction and their operands.
- Parameters:
cb (LowLevelILVisitorCallback) – Callback function that takes the name of the operand, the operand, operand type, and parent instruction
- Returns:
True if all instructions were visited, False if the callback function returned False.
- Return type:
Deprecated since version 4.0.4907: Use
LowLevelILFunction.traverse
instead.
- visit_operands(cb: Callable[[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str, LowLevelILInstruction | None], bool]) bool [source]
- Iterates over all the instructions in the function and calls the callback function for each operand and
the operands of each sub-instruction.
- Parameters:
cb (LowLevelILVisitorCallback) – Callback function that takes the name of the operand, the operand, operand type, and parent instruction
- Returns:
True if all instructions were visited, False if the callback function returned False.
- Return type:
Deprecated since version 4.0.4907: Use
LowLevelILFunction.traverse
instead.
- xor_expr(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
xor_expr
xor’s expressiona
with expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
xor.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- zero_extend(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]
zero_extend
zero-extends the expression invalue
tosize
bytes- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to zero extend
loc (ILSourceLocation) – location of returned expression
flags (architecture.FlagType | None) –
- Returns:
The expression
zx.<size>(value)
- Return type:
ExpressionIndex
- property arch: Architecture
- property basic_blocks: LowLevelILBasicBlockList
- property current_address: int
Current IL Address (read/write)
- property il_form: FunctionGraphType
- property instructions: Generator[LowLevelILInstruction, None, None]
A generator of llil instructions of the current llil function
- property is_thunk: bool
Returns True if the function starts with a Tailcall (read-only)
- property mapped_medium_level_il: MediumLevelILFunction
Medium level IL with mappings between low level IL and medium level IL. Unused stores are not removed. Typically, this should only be used to answer queries on assembly or low level IL where the query is easier to perform on medium level IL.
- property medium_level_il: MediumLevelILFunction
Medium level IL for this low level IL.
- property mlil: MediumLevelILFunction
- property mmlil: MediumLevelILFunction
- property non_ssa_form: LowLevelILFunction
Low level IL in non-SSA (default) form (read-only)
- property reg_stacks: List[SSARegisterStack]
List of register stacks used in this IL
- property register_stacks: List[SSARegisterStack]
Deprecated, use reg_stacks instead. List of register stacks used in this IL
- property registers: List[SSARegister]
Deprecated, use regs instead. List of registers used in this IL
- property regs: List[SSARegister]
List of registers used in this IL
- property ssa_form: LowLevelILFunction
Low level IL in SSA form (read-only)
- property ssa_reg_stacks: List[SSARegisterStack]
List of all SSA register stacks and versions used in this IL
- property ssa_reg_stacks_without_versions: List[SSARegisterStack]
List of SSA register stacks used in this IL
- property ssa_register_stacks: List[SSARegisterStack]
- property ssa_registers: List[SSARegister]
- property ssa_regs: List[SSARegister]
List of all SSA registers and versions used in this IL
- property ssa_regs_without_versions: List[SSARegister]
List of SSA registers used in this IL
- property ssa_vars: List[SSARegister | SSARegisterStack | SSAFlag]
This is the union LowLevelILFunction.ssa_regs, LowLevelILFunction.ssa_reg_stacks, and LowLevelILFunction.ssa_flags
- property ssa_vars_without_versions: List[SSARegister | SSARegisterStack | SSAFlag]
This is the union LowLevelILFunction.ssa_regs_without_versions, LowLevelILFunction.ssa_reg_stacks_without_versions, and LowLevelILFunction.ssa_flags_without_versions
- property temp_flag_count: int
Number of temporary flags (read-only)
- property temp_reg_count: int
Number of temporary registers (read-only)
- property vars: List[ILRegister | ILRegisterStack | ILFlag]
This is the union LowLevelILFunction.regs, LowLevelILFunction.reg_stacks, and LowLevelILFunction.flags
- property view: BinaryView | None
- class LowLevelILGoto[source]
Bases:
LowLevelILInstruction
,Terminal
LowLevelILGoto(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: InstructionIndex
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- class LowLevelILIf[source]
Bases:
LowLevelILInstruction
,ControlFlow
LowLevelILIf(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property condition: LowLevelILInstruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property false: InstructionIndex
- property true: InstructionIndex
- class LowLevelILInstruction[source]
Bases:
BaseILInstruction
class LowLevelILInstruction
Low Level Intermediate Language Instructions are infinite length tree-based instructions. Tree-based instructions use infix notation with the left hand operand being the destination operand. Infix notation is thus more natural to read than other notations (e.g. x86mov eax, 0
vs. LLILeax = 0
).- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- copy_to(dest: LowLevelILFunction, sub_expr_handler: Callable[[LowLevelILInstruction], ExpressionIndex] | None = None) ExpressionIndex [source]
copy_to
deep copies an expression into a new IL function. If provided, the functionsub_expr_handler
will be called on every copied sub-expressionWarning
This function should ONLY be called as a part of a lifter or workflow. It will otherwise not do anything useful as analysis will not be running.
- Parameters:
dest (LowLevelILFunction) – Function to copy the expression to
sub_expr_handler (Callable[[LowLevelILInstruction], ExpressionIndex] | None) – Optional function to call on every copied sub-expression
- Returns:
Index of the copied expression in the target function
- Return type:
ExpressionIndex
- classmethod create(func: LowLevelILFunction, expr_index: ExpressionIndex, instr_index: InstructionIndex | None = None) LowLevelILInstruction [source]
- Parameters:
func (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr_index (InstructionIndex | None) –
- Return type:
- get_flag_value(flag: architecture.FlagType) RegisterValue [source]
- Parameters:
flag (architecture.FlagType) –
- Return type:
- get_flag_value_after(flag: architecture.FlagType) RegisterValue [source]
- Parameters:
flag (architecture.FlagType) –
- Return type:
- get_possible_flag_values(flag: architecture.FlagType, options: List[DataFlowQueryOption] | None = None) PossibleValueSet [source]
- Parameters:
flag (architecture.FlagType) –
options (List[DataFlowQueryOption] | None) –
- Return type:
- get_possible_flag_values_after(flag: architecture.FlagType, options: List[DataFlowQueryOption] | None = None) PossibleValueSet [source]
- Parameters:
flag (architecture.FlagType) –
options (List[DataFlowQueryOption] | None) –
- Return type:
- get_possible_reg_values(reg: architecture.RegisterType, options: List[DataFlowQueryOption] | None = None) PossibleValueSet [source]
- Parameters:
reg (architecture.RegisterType) –
options (List[DataFlowQueryOption] | None) –
- Return type:
- get_possible_reg_values_after(reg: architecture.RegisterType, options: List[DataFlowQueryOption] | None = None) PossibleValueSet [source]
- Parameters:
reg (architecture.RegisterType) –
options (List[DataFlowQueryOption] | None) –
- Return type:
- get_possible_stack_contents(offset: int, size: int, options: List[DataFlowQueryOption] | None = None) PossibleValueSet [source]
- Parameters:
offset (int) –
size (int) –
options (List[DataFlowQueryOption] | None) –
- Return type:
- get_possible_stack_contents_after(offset: int, size: int, options: List[DataFlowQueryOption] | None = None) PossibleValueSet [source]
- Parameters:
offset (int) –
size (int) –
options (List[DataFlowQueryOption] | None) –
- Return type:
- get_possible_values(options: List[DataFlowQueryOption] | None = None) PossibleValueSet [source]
- Parameters:
options (List[DataFlowQueryOption] | None) –
- Return type:
- get_reg_value(reg: architecture.RegisterType) RegisterValue [source]
- Parameters:
reg (architecture.RegisterType) –
- Return type:
- get_reg_value_after(reg: architecture.RegisterType) RegisterValue [source]
- Parameters:
reg (architecture.RegisterType) –
- Return type:
- get_stack_contents(offset: int, size: int) RegisterValue [source]
- Parameters:
- Return type:
- get_stack_contents_after(offset: int, size: int) RegisterValue [source]
- Parameters:
- Return type:
- static show_llil_hierarchy()[source]
Opens a new tab showing the LLIL hierarchy which includes classes which can easily be used with isinstance to match multiple types of IL instructions.
- traverse(cb: Callable[[LowLevelILInstruction, Any], Any], *args: Any, **kwargs: Any) Iterator[Any] [source]
traverse
is a generator that allows you to traverse the LowLevelILInstruction in a depth-first manner. It will yield the result of the callback function for each node in the tree. Arguments can be passed to the callback function usingargs
andkwargs
. See the Developer Docs for more examples.- Parameters:
cb (Callable[[LowLevelILInstruction, Any], Any]) – The callback function to call for each node in the LowLevelILInstruction
args (Any) – Custom user-defined arguments
kwargs (Any) – Custom user-defined keyword arguments
cb –
- Returns:
An iterator of the results of the callback function
- Return type:
Iterator[Any]
- Example:
>>> def get_constant_less_than_value(inst: LowLevelILInstruction, value: int) -> int: >>> if isinstance(inst, Constant) and inst.constant < value: >>> return inst.constant >>> >>> list(inst.traverse(get_constant_less_than_value, 10))
- visit(cb: Callable[[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str, LowLevelILInstruction | None], bool], name: str = 'root', parent: LowLevelILInstruction | None = None) bool [source]
Visits all LowLevelILInstructions in the operands of this instruction and any sub-instructions.
- Parameters:
cb (LowLevelILVisitorCallback) – Callback function that takes the name of the operand, the operand, operand type, and parent instruction
name (str) –
parent (LowLevelILInstruction | None) –
- Returns:
True if all instructions were visited, False if the callback returned False
- Return type:
Deprecated since version 4.0.4907: Use
LowLevelILInstruction.traverse
instead.
- visit_all(cb: Callable[[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str, LowLevelILInstruction | None], bool], name: str = 'root', parent: LowLevelILInstruction | None = None) bool [source]
Visits all operands of this instruction and all operands of any sub-instructions. Using pre-order traversal.
- Parameters:
cb (LowLevelILVisitorCallback) – Callback function that takes the name of the operand, the operand, operand type, and parent instruction
name (str) –
parent (LowLevelILInstruction | None) –
- Returns:
True if all instructions were visited, False if the callback returned False
- Return type:
Deprecated since version 4.0.4907: Use
LowLevelILInstruction.traverse
instead.
- visit_operands(cb: Callable[[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str, LowLevelILInstruction | None], bool], name: str = 'root', parent: LowLevelILInstruction | None = None) bool [source]
Visits all leaf operands of this instruction and any sub-instructions.
- Parameters:
cb (LowLevelILVisitorCallback) – Callback function that takes the name of the operand, the operand, operand type, and parent instruction
name (str) –
parent (LowLevelILInstruction | None) –
- Returns:
True if all instructions were visited, False if the callback returned False
- Return type:
Deprecated since version 4.0.4907: Use
LowLevelILInstruction.traverse
instead.
- ILOperations: ClassVar[Dict[LowLevelILOperation, List[Tuple[str, str]]]] = {LowLevelILOperation.LLIL_NOP: [], LowLevelILOperation.LLIL_SET_REG: [('dest', 'reg'), ('src', 'expr')], LowLevelILOperation.LLIL_SET_REG_SPLIT: [('hi', 'reg'), ('lo', 'reg'), ('src', 'expr')], LowLevelILOperation.LLIL_SET_FLAG: [('dest', 'flag'), ('src', 'expr')], LowLevelILOperation.LLIL_SET_REG_STACK_REL: [('stack', 'reg_stack'), ('dest', 'expr'), ('src', 'expr')], LowLevelILOperation.LLIL_REG_STACK_PUSH: [('stack', 'reg_stack'), ('src', 'expr')], LowLevelILOperation.LLIL_LOAD: [('src', 'expr')], LowLevelILOperation.LLIL_STORE: [('dest', 'expr'), ('src', 'expr')], LowLevelILOperation.LLIL_PUSH: [('src', 'expr')], LowLevelILOperation.LLIL_POP: [], LowLevelILOperation.LLIL_REG: [('src', 'reg')], LowLevelILOperation.LLIL_REG_SPLIT: [('hi', 'reg'), ('lo', 'reg')], LowLevelILOperation.LLIL_REG_STACK_REL: [('stack', 'reg_stack'), ('src', 'expr')], LowLevelILOperation.LLIL_REG_STACK_POP: [('stack', 'reg_stack')], LowLevelILOperation.LLIL_REG_STACK_FREE_REG: [('dest', 'reg')], LowLevelILOperation.LLIL_REG_STACK_FREE_REL: [('stack', 'reg_stack'), ('dest', 'expr')], LowLevelILOperation.LLIL_CONST: [('constant', 'int')], LowLevelILOperation.LLIL_CONST_PTR: [('constant', 'int')], LowLevelILOperation.LLIL_EXTERN_PTR: [('constant', 'int'), ('offset', 'int')], LowLevelILOperation.LLIL_FLOAT_CONST: [('constant', 'float')], LowLevelILOperation.LLIL_FLAG: [('src', 'flag')], LowLevelILOperation.LLIL_FLAG_BIT: [('src', 'flag'), ('bit', 'int')], LowLevelILOperation.LLIL_ADD: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_ADC: [('left', 'expr'), ('right', 'expr'), ('carry', 'expr')], LowLevelILOperation.LLIL_SUB: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_SBB: [('left', 'expr'), ('right', 'expr'), ('carry', 'expr')], LowLevelILOperation.LLIL_AND: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_OR: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_XOR: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_LSL: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_LSR: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_ASR: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_ROL: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_RLC: [('left', 'expr'), ('right', 'expr'), ('carry', 'expr')], LowLevelILOperation.LLIL_ROR: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_RRC: [('left', 'expr'), ('right', 'expr'), ('carry', 'expr')], LowLevelILOperation.LLIL_MUL: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_MULU_DP: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_MULS_DP: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_DIVU: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_DIVU_DP: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_DIVS: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_DIVS_DP: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_MODU: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_MODU_DP: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_MODS: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_MODS_DP: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_NEG: [('src', 'expr')], LowLevelILOperation.LLIL_NOT: [('src', 'expr')], LowLevelILOperation.LLIL_SX: [('src', 'expr')], LowLevelILOperation.LLIL_ZX: [('src', 'expr')], LowLevelILOperation.LLIL_LOW_PART: [('src', 'expr')], LowLevelILOperation.LLIL_JUMP: [('dest', 'expr')], LowLevelILOperation.LLIL_JUMP_TO: [('dest', 'expr'), ('targets', 'target_map')], LowLevelILOperation.LLIL_CALL: [('dest', 'expr')], LowLevelILOperation.LLIL_CALL_STACK_ADJUST: [('dest', 'expr'), ('stack_adjustment', 'int'), ('reg_stack_adjustments', 'reg_stack_adjust')], LowLevelILOperation.LLIL_TAILCALL: [('dest', 'expr')], LowLevelILOperation.LLIL_RET: [('dest', 'expr')], LowLevelILOperation.LLIL_NORET: [], LowLevelILOperation.LLIL_IF: [('condition', 'expr'), ('true', 'int'), ('false', 'int')], LowLevelILOperation.LLIL_GOTO: [('dest', 'int')], LowLevelILOperation.LLIL_FLAG_COND: [('condition', 'cond'), ('semantic_class', 'sem_class')], LowLevelILOperation.LLIL_FLAG_GROUP: [('semantic_group', 'sem_group')], LowLevelILOperation.LLIL_CMP_E: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_NE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_SLT: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_ULT: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_SLE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_ULE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_SGE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_UGE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_SGT: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_UGT: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_TEST_BIT: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_BOOL_TO_INT: [('src', 'expr')], LowLevelILOperation.LLIL_ADD_OVERFLOW: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_SYSCALL: [], LowLevelILOperation.LLIL_BP: [], LowLevelILOperation.LLIL_TRAP: [('vector', 'int')], LowLevelILOperation.LLIL_INTRINSIC: [('output', 'reg_or_flag_list'), ('intrinsic', 'intrinsic'), ('param', 'expr')], LowLevelILOperation.LLIL_UNDEF: [], LowLevelILOperation.LLIL_UNIMPL: [], LowLevelILOperation.LLIL_UNIMPL_MEM: [('src', 'expr')], LowLevelILOperation.LLIL_FADD: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FSUB: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FMUL: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FDIV: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FSQRT: [('src', 'expr')], LowLevelILOperation.LLIL_FNEG: [('src', 'expr')], LowLevelILOperation.LLIL_FABS: [('src', 'expr')], LowLevelILOperation.LLIL_FLOAT_TO_INT: [('src', 'expr')], LowLevelILOperation.LLIL_INT_TO_FLOAT: [('src', 'expr')], LowLevelILOperation.LLIL_FLOAT_CONV: [('src', 'expr')], LowLevelILOperation.LLIL_ROUND_TO_INT: [('src', 'expr')], LowLevelILOperation.LLIL_FLOOR: [('src', 'expr')], LowLevelILOperation.LLIL_CEIL: [('src', 'expr')], LowLevelILOperation.LLIL_FTRUNC: [('src', 'expr')], LowLevelILOperation.LLIL_FCMP_E: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FCMP_NE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FCMP_LT: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FCMP_LE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FCMP_GE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FCMP_GT: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FCMP_O: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FCMP_UO: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_SET_REG_SSA: [('dest', 'reg_ssa'), ('src', 'expr')], LowLevelILOperation.LLIL_SET_REG_SSA_PARTIAL: [('full_reg', 'reg_ssa'), ('dest', 'reg'), ('src', 'expr')], LowLevelILOperation.LLIL_SET_REG_SPLIT_SSA: [('hi', 'expr'), ('lo', 'expr'), ('src', 'expr')], LowLevelILOperation.LLIL_SET_REG_STACK_REL_SSA: [('stack', 'expr'), ('dest', 'expr'), ('top', 'expr'), ('src', 'expr')], LowLevelILOperation.LLIL_SET_REG_STACK_ABS_SSA: [('stack', 'expr'), ('dest', 'reg'), ('src', 'expr')], LowLevelILOperation.LLIL_REG_SPLIT_DEST_SSA: [('dest', 'reg_ssa')], LowLevelILOperation.LLIL_REG_STACK_DEST_SSA: [('src', 'reg_stack_ssa_dest_and_src')], LowLevelILOperation.LLIL_REG_SSA: [('src', 'reg_ssa')], LowLevelILOperation.LLIL_REG_SSA_PARTIAL: [('full_reg', 'reg_ssa'), ('src', 'reg')], LowLevelILOperation.LLIL_REG_SPLIT_SSA: [('hi', 'reg_ssa'), ('lo', 'reg_ssa')], LowLevelILOperation.LLIL_REG_STACK_REL_SSA: [('stack', 'reg_stack_ssa'), ('src', 'expr'), ('top', 'expr')], LowLevelILOperation.LLIL_REG_STACK_ABS_SSA: [('stack', 'reg_stack_ssa'), ('src', 'reg')], LowLevelILOperation.LLIL_REG_STACK_FREE_REL_SSA: [('stack', 'expr'), ('dest', 'expr'), ('top', 'expr')], LowLevelILOperation.LLIL_REG_STACK_FREE_ABS_SSA: [('stack', 'expr'), ('dest', 'reg')], LowLevelILOperation.LLIL_SET_FLAG_SSA: [('dest', 'flag_ssa'), ('src', 'expr')], LowLevelILOperation.LLIL_FLAG_SSA: [('src', 'flag_ssa')], LowLevelILOperation.LLIL_FLAG_BIT_SSA: [('src', 'flag_ssa'), ('bit', 'int')], LowLevelILOperation.LLIL_CALL_SSA: [('output', 'expr'), ('dest', 'expr'), ('stack', 'expr'), ('param', 'expr')], LowLevelILOperation.LLIL_SYSCALL_SSA: [('output', 'expr'), ('stack', 'expr'), ('param', 'expr')], LowLevelILOperation.LLIL_TAILCALL_SSA: [('output', 'expr'), ('dest', 'expr'), ('stack', 'expr'), ('param', 'expr')], LowLevelILOperation.LLIL_CALL_PARAM: [('src', 'expr_list')], LowLevelILOperation.LLIL_CALL_STACK_SSA: [('src', 'reg_ssa'), ('src_memory', 'int')], LowLevelILOperation.LLIL_CALL_OUTPUT_SSA: [('dest_memory', 'int'), ('dest', 'reg_ssa_list')], LowLevelILOperation.LLIL_SEPARATE_PARAM_LIST_SSA: [('src', 'expr_list')], LowLevelILOperation.LLIL_SHARED_PARAM_SLOT_SSA: [('src', 'expr_list')], LowLevelILOperation.LLIL_MEMORY_INTRINSIC_OUTPUT_SSA: [('dest_memory', 'int'), ('output', 'reg_ssa_list')], LowLevelILOperation.LLIL_LOAD_SSA: [('src', 'expr'), ('src_memory', 'int')], LowLevelILOperation.LLIL_STORE_SSA: [('dest', 'expr'), ('dest_memory', 'int'), ('src_memory', 'int'), ('src', 'expr')], LowLevelILOperation.LLIL_INTRINSIC_SSA: [('output', 'reg_or_flag_ssa_list'), ('intrinsic', 'intrinsic'), ('param', 'expr')], LowLevelILOperation.LLIL_MEMORY_INTRINSIC_SSA: [('output', 'expr'), ('intrinsic', 'intrinsic'), ('params', 'expr_list'), ('src_memory', 'int')], LowLevelILOperation.LLIL_REG_PHI: [('dest', 'reg_ssa'), ('src', 'reg_ssa_list')], LowLevelILOperation.LLIL_REG_STACK_PHI: [('dest', 'reg_stack_ssa'), ('src', 'reg_stack_ssa_list')], LowLevelILOperation.LLIL_FLAG_PHI: [('dest', 'flag_ssa'), ('src', 'flag_ssa_list')], LowLevelILOperation.LLIL_MEM_PHI: [('dest_memory', 'int'), ('src_memory', 'int_list')]}
- property address: int
- property attributes: Set[ILInstructionAttribute]
The set of optional attributes placed on the instruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- expr_index: ExpressionIndex
- property flags: FlagWriteTypeName | None
- function: LowLevelILFunction
- property high_level_il: HighLevelILInstruction | None
Gets the high level IL expression corresponding to this expression (may be None for eliminated instructions)
- property hlil: HighLevelILInstruction | None
- property hlils: List[HighLevelILInstruction]
- property il_basic_block: LowLevelILBasicBlock
IL basic block object containing this expression (read-only) (only available on finalized functions)
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property mapped_medium_level_il: MediumLevelILInstruction | None
Gets the mapped medium level IL expression corresponding to this expression
- property medium_level_il: MediumLevelILInstruction | None
Gets the medium level IL expression corresponding to this expression (may be None for eliminated instructions)
- property mlil: MediumLevelILInstruction | None
- property mlils: List[MediumLevelILInstruction]
- property mmlil: MediumLevelILInstruction | None
- property non_ssa_form: LowLevelILInstruction
Non-SSA form of expression (read-only)
- property operands: List[LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None]
Operands for the instruction
Consider using more specific APIs for
src
,dest
,params
, etc where appropriate.
- property operation: LowLevelILOperation
- property possible_values: PossibleValueSet
Possible values of expression using path-sensitive static data flow analysis (read-only)
- property postfix_operands: List[LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None]
All operands in the expression tree in postfix order
- property prefix_operands: List[LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None]
All operands in the expression tree in prefix order
- property raw_flags: int
- property raw_operands: Tuple[ExpressionIndex, ExpressionIndex, ExpressionIndex, ExpressionIndex]
Raw operand expression indices as specified by the core structure (read-only)
- property size: int
- property source_location: ILSourceLocation
- property source_operand: ExpressionIndex | None
- property ssa_form: LowLevelILInstruction
SSA form of expression (read-only)
- property tokens: List[InstructionTextToken]
LLIL tokens (read-only)
- property value: RegisterValue
Value of expression if constant or a known value (read-only)
- class LowLevelILIntToFloat[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILIntToFloat(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILIntrinsic[source]
Bases:
LowLevelILInstruction
,Intrinsic
LowLevelILIntrinsic(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property intrinsic: ILIntrinsic
- property output: List[ILFlag | ILRegister]
- property param: LowLevelILCallParam
- property params: List[LowLevelILInstruction]
- class LowLevelILIntrinsicSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILIntrinsicSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property intrinsic: ILIntrinsic
- property output: List[SSARegisterOrFlag]
- property param: LowLevelILCallParam
- property params: List[LowLevelILInstruction]
- class LowLevelILJump[source]
Bases:
LowLevelILInstruction
,Terminal
LowLevelILJump(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- class LowLevelILJumpTo[source]
Bases:
LowLevelILInstruction
LowLevelILJumpTo(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- class LowLevelILLabel[source]
Bases:
object
- __init__(handle: BNLowLevelILLabel | None = None)[source]
- Parameters:
handle (BNLowLevelILLabel | None) –
- property operand: InstructionIndex
- property ref: bool
- property resolved: bool
- class LowLevelILLoad[source]
Bases:
LowLevelILInstruction
,Load
LowLevelILLoad(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILLoadSsa[source]
Bases:
LowLevelILInstruction
,Load
,SSA
LowLevelILLoadSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- property src_memory: int
- class LowLevelILLowPart[source]
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILLowPart(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILLsl[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILLsl(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILLsr[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILLsr(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILMemPhi[source]
Bases:
LowLevelILInstruction
,Memory
,Phi
LowLevelILMemPhi(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest_memory: int
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- class LowLevelILMemoryIntrinsicOutputSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILMemoryIntrinsicOutputSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest_memory: int
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property output: List[SSARegisterOrFlag]
- class LowLevelILMemoryIntrinsicSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILMemoryIntrinsicSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest_memory: int
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property intrinsic: ILIntrinsic
- property output: List[SSARegisterOrFlag]
- property param: LowLevelILCallParam
- property params: List[LowLevelILInstruction]
- property src_memory: int
- class LowLevelILMods[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
,Signed
LowLevelILMods(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILModsDp[source]
Bases:
LowLevelILBinaryBase
,DoublePrecision
,Signed
LowLevelILModsDp(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILModu[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILModu(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILModuDp[source]
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILModuDp(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILMul[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILMul(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILMulsDp[source]
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILMulsDp(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILMuluDp[source]
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILMuluDp(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILNeg[source]
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILNeg(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILNop[source]
Bases:
LowLevelILInstruction
LowLevelILNop(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILNoret[source]
Bases:
LowLevelILInstruction
,Terminal
LowLevelILNoret(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILNot[source]
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILNot(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILOperationAndSize[source]
Bases:
object
LowLevelILOperationAndSize(operation: ‘LowLevelILOperation’, size: int)
- __init__(operation: LowLevelILOperation, size: int) None
- Parameters:
operation (LowLevelILOperation) –
size (int) –
- Return type:
None
- operation: LowLevelILOperation
- size: int
- class LowLevelILOr[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILOr(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILPop[source]
Bases:
LowLevelILInstruction
,StackOperation
LowLevelILPop(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILPush[source]
Bases:
LowLevelILInstruction
,StackOperation
LowLevelILPush(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILReg[source]
Bases:
LowLevelILInstruction
LowLevelILReg(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: ILRegister
- class LowLevelILRegPhi[source]
Bases:
LowLevelILInstruction
,Phi
LowLevelILRegPhi(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: SSARegister
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: List[SSARegister]
- class LowLevelILRegSplit[source]
Bases:
LowLevelILInstruction
LowLevelILRegSplit(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property hi: ILRegister
- property lo: ILRegister
- class LowLevelILRegSplitDestSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILRegSplitDestSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: SSARegister
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- class LowLevelILRegSplitSsa[source]
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILRegSplitSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property hi: SSARegister
- property lo: SSARegister
- class LowLevelILRegSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILRegSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: SSARegister
- class LowLevelILRegSsaPartial[source]
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILRegSsaPartial(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property full_reg: SSARegister
- property src: ILRegister
- class LowLevelILRegStackAbsSsa[source]
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackAbsSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: ILRegister
- property stack: SSARegisterStack
- class LowLevelILRegStackDestSsa[source]
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackDestSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: SSARegisterStack
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: SSARegisterStack
- class LowLevelILRegStackFreeAbsSsa[source]
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackFreeAbsSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: ILRegister
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property stack: LowLevelILInstruction
- class LowLevelILRegStackFreeReg[source]
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackFreeReg(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: ILRegister
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- class LowLevelILRegStackFreeRel[source]
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackFreeRel(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property stack: ILRegisterStack
- class LowLevelILRegStackFreeRelSsa[source]
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackFreeRelSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property stack: LowLevelILInstruction
- property top: LowLevelILInstruction
- class LowLevelILRegStackPhi[source]
Bases:
LowLevelILInstruction
,RegisterStack
,Phi
LowLevelILRegStackPhi(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: SSARegisterStack
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: List[SSARegisterStack]
- class LowLevelILRegStackPop[source]
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackPop(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property stack: ILRegisterStack
- class LowLevelILRegStackPush[source]
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackPush(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- property stack: ILRegisterStack
- class LowLevelILRegStackRel[source]
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackRel(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- property stack: ILRegisterStack
- class LowLevelILRegStackRelSsa[source]
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackRelSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- property stack: SSARegisterStack
- property top: LowLevelILInstruction
- class LowLevelILRet[source]
Bases:
LowLevelILInstruction
,Return
LowLevelILRet(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- class LowLevelILRlc[source]
Bases:
LowLevelILCarryBase
LowLevelILRlc(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILRol[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILRol(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILRor[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILRor(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILRoundToInt[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILRoundToInt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILRrc[source]
Bases:
LowLevelILCarryBase
LowLevelILRrc(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILSbb[source]
Bases:
LowLevelILCarryBase
LowLevelILSbb(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILSeparateParamListSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILSeparateParamListSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: List[LowLevelILInstruction]
- class LowLevelILSetFlag[source]
Bases:
LowLevelILInstruction
LowLevelILSetFlag(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: ILFlag
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILSetFlagSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILSetFlagSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: SSAFlag
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILSetReg[source]
Bases:
LowLevelILInstruction
,SetReg
LowLevelILSetReg(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: ILRegister
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILSetRegSplit[source]
Bases:
LowLevelILInstruction
,SetReg
LowLevelILSetRegSplit(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property hi: ILRegister
- property lo: ILRegister
- property src: LowLevelILInstruction
- class LowLevelILSetRegSplitSsa[source]
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILSetRegSplitSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property hi: LowLevelILInstruction
- property lo: LowLevelILInstruction
- property src: LowLevelILInstruction
- class LowLevelILSetRegSsa[source]
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILSetRegSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: SSARegister
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILSetRegSsaPartial[source]
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILSetRegSsaPartial(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: ILRegister
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property full_reg: SSARegister
- property src: LowLevelILInstruction
- class LowLevelILSetRegStackAbsSsa[source]
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILSetRegStackAbsSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: ILRegister
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- property stack: LowLevelILInstruction
- class LowLevelILSetRegStackRel[source]
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILSetRegStackRel(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- property stack: ILRegisterStack
- class LowLevelILSetRegStackRelSsa[source]
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILSetRegStackRelSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- property stack: LowLevelILInstruction
- property top: LowLevelILInstruction
- class LowLevelILSharedParamSlotSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILSharedParamSlotSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: List[LowLevelILInstruction]
- class LowLevelILStore[source]
Bases:
LowLevelILInstruction
,Store
LowLevelILStore(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILStoreSsa[source]
Bases:
LowLevelILInstruction
,Store
,SSA
LowLevelILStoreSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction
- property dest_memory: int
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- property src_memory: int
- class LowLevelILSub[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILSub(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILSx[source]
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILSx(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILSyscall[source]
Bases:
LowLevelILInstruction
,Syscall
LowLevelILSyscall(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILSyscallSsa[source]
Bases:
LowLevelILInstruction
,Syscall
,SSA
LowLevelILSyscallSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property output: List[SSARegister]
- property param: LowLevelILCallParam
- property params: List[LowLevelILInstruction]
- property stack: LowLevelILCallStackSsa
- property stack_memory: int
- property stack_reg: SSARegister
- class LowLevelILTailcall[source]
Bases:
LowLevelILInstruction
,Tailcall
LowLevelILTailcall(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- class LowLevelILTailcallSsa[source]
Bases:
LowLevelILInstruction
,Tailcall
,SSA
,Terminal
LowLevelILTailcallSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property output: List[SSARegister]
- property param: LowLevelILCallParam
- property params: List[LowLevelILInstruction]
- property stack: LowLevelILInstruction
- class LowLevelILTestBit[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILTestBit(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILTrap[source]
Bases:
LowLevelILInstruction
,Terminal
LowLevelILTrap(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property vector: int
- class LowLevelILUnaryBase[source]
Bases:
LowLevelILInstruction
,UnaryOperation
LowLevelILUnaryBase(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILUndef[source]
Bases:
LowLevelILInstruction
,Terminal
LowLevelILUndef(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILUnimpl[source]
Bases:
LowLevelILInstruction
LowLevelILUnimpl(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILUnimplMem[source]
Bases:
LowLevelILInstruction
,Memory
LowLevelILUnimplMem(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction
- class LowLevelILXor[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILXor(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class LowLevelILZx[source]
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILZx(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- class SSAFlag[source]
Bases:
object
SSAFlag(flag: binaryninja.lowlevelil.ILFlag, version: int)
- flag: ILFlag
- version: int
- class SSARegister[source]
Bases:
object
SSARegister(reg: binaryninja.lowlevelil.ILRegister, version: int)
- __init__(reg: ILRegister, version: int) None
- Parameters:
reg (ILRegister) –
version (int) –
- Return type:
None
- reg: ILRegister
- version: int
- class SSARegisterOrFlag[source]
Bases:
object
SSARegisterOrFlag(reg_or_flag: Union[binaryninja.lowlevelil.ILRegister, binaryninja.lowlevelil.ILFlag], version: int)
- __init__(reg_or_flag: ILRegister | ILFlag, version: int) None
- Parameters:
reg_or_flag (ILRegister | ILFlag) –
version (int) –
- Return type:
None
- reg_or_flag: ILRegister | ILFlag
- version: int
- class SSARegisterStack[source]
Bases:
object
SSARegisterStack(reg_stack: binaryninja.lowlevelil.ILRegisterStack, version: int)
- __init__(reg_stack: ILRegisterStack, version: int) None
- Parameters:
reg_stack (ILRegisterStack) –
version (int) –
- Return type:
None
- reg_stack: ILRegisterStack
- version: int
- LLIL_GET_TEMP_REG_INDEX(n: ILRegister | int) int [source]
- Parameters:
n (ILRegister | int) –
- Return type:
- LLIL_REG_IS_TEMP(n: ILRegister | int) bool [source]
- Parameters:
n (ILRegister | int) –
- Return type:
- LLIL_TEMP(n: ILRegister | int) RegisterIndex [source]
- Parameters:
n (ILRegister | int) –
- Return type:
RegisterIndex
CoreLowLevelILInstruction¶
- class CoreLowLevelILInstruction[source]¶
Bases:
object
CoreLowLevelILInstruction(operation: binaryninja.enums.LowLevelILOperation, attributes: int, size: int, flags: int, source_operand: binaryninja.lowlevelil.ExpressionIndex, operands: Tuple[binaryninja.lowlevelil.ExpressionIndex, binaryninja.lowlevelil.ExpressionIndex, binaryninja.lowlevelil.ExpressionIndex, binaryninja.lowlevelil.ExpressionIndex], address: int)
- __init__(operation: LowLevelILOperation, attributes: int, size: int, flags: int, source_operand: ExpressionIndex, operands: Tuple[ExpressionIndex, ExpressionIndex, ExpressionIndex, ExpressionIndex], address: int) None ¶
- classmethod from_BNLowLevelILInstruction(instr: BNLowLevelILInstruction) CoreLowLevelILInstruction [source]¶
- Parameters:
instr (BNLowLevelILInstruction) –
- Return type:
- operation: LowLevelILOperation¶
- source_operand: ExpressionIndex¶
ILFlag¶
- class ILFlag[source]¶
Bases:
object
ILFlag(arch: ‘architecture.Architecture’, index: ‘architecture.FlagIndex’)
- __init__(arch: Architecture, index: FlagIndex) None ¶
- Parameters:
arch (Architecture) –
index (FlagIndex) –
- Return type:
None
- arch: Architecture¶
- index: FlagIndex¶
- property name: FlagName¶
ILIntrinsic¶
- class ILIntrinsic[source]¶
Bases:
object
ILIntrinsic(arch: ‘architecture.Architecture’, index: ‘architecture.IntrinsicIndex’)
- __init__(arch: Architecture, index: IntrinsicIndex) None ¶
- Parameters:
arch (Architecture) –
index (IntrinsicIndex) –
- Return type:
None
- arch: Architecture¶
- index: IntrinsicIndex¶
- property inputs: List[IntrinsicInput]¶
inputs
is only available if the IL intrinsic is an Architecture intrinsic
- property name: IntrinsicName¶
ILRegister¶
- class ILRegister[source]¶
Bases:
object
ILRegister(arch: ‘architecture.Architecture’, index: ‘architecture.RegisterIndex’)
- __init__(arch: Architecture, index: RegisterIndex) None ¶
- Parameters:
arch (Architecture) –
index (RegisterIndex) –
- Return type:
None
- arch: Architecture¶
- index: RegisterIndex¶
- property info: RegisterInfo¶
- property name: RegisterName¶
ILRegisterStack¶
- class ILRegisterStack[source]¶
Bases:
object
ILRegisterStack(arch: ‘architecture.Architecture’, index: ‘architecture.RegisterStackIndex’)
- __init__(arch: Architecture, index: RegisterStackIndex) None ¶
- Parameters:
arch (Architecture) –
index (RegisterStackIndex) –
- Return type:
None
- arch: Architecture¶
- index: RegisterStackIndex¶
- property info: RegisterStackInfo¶
- property name: RegisterStackName¶
ILSemanticFlagClass¶
- class ILSemanticFlagClass[source]¶
Bases:
object
ILSemanticFlagClass(arch: ‘architecture.Architecture’, index: ‘architecture.SemanticClassIndex’)
- __init__(arch: Architecture, index: SemanticClassIndex) None ¶
- Parameters:
arch (Architecture) –
index (SemanticClassIndex) –
- Return type:
None
- arch: Architecture¶
- index: SemanticClassIndex¶
- property name: SemanticClassName¶
ILSemanticFlagGroup¶
- class ILSemanticFlagGroup[source]¶
Bases:
object
ILSemanticFlagGroup(arch: ‘architecture.Architecture’, index: ‘architecture.SemanticGroupIndex’)
- __init__(arch: Architecture, index: SemanticGroupIndex) None ¶
- Parameters:
arch (Architecture) –
index (SemanticGroupIndex) –
- Return type:
None
- arch: Architecture¶
- index: SemanticGroupIndex¶
- property name: SemanticGroupName¶
LowLevelILAdc¶
- class LowLevelILAdc[source]¶
Bases:
LowLevelILCarryBase
LowLevelILAdc(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILAdd¶
- class LowLevelILAdd[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAdd(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILAddOverflow¶
- class LowLevelILAddOverflow[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAddOverflow(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILAnd¶
- class LowLevelILAnd[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAnd(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILAsr¶
- class LowLevelILAsr[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAsr(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILAssert¶
- class LowLevelILAssert[source]¶
Bases:
LowLevelILInstruction
LowLevelILAssert(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property constraint: PossibleValueSet¶
- property src: ILRegister¶
LowLevelILAssertSsa¶
- class LowLevelILAssertSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILAssertSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property constraint: PossibleValueSet¶
- property src: SSARegister¶
LowLevelILBasicBlock¶
- class LowLevelILBasicBlock[source]¶
Bases:
BasicBlock
The
LogLevelILBasicBlock
object is returned during analysis and should not be directly instantiated.- __init__(handle: LP_BNBasicBlock, owner: LowLevelILFunction, view: BinaryView | None)[source]¶
- Parameters:
handle (LP_BNBasicBlock) –
owner (LowLevelILFunction) –
view (BinaryView | None) –
- property il_function: LowLevelILFunction¶
IL Function of which this block is a part, if the block is part of an IL Function.
LowLevelILBinaryBase¶
- class LowLevelILBinaryBase[source]¶
Bases:
LowLevelILInstruction
,BinaryOperation
LowLevelILBinaryBase(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property left: LowLevelILInstruction¶
- property right: LowLevelILInstruction¶
LowLevelILBoolToInt¶
- class LowLevelILBoolToInt[source]¶
Bases:
LowLevelILInstruction
LowLevelILBoolToInt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILBp¶
- class LowLevelILBp[source]¶
Bases:
LowLevelILInstruction
,Terminal
LowLevelILBp(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILCall¶
- class LowLevelILCall[source]¶
Bases:
LowLevelILInstruction
,Localcall
LowLevelILCall(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILCallOutputSsa¶
- class LowLevelILCallOutputSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILCallOutputSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: List[SSARegister]¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILCallParam¶
- class LowLevelILCallParam[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILCallParam(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: List[LowLevelILInstruction]¶
LowLevelILCallSsa¶
- class LowLevelILCallSsa[source]¶
Bases:
LowLevelILInstruction
,Localcall
,SSA
LowLevelILCallSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property output: List[SSARegister]¶
- property param: LowLevelILCallParam¶
- property params: List[LowLevelILInstruction]¶
- property stack: LowLevelILInstruction¶
LowLevelILCallStackAdjust¶
- class LowLevelILCallStackAdjust[source]¶
Bases:
LowLevelILInstruction
,Localcall
LowLevelILCallStackAdjust(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILCallStackSsa¶
- class LowLevelILCallStackSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILCallStackSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: SSARegister¶
LowLevelILCarryBase¶
- class LowLevelILCarryBase[source]¶
Bases:
LowLevelILInstruction
,Carry
LowLevelILCarryBase(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property carry: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property left: LowLevelILInstruction¶
- property right: LowLevelILInstruction¶
LowLevelILCeil¶
- class LowLevelILCeil[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILCeil(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILCmpE¶
- class LowLevelILCmpE[source]¶
Bases:
LowLevelILComparisonBase
LowLevelILCmpE(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILCmpNe¶
- class LowLevelILCmpNe[source]¶
Bases:
LowLevelILComparisonBase
LowLevelILCmpNe(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILCmpSge¶
- class LowLevelILCmpSge[source]¶
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSge(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILCmpSgt¶
- class LowLevelILCmpSgt[source]¶
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSgt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILCmpSle¶
- class LowLevelILCmpSle[source]¶
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSle(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILCmpSlt¶
- class LowLevelILCmpSlt[source]¶
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSlt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILCmpUge¶
- class LowLevelILCmpUge[source]¶
Bases:
LowLevelILComparisonBase
LowLevelILCmpUge(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILCmpUgt¶
- class LowLevelILCmpUgt[source]¶
Bases:
LowLevelILComparisonBase
LowLevelILCmpUgt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILCmpUle¶
- class LowLevelILCmpUle[source]¶
Bases:
LowLevelILComparisonBase
LowLevelILCmpUle(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILCmpUlt¶
- class LowLevelILCmpUlt[source]¶
Bases:
LowLevelILComparisonBase
LowLevelILCmpUlt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILComparisonBase¶
- class LowLevelILComparisonBase[source]¶
Bases:
LowLevelILBinaryBase
,Comparison
LowLevelILComparisonBase(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILConst¶
- class LowLevelILConst[source]¶
Bases:
LowLevelILConstantBase
LowLevelILConst(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILConstPtr¶
- class LowLevelILConstPtr[source]¶
Bases:
LowLevelILConstantBase
LowLevelILConstPtr(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILConstantBase¶
- class LowLevelILConstantBase[source]¶
Bases:
LowLevelILInstruction
,Constant
LowLevelILConstantBase(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILDivs¶
- class LowLevelILDivs[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
,Signed
LowLevelILDivs(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILDivsDp¶
- class LowLevelILDivsDp[source]¶
Bases:
LowLevelILBinaryBase
,DoublePrecision
,Signed
LowLevelILDivsDp(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILDivu¶
- class LowLevelILDivu[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILDivu(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILDivuDp¶
- class LowLevelILDivuDp[source]¶
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILDivuDp(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILExpr¶
LowLevelILExternPtr¶
- class LowLevelILExternPtr[source]¶
Bases:
LowLevelILConstantBase
LowLevelILExternPtr(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILFabs¶
- class LowLevelILFabs[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFabs(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILFadd¶
- class LowLevelILFadd[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFadd(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILFcmpE¶
- class LowLevelILFcmpE[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpE(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILFcmpGe¶
- class LowLevelILFcmpGe[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpGe(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILFcmpGt¶
- class LowLevelILFcmpGt[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpGt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILFcmpLe¶
- class LowLevelILFcmpLe[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpLe(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILFcmpLt¶
- class LowLevelILFcmpLt[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpLt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILFcmpNe¶
- class LowLevelILFcmpNe[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpNe(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILFcmpO¶
- class LowLevelILFcmpO[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpO(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILFcmpUo¶
- class LowLevelILFcmpUo[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpUo(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILFdiv¶
- class LowLevelILFdiv[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFdiv(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILFlag¶
- class LowLevelILFlag[source]¶
Bases:
LowLevelILInstruction
LowLevelILFlag(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILFlagBit¶
- class LowLevelILFlagBit[source]¶
Bases:
LowLevelILInstruction
LowLevelILFlagBit(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILFlagBitSsa¶
- class LowLevelILFlagBitSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILFlagBitSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILFlagCond¶
- class LowLevelILFlagCond[source]¶
Bases:
LowLevelILInstruction
LowLevelILFlagCond(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property condition: LowLevelILFlagCondition¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property semantic_class: ILSemanticFlagClass | None¶
LowLevelILFlagGroup¶
- class LowLevelILFlagGroup[source]¶
Bases:
LowLevelILInstruction
LowLevelILFlagGroup(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property semantic_group: ILSemanticFlagGroup¶
LowLevelILFlagPhi¶
- class LowLevelILFlagPhi[source]¶
Bases:
LowLevelILInstruction
,Phi
LowLevelILFlagPhi(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILFlagSsa¶
- class LowLevelILFlagSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILFlagSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILFloatConst¶
- class LowLevelILFloatConst[source]¶
Bases:
LowLevelILConstantBase
,FloatingPoint
LowLevelILFloatConst(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILFloatConv¶
- class LowLevelILFloatConv[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFloatConv(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILFloatToInt¶
- class LowLevelILFloatToInt[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFloatToInt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILFloor¶
- class LowLevelILFloor[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFloor(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILFmul¶
- class LowLevelILFmul[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFmul(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILFneg¶
- class LowLevelILFneg[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFneg(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILForceVer¶
- class LowLevelILForceVer[source]¶
Bases:
LowLevelILInstruction
LowLevelILForceVer(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: ILRegister¶
LowLevelILForceVerSsa¶
- class LowLevelILForceVerSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILForceVerSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: SSARegister¶
- property src: SSARegister¶
LowLevelILFsqrt¶
- class LowLevelILFsqrt[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFsqrt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILFsub¶
- class LowLevelILFsub[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFsub(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILFtrunc¶
- class LowLevelILFtrunc[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFtrunc(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILFunction¶
- class LowLevelILFunction[source]¶
Bases:
object
class LowLevelILFunction
contains the list of ExpressionIndex objects that make up a function. ExpressionIndex objects can be added to the LowLevelILFunction by callingappend
and passing the result of the various class methods which return ExpressionIndex objects.LowLevelILFlagCondition values used as parameters in the
flag_condition
method.LowLevelILFlagCondition
Operator
Description
LLFC_E
==
Equal
LLFC_NE
!=
Not equal
LLFC_SLT
s<
Signed less than
LLFC_ULT
u<
Unsigned less than
LLFC_SLE
s<=
Signed less than or equal
LLFC_ULE
u<=
Unsigned less than or equal
LLFC_SGE
s>=
Signed greater than or equal
LLFC_UGE
u>=
Unsigned greater than or equal
LLFC_SGT
s>
Signed greater than
LLFC_UGT
u>
Unsigned greater than
LLFC_NEG
Negative
LLFC_POS
Positive
LLFC_O
overflow
Overflow
LLFC_NO
!overflow
No overflow
- __init__(arch: Architecture | None = None, handle: BNLowLevelILFunction | None = None, source_func: Function | None = None)[source]¶
- Parameters:
arch (Architecture | None) –
handle (BNLowLevelILFunction | None) –
source_func (Function | None) –
- add(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
add
adds expressiona
to expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
add.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- add_carry(size: int, a: ExpressionIndex, b: ExpressionIndex, carry: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
add_carry
adds with carry expressiona
to expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
carry (ExpressionIndex) – Carry flag expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
adc.<size>{<flags>}(a, b, carry)
- Return type:
ExpressionIndex
- add_index_list(indices: List[int]) ExpressionIndex [source]¶
add_index_list
returns an index list expression for the given list of integers.- Parameters:
indices (List(int)) – list of numbers
- Returns:
an operand list expression
- Return type:
ExpressionIndex
- add_label_for_address(arch: Architecture, addr: int) None [source]¶
add_label_for_address
adds a low-level IL label for the given architecturearch
at the given virtual addressaddr
- Parameters:
arch (Architecture) – Architecture to add labels for
addr (int) – the IL address to add a label at
- Return type:
None
- add_label_map(labels: Dict[int, LowLevelILLabel], loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
add_label_map
returns a label list expression for the given list of LowLevelILLabel objects.- Parameters:
labels (dict(int, LowLevelILLabel)) – the list of LowLevelILLabel to get a label list expression from
loc (ILSourceLocation) – location of returned expression
- Returns:
the label list expression
- Return type:
ExpressionIndex
- add_operand_list(operands: List[ExpressionIndex]) ExpressionIndex [source]¶
add_operand_list
returns an operand list expression for the given list of integer operands.- Parameters:
operands (List(Union[ExpressionIndex, ExpressionIndex])) – list of operand numbers
- Returns:
an operand list expression
- Return type:
ExpressionIndex
- and_expr(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
and_expr
bitwise and’s expressiona
and expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
and.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- append(expr: ExpressionIndex) InstructionIndex [source]¶
append
adds the ExpressionIndexexpr
to the current LowLevelILFunction.- Parameters:
expr (ExpressionIndex) – the ExpressionIndex to add to the current LowLevelILFunction
- Returns:
Index of added instruction in the current function
- Return type:
- arith_shift_right(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
arith_shift_right
shifts arithmetic right expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
asr.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- assert_expr(size: int, src: architecture.RegisterType, constraint: PossibleValueSet, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
assert_expr
assertconstraint
is the value of the given registersrc
. Used when setting user variable values.- Parameters:
size (int) – size of value in the constraint
src (RegisterType) – register to constrain
constraint (PossibleValueSet) – asserted value of register
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
ASSERT(reg, constraint)
- Return type:
ExpressionIndex
- bool_to_int(size: int, a: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
bool_to_int
returns an expression of sizesize
converting the boolean expressiona
to an integer- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – boolean expression to be converted
loc (ILSourceLocation) – location of returned expression
- Returns:
the converted integer expression.
- Return type:
ExpressionIndex
- breakpoint(loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
breakpoint
returns a processor breakpoint expression.- Parameters:
loc (ILSourceLocation) – location of returned expression
- Returns:
a breakpoint expression.
- Return type:
ExpressionIndex
- cache_possible_value_set(pvs: PossibleValueSet) int [source]¶
Cache a PossibleValueSet in the IL function, returning its index for use in an expression operand :param pvs: PossibleValueSet to cache :return: Index of the PossibleValueSet in the cache
- Parameters:
pvs (PossibleValueSet) –
- Return type:
- call(dest: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
call
returns an expression which first pushes the address of the next instruction onto the stack then jumps (branches) to the expressiondest
- Parameters:
dest (ExpressionIndex) – the expression to call
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
call(dest)
- Return type:
ExpressionIndex
- call_stack_adjust(dest: ExpressionIndex, stack_adjust: int, reg_stack_adjustments: Dict[architecture.RegisterStackType, int] | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
call_stack_adjust
returns an expression which first pushes the address of the next instruction onto the stack then jumps (branches) to the expressiondest
. After the function exits,stack_adjust
is added to the stack pointer register.- Parameters:
dest (ExpressionIndex) – the expression to call
loc (ILSourceLocation) – location of returned expression
stack_adjust (int) –
reg_stack_adjustments (Dict[architecture.RegisterStackType, int] | None) –
- Returns:
The expression
call(dest), stack += stack_adjust
- Return type:
ExpressionIndex
- ceil(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
ceil
rounds a floating point value to an integer towards positive infinity- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to round up
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
roundint.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- compare_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
compare_equal
returns comparison expression of sizesize
checking if expressiona
is equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_not_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
compare_not_equal
returns comparison expression of sizesize
checking if expressiona
is not equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_signed_greater_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
compare_signed_greater_equal
returns comparison expression of sizesize
checking if expressiona
is signed greater than or equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_signed_greater_than(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
compare_signed_greater_than
returns comparison expression of sizesize
checking if expressiona
is signed greater than or equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_signed_less_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
compare_signed_less_equal
returns comparison expression of sizesize
checking if expressiona
is signed less than or equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_signed_less_than(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
compare_signed_less_than
returns comparison expression of sizesize
checking if expressiona
is signed less than expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_unsigned_greater_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
compare_unsigned_greater_equal
returns comparison expression of sizesize
checking if expressiona
is unsigned greater than or equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_unsigned_greater_than(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
compare_unsigned_greater_than
returns comparison expression of sizesize
checking if expressiona
is unsigned greater than or equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_unsigned_less_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
compare_unsigned_less_equal
returns comparison expression of sizesize
checking if expressiona
is unsigned less than or equal to expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- compare_unsigned_less_than(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
compare_unsigned_less_than
returns comparison expression of sizesize
checking if expressiona
is unsigned less than expressionb
- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – LHS of comparison
b (ExpressionIndex) – RHS of comparison
loc (ILSourceLocation) – location of returned expression
- Returns:
a comparison expression.
- Return type:
ExpressionIndex
- const(size: int, value: int, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
const
returns an expression for the constant integervalue
with sizesize
- Parameters:
size (int) – the size of the constant in bytes
value (int) – integer value of the constant
loc (ILSourceLocation) – location of returned expression
- Returns:
A constant expression of given value and size
- Return type:
ExpressionIndex
- const_pointer(size: int, value: int, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
const_pointer
returns an expression for the constant pointervalue
with sizesize
- Parameters:
size (int) – the size of the pointer in bytes
value (int) – address referenced by pointer
loc (ILSourceLocation) – location of returned expression
- Returns:
A constant expression of given value and size
- Return type:
ExpressionIndex
- copy_expr(original: LowLevelILInstruction) ExpressionIndex [source]¶
copy_expr
adds an expression to the function which is equivalent to the given expressionWarning
This function should ONLY be called as a part of a lifter or workflow. It will otherwise not do anything useful as analysis will not be running.
- Parameters:
original (LowLevelILInstruction) – the original IL Instruction you want to copy
- Returns:
The index of the newly copied expression
- Return type:
ExpressionIndex
- copy_expr_to(expr: LowLevelILInstruction, dest: LowLevelILFunction, sub_expr_handler: Callable[[LowLevelILInstruction], ExpressionIndex] | None = None) ExpressionIndex [source]¶
copy_expr_to
deep copies an expression from this function into a target function If provided, the functionsub_expr_handler
will be called on every copied sub-expressionWarning
This function should ONLY be called as a part of a lifter or workflow. It will otherwise not do anything useful as analysis will not be running.
- Parameters:
expr (LowLevelILInstruction) – Expression in this function to copy
dest (LowLevelILFunction) – Function to copy the expression to
sub_expr_handler (Callable[[LowLevelILInstruction], ExpressionIndex] | None) – Optional function to call on every copied sub-expression
- Returns:
Index of the copied expression in the target function
- Return type:
ExpressionIndex
- create_graph(settings: DisassemblySettings | None = None) CoreFlowGraph [source]¶
- Parameters:
settings (DisassemblySettings | None) –
- Return type:
- create_graph_immediate(settings: DisassemblySettings | None = None) CoreFlowGraph [source]¶
- Parameters:
settings (DisassemblySettings | None) –
- Return type:
- div_double_prec_signed(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
div_double_prec_signed
signed double precision divide using expressiona
as a single double precision register by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
divs.dp.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- div_double_prec_unsigned(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
div_double_prec_unsigned
unsigned double precision divide using expressiona
as a single double precision register by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
divu.dp.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- div_signed(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
div_signed
signed divide expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
divs.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- div_unsigned(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
div_unsigned
unsigned divide expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
divu.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- expr(operation, a: ExpressionIndex = 0, b: ExpressionIndex = 0, c: ExpressionIndex = 0, d: ExpressionIndex = 0, size: int = 0, flags: architecture.FlagWriteTypeName | architecture.FlagType | architecture.FlagIndex | int | None = None, source_location: ILSourceLocation | None = None) ExpressionIndex [source]¶
- Parameters:
a (ExpressionIndex) –
b (ExpressionIndex) –
c (ExpressionIndex) –
d (ExpressionIndex) –
size (int) –
flags (architecture.FlagWriteTypeName | architecture.FlagType | architecture.FlagIndex | int | None) –
source_location (ILSourceLocation | None) –
- Return type:
ExpressionIndex
- extern_pointer(size: int, value: int, offset: int, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
extern_pointer
returns an expression for the constant external pointervalue
with sizesize
at offsetoffset
- Parameters:
size (int) – the size of the pointer in bytes
value (int) – address referenced by pointer
offset (int) – offset into external pointer
loc (ILSourceLocation) – location of returned expression
- Returns:
A constant expression of given value and size
- Return type:
ExpressionIndex
- finalize() None [source]¶
finalize
ends the function and computes the list of basic blocks.- Return type:
None
- flag(flag: architecture.FlagType, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
flag
returns a flag expression for the given flag name.- Parameters:
flag (architecture.FlagType) – flag expression to retrieve
loc (ILSourceLocation) – location of returned expression
- Returns:
A flag expression of given flag name
- Return type:
ExpressionIndex
- flag_bit(size: int, flag: architecture.FlagType, bit: int, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
flag_bit
sets the flag namedflag
and sizesize
to the constant integer valuebit
- Parameters:
size (int) – the size of the flag
flag (str) – flag value
bit (int) – integer value to set the bit to
loc (ILSourceLocation) – location of returned expression
- Returns:
A constant expression of given value and size
FLAG.flag = bit
- Return type:
ExpressionIndex
- flag_condition(cond: str | LowLevelILFlagCondition | int, sem_class: architecture.SemanticClassType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
flag_condition
returns a flag_condition expression for the given LowLevelILFlagCondition- Parameters:
cond (LowLevelILFlagCondition) – Flag condition expression to retrieve
sem_class (str) – Optional semantic flag class
loc (ILSourceLocation) – location of returned expression
- Returns:
A flag_condition expression
- Return type:
ExpressionIndex
- flag_group(sem_group: SemanticGroupName, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
flag_group
returns a flag_group expression for the given semantic flag group- Parameters:
sem_group (SemanticGroupName) – Semantic flag group to access
loc (ILSourceLocation) – location of returned expression
- Returns:
A flag_group expression
- Return type:
ExpressionIndex
- float_abs(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_abs
returns absolute value of floating point expressionvalue
of sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to get the absolute value of
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
fabs.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- float_add(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_add
adds floating point expressiona
to expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
fadd.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- float_compare_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_compare_equal
returns floating point comparison expression of sizesize
checking if expressiona
is equal to expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
a f== b
- Return type:
ExpressionIndex
- float_compare_greater_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_compare_greater_equal
returns floating point comparison expression of sizesize
checking if expressiona
is greater than or equal to expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
a f>= b
- Return type:
ExpressionIndex
- float_compare_greater_than(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_compare_greater_than
returns floating point comparison expression of sizesize
checking if expressiona
is greater than expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
a f> b
- Return type:
ExpressionIndex
- float_compare_less_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_compare_less_equal
returns floating point comparison expression of sizesize
checking if expressiona
is less than or equal to expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
a f<= b
- Return type:
ExpressionIndex
- float_compare_less_than(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_compare_less_than
returns floating point comparison expression of sizesize
checking if expressiona
is less than expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
a f< b
- Return type:
ExpressionIndex
- float_compare_not_equal(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_compare_not_equal
returns floating point comparison expression of sizesize
checking if expressiona
is not equal to expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
a f!= b
- Return type:
ExpressionIndex
- float_compare_ordered(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_compare_ordered
returns floating point comparison expression of sizesize
checking if expressiona
is ordered relative to expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
is_ordered(a, b)
- Return type:
ExpressionIndex
- float_compare_unordered(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_compare_unordered
returns floating point comparison expression of sizesize
checking if expressiona
is unordered relative to expressionb
- Parameters:
size (int) – the size of the operands in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
is_unordered(a, b)
- Return type:
ExpressionIndex
- float_const_double(value: float, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_const_double
returns an expression for the double precision floating point valuevalue
- Parameters:
value (float) – float value for the constant
loc (ILSourceLocation) – location of returned expression
- Returns:
A constant expression of given value and size
- Return type:
ExpressionIndex
- float_const_raw(size: int, value: int, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_const_raw
returns an expression for the constant raw binary floating point valuevalue
with sizesize
- Parameters:
size (int) – the size of the constant in bytes
value (int) – integer value for the raw binary representation of the constant
loc (ILSourceLocation) – location of returned expression
- Returns:
A constant expression of given value and size
- Return type:
ExpressionIndex
- float_const_single(value: float, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_const_single
returns an expression for the single precision floating point valuevalue
- Parameters:
value (float) – float value for the constant
loc (ILSourceLocation) – location of returned expression
- Returns:
A constant expression of given value and size
- Return type:
ExpressionIndex
- float_convert(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
int_to_float
converts floating point value of expressionvalue
to sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to negate
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
fconvert.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- float_div(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_div
divides floating point expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
fdiv.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- float_mult(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_mult
multiplies floating point expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
fmul.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- float_neg(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_neg
returns sign negation of floating point expressionvalue
of sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to negate
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
fneg.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- float_sqrt(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_sqrt
returns square root of floating point expressionvalue
of sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to calculate the square root of
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
sqrt.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- float_sub(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_sub
subtracts floating point expressionb
from expressiona
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
fsub.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- float_to_int(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_to_int
returns integer value of floating point expressionvalue
of sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to convert to an int
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
int.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- float_trunc(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
float_trunc
rounds a floating point value to an integer towards zero- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to truncate
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
roundint.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- floor(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
floor
rounds a floating point value to an integer towards negative infinity- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to round down
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
roundint.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- force_ver(size: int, dest: architecture.RegisterType, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
force_ver
creates a new version of the registerdest
Effectively, this is like saying r0#2 = r0#1 which MLIL can then use as a new variable definition site.- Parameters:
size (int) – size of the register
dest (RegisterType) – the register to force a new version of
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
FORCE_VER(reg)
- Return type:
ExpressionIndex
- generate_ssa_form() None [source]¶
generate_ssa_form
generate SSA form given the current LLIL- Return type:
None
- get_basic_block_at(index: int) BasicBlock | None [source]¶
get_basic_block_at
returns the BasicBlock at the given LLIL instructionindex
.- Parameters:
index (int) – Index of the LLIL instruction of the BasicBlock to retrieve.
- Example:
>>> current_il_function.get_basic_block_at(current_il_index) <llil block: x86@19-26>
- Return type:
BasicBlock | None
- get_expr(index: ExpressionIndex) LowLevelILInstruction | None [source]¶
get_expr
retrieves the IL expression at a given expression index in the function.Warning
Not all IL expressions are valid, even if their index is within the bounds of the function, they might not be used by the function and might not contain properly structured data.
- Parameters:
index (ExpressionIndex) – Index of desired expression in function
- Returns:
A LowLevelILInstruction object for the expression, if it exists. Otherwise, None
- Return type:
LowLevelILInstruction | None
- get_expr_count() int [source]¶
get_expr_count
gives a the total number of expressions in this IL functionYou can use this to enumerate all expressions in conjunction with
get_expr
Warning
Not all IL expressions are valid, even if their index is within the returned value from this, they might not be used by the function and might not contain properly structured data.
- Returns:
The number of expressions in the function
- Return type:
- get_expr_index_for_instruction(instr: InstructionIndex) ExpressionIndex [source]¶
- Parameters:
instr (InstructionIndex) –
- Return type:
ExpressionIndex
- get_high_level_il_expr_index(expr: ExpressionIndex) ExpressionIndex | None [source]¶
- Parameters:
expr (ExpressionIndex) –
- Return type:
ExpressionIndex | None
- get_high_level_il_instruction_index(instr: InstructionIndex) InstructionIndex | None [source]¶
- Parameters:
instr (InstructionIndex) –
- Return type:
InstructionIndex | None
- get_instruction_index_for_expr(expr: ExpressionIndex) InstructionIndex | None [source]¶
- Parameters:
expr (ExpressionIndex) –
- Return type:
InstructionIndex | None
- get_instruction_start(addr: int, arch: Architecture | None = None) InstructionIndex | None [source]¶
- Parameters:
addr (int) –
arch (Architecture | None) –
- Return type:
InstructionIndex | None
- get_label_for_address(arch: Architecture, addr: int) LowLevelILLabel | None [source]¶
get_label_for_address
returns the LowLevelILLabel for the given Architecturearch
and IL addressaddr
.- Parameters:
arch (Architecture) –
addr (int) – IL Address label to retrieve
- Returns:
the LowLevelILLabel for the given IL address
- Return type:
- get_label_for_source_instruction(i: InstructionIndex) LowLevelILLabel | None [source]¶
Get the LowLevelILLabel for a given source instruction. The returned label is to an internal object with the same lifetime as the containing LowLevelILFunction.
- Parameters:
i (InstructionIndex) – The source instruction index
- Returns:
The LowLevelILLabel for the source instruction
- Return type:
LowLevelILLabel | None
- get_mapped_medium_level_il_expr_index(expr: ExpressionIndex) ExpressionIndex | None [source]¶
- Parameters:
expr (ExpressionIndex) –
- Return type:
ExpressionIndex | None
- get_mapped_medium_level_il_instruction_index(instr: InstructionIndex) InstructionIndex | None [source]¶
- Parameters:
instr (InstructionIndex) –
- Return type:
InstructionIndex | None
- get_medium_level_il_expr_index(expr: ExpressionIndex) ExpressionIndex | None [source]¶
- Parameters:
expr (ExpressionIndex) –
- Return type:
ExpressionIndex | None
- get_medium_level_il_expr_indexes(expr: ExpressionIndex) List[ExpressionIndex] [source]¶
- Parameters:
expr (ExpressionIndex) –
- Return type:
List[ExpressionIndex]
- get_medium_level_il_instruction_index(instr: InstructionIndex) InstructionIndex | None [source]¶
- Parameters:
instr (InstructionIndex) –
- Return type:
InstructionIndex | None
- get_non_ssa_instruction_index(instr: InstructionIndex) InstructionIndex [source]¶
- Parameters:
instr (InstructionIndex) –
- Return type:
InstructionIndex
- get_ssa_flag_definition(flag_ssa: SSAFlag) LowLevelILInstruction | None [source]¶
- Parameters:
flag_ssa (SSAFlag) –
- Return type:
LowLevelILInstruction | None
- get_ssa_flag_uses(flag_ssa: SSAFlag) List[LowLevelILInstruction] [source]¶
- Parameters:
flag_ssa (SSAFlag) –
- Return type:
- get_ssa_flag_value(flag_ssa: SSAFlag) RegisterValue [source]¶
- Parameters:
flag_ssa (SSAFlag) –
- Return type:
- get_ssa_instruction_index(instr: InstructionIndex) InstructionIndex [source]¶
- Parameters:
instr (InstructionIndex) –
- Return type:
InstructionIndex
- get_ssa_memory_definition(index: int) LowLevelILInstruction | None [source]¶
- Parameters:
index (int) –
- Return type:
LowLevelILInstruction | None
- get_ssa_memory_uses(index: int) List[LowLevelILInstruction] [source]¶
- Parameters:
index (int) –
- Return type:
- get_ssa_reg_definition(reg_ssa: SSARegister) LowLevelILInstruction | None [source]¶
- Parameters:
reg_ssa (SSARegister) –
- Return type:
LowLevelILInstruction | None
- get_ssa_reg_uses(reg_ssa: SSARegister) List[LowLevelILInstruction] [source]¶
- Parameters:
reg_ssa (SSARegister) –
- Return type:
- get_ssa_reg_value(reg_ssa: SSARegister) RegisterValue [source]¶
- Parameters:
reg_ssa (SSARegister) –
- Return type:
- goto(label: LowLevelILLabel, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
goto
returns a goto expression which jumps to the provided LowLevelILLabel.- Parameters:
label (LowLevelILLabel) – Label to jump to
loc (ILSourceLocation) – location of returned expression
- Returns:
the ExpressionIndex that jumps to the provided label
- Return type:
ExpressionIndex
- if_expr(operand: ExpressionIndex, t: LowLevelILLabel, f: LowLevelILLabel, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
if_expr
returns theif
expression which depending on conditionoperand
jumps to the LowLevelILLabelt
when the condition expressionoperand
is non-zero andf
when it’s zero.- Parameters:
operand (ExpressionIndex) – comparison expression to evaluate.
t (LowLevelILLabel) – Label for the true branch
f (LowLevelILLabel) – Label for the false branch
loc (ILSourceLocation) – location of returned expression
- Returns:
the ExpressionIndex for the if expression
- Return type:
ExpressionIndex
- int_to_float(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
int_to_float
returns floating point value of integer expressionvalue
of sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to convert to a float
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
float.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- intrinsic(outputs: List[str | ILRegister | int | ILFlag | RegisterInfo], intrinsic: architecture.IntrinsicType, params: List[ExpressionIndex], flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None)[source]¶
intrinsic
return an intrinsic expression.- Parameters:
loc (ILSourceLocation) – location of returned expression
outputs (List[str | ILRegister | int | ILFlag | RegisterInfo]) –
intrinsic (architecture.IntrinsicType) –
params (List[ExpressionIndex]) –
flags (architecture.FlagType | None) –
- Returns:
an intrinsic expression.
- Return type:
ExpressionIndex
- jump(dest: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
jump
returns an expression which jumps (branches) to the expressiondest
- Parameters:
dest (ExpressionIndex) – the expression to jump to
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
jump(dest)
- Return type:
ExpressionIndex
- jump_to(dest: ExpressionIndex, targets: Dict[int, LowLevelILLabel], loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
jump_to
returns an expression which jumps (branches) various targets intargets
choosing the target intargets
based on the value calculated bydest
- Parameters:
dest (ExpressionIndex) – the expression choosing which jump target to use
targets (Dict[int, LowLevelILLabel]) – the list of targets for jump locations
loc (ILSourceLocation) – location of returned expression
targets –
- Returns:
The expression
jump(dest)
- Return type:
ExpressionIndex
- load(size: int, addr: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
load
Readssize
bytes from the expressionaddr
- Parameters:
size (int) – number of bytes to read
addr (ExpressionIndex) – the expression to read memory from
flags (FlagType) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
[addr].size
- Return type:
ExpressionIndex
- logical_shift_right(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
logical_shift_right
shifts logically right expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
lsr.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- low_part(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
low_part
truncatesvalue
tosize
bytes- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to truncate
loc (ILSourceLocation) – location of returned expression
flags (architecture.FlagType | None) –
- Returns:
The expression
(value).<size>
- Return type:
ExpressionIndex
- mark_label(label: LowLevelILLabel) None [source]¶
mark_label
assigns a LowLevelILLabel to the current IL address.- Parameters:
label (LowLevelILLabel) –
- Return type:
None
- mod_double_prec_signed(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
mod_double_prec_signed
signed double precision modulus using expressiona
as a single double precision register by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
mods.dp.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- mod_double_prec_unsigned(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
mod_double_prec_unsigned
unsigned double precision modulus using expressiona
as a single double precision register by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
modu.dp.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- mod_signed(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
mod_signed
signed modulus expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
mods.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- mod_unsigned(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
mod_unsigned
unsigned modulus expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
modu.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- mult(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
mult
multiplies expressiona
by expressionb
potentially setting flagsflags
and returning an expression. Both the operands and return value aresize
bytes as the product’s upper half is discarded.- Parameters:
size (int) – the size of the result and input operands, in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
mul.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- mult_double_prec_signed(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
mult_double_prec_signed
multiplies signed with double (2*size bytes) precision expressiona
by expressionb
, eachsize
bytes and potentially setting flagsflags
and returning an expression of2*size
bytes.Note
The output expression is
2*size
bytes in size, but will be rendered asmuls.dp.<size>
.- Parameters:
size (int) – the size of the input operands, in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
muls.dp.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- mult_double_prec_unsigned(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
mult_double_prec_unsigned
multiplies unsigned with double (2*size bytes) precision expressiona
by expressionb
, eachsize
bytes and potentially setting flagsflags
and returning an expression of2*size
bytes.Note
The output expression is
2*size
bytes in size, but will be rendered asmulu.dp.<size>
.- Parameters:
size (int) – the size of the input operands, in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
mulu.dp.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- neg_expr(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
neg_expr
two’s complement sign negation of expressionvalue
of sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to negate
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
neg.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- no_ret(loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
no_ret
returns an expression that halts disassembly- Parameters:
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
noreturn
- Return type:
ExpressionIndex
- nop(loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
nop
no operation, this instruction does nothing- Parameters:
loc (ILSourceLocation) – location of returned expression
- Returns:
The no operation expression
- Return type:
ExpressionIndex
- not_expr(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
not_expr
bitwise inverse of expressionvalue
of sizesize
potentially setting flags- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to bitwise invert
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
not.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- operand(n: int, expr: ExpressionIndex) ExpressionIndex [source]¶
operand
sets the operand number of the expressionexpr
and passes backexpr
without modification.- Parameters:
n (int) –
expr (ExpressionIndex) –
- Returns:
returns the expression
expr
unmodified- Return type:
ExpressionIndex
- or_expr(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
or_expr
bitwise or’s expressiona
and expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
or.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- pop(size: int, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
pop
readssize
bytes from the stack, adjusting the stack bysize
.- Parameters:
size (int) – number of bytes to read from the stack
flags (FlagType) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
pop
- Return type:
ExpressionIndex
- prepare_to_copy_block(src: LowLevelILBasicBlock)[source]¶
prepare_to_copy_block
sets up state when copying a function in preparation of copying the instructions from the blocksrc
- Parameters:
src (LowLevelILBasicBlock) – block about to be copied from
- prepare_to_copy_function(src: LowLevelILFunction)[source]¶
prepare_to_copy_function
sets up state in this LLIL function in preparation of copying instructions fromsrc
- Parameters:
src (LowLevelILFunction) – function about to be copied from
- push(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
push
writessize
bytes from expressionvalue
to the stack, adjusting the stack bysize
.- Parameters:
size (int) – number of bytes to write and adjust the stack by
value (ExpressionIndex) – the expression to write
flags (FlagType) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression push(value)
- Return type:
ExpressionIndex
- reg(size: int, reg: architecture.RegisterType, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
reg
returns a register of sizesize
with namereg
- Parameters:
size (int) – the size of the register in bytes
reg (str) – the name of the register
loc (ILSourceLocation) – location of returned expression
- Returns:
A register expression for the given string
- Return type:
ExpressionIndex
- reg_split(size: int, hi: architecture.RegisterType, lo: architecture.RegisterType, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
reg_split
combines registers of sizesize
with nameshi
andlo
- Parameters:
size (int) – the size of the register in bytes
hi (str) – register holding high part of value
lo (str) – register holding low part of value
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
hi:lo
- Return type:
ExpressionIndex
- reg_stack_free_reg(reg: architecture.RegisterType, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
reg_stack_free_reg
clears the given registerreg
from its register stack without affecting the register at the top of the register stack.- Parameters:
reg (str) – the register being marked free
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
__free_slot(reg)
- Return type:
ExpressionIndex
- reg_stack_free_top_relative(reg_stack: architecture.RegisterStackType, entry: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
reg_stack_free_top_relative
clears an entry in the register stackreg_stack
at a top-relative position specified by the value ofentry
.- Parameters:
reg_stack (str) – the register stack name
entry (ExpressionIndex) – expression to calculate the top-relative position
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
__free_slot(reg_stack[entry])
- Return type:
ExpressionIndex
- reg_stack_pop(size: int, reg_stack: architecture.RegisterStackType, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
reg_stack_pop
returns the top entry of sizesize
in register stack with namereg_stack
, and removes the entry from the stack- Parameters:
size (int) – the size of the register in bytes
reg_stack (str) – the name of the register stack
flags (FlagType) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
reg_stack.pop
- Return type:
ExpressionIndex
- reg_stack_push(size: int, reg_stack: architecture.RegisterStackType, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
reg_stack_push
pushes the expressionvalue
of sizesize
onto the top of the register stackreg_stack
- Parameters:
size (int) – size of the register parameter in bytes
reg_stack (str) – the register stack name
value (ExpressionIndex) – an expression to push
flags (str) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
reg_stack.push(value)
- Return type:
ExpressionIndex
- reg_stack_top_relative(size: int, reg_stack: architecture.RegisterStackType, entry: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
reg_stack_top_relative
returns a register stack entry of sizesize
at top-relative locationentry
in register stack with namereg_stack
- Parameters:
size (int) – the size of the register in bytes
reg_stack (str) – the name of the register stack
entry (ExpressionIndex) – an expression for which stack entry to fetch
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
reg_stack[entry]
- Return type:
ExpressionIndex
- replace_expr(original: LowLevelILInstruction | ExpressionIndex | InstructionIndex, new: LowLevelILInstruction | ExpressionIndex | InstructionIndex) None [source]¶
replace_expr
allows modification of expressions but ONLY during lifting.Warning
This function should ONLY be called as a part of a lifter or workflow. It will otherwise not do anything useful as analysis will not be running.
- Parameters:
original (ExpressionIndex) – the ExpressionIndex to replace (may also be an expression index)
new (ExpressionIndex) – the ExpressionIndex to add to the current LowLevelILFunction (may also be an expression index)
- Return type:
None
- ret(dest: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
ret
returns an expression which jumps (branches) to the expressiondest
.ret
is a special alias for jump that makes the disassembler stop disassembling.- Parameters:
dest (ExpressionIndex) – the expression to jump to
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
jump(dest)
- Return type:
ExpressionIndex
- rotate_left(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
rotate_left
bitwise rotates left expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
rol.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- rotate_left_carry(size: int, a: ExpressionIndex, b: ExpressionIndex, carry: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
rotate_left_carry
bitwise rotates left with carry expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
carry (ExpressionIndex) – Carry flag expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
rlc.<size>{<flags>}(a, b, carry)
- Return type:
ExpressionIndex
- rotate_right(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
rotate_right
bitwise rotates right expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
ror.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- rotate_right_carry(size: int, a: ExpressionIndex, b: ExpressionIndex, carry: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
rotate_right_carry
bitwise rotates right with carry expressiona
by expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
carry (ExpressionIndex) – Carry flag expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
rrc.<size>{<flags>}(a, b, carry)
- Return type:
ExpressionIndex
- round_to_int(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
round_to_int
rounds a floating point value to the nearest integer- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to round to the nearest integer
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
roundint.<size>{<flags>}(value)
- Return type:
ExpressionIndex
- set_current_address(value: int, arch: Architecture | None = None) None [source]¶
- Parameters:
value (int) –
arch (Architecture | None) –
- Return type:
None
- set_expr_attributes(expr: LowLevelILInstruction | ExpressionIndex | InstructionIndex, value: Set[ILInstructionAttribute] | List[ILInstructionAttribute])[source]¶
set_expr_attributes
allows modification of instruction attributes but ONLY during lifting.Warning
This function should ONLY be called as a part of a lifter or workflow. It will otherwise not do anything useful as analysis will not be running.
- Parameters:
expr (ExpressionIndex) – the ExpressionIndex to replace (may also be an expression index)
value (set(ILInstructionAttribute)) – the set of attributes to place on the instruction
- Return type:
None
- set_flag(flag: architecture.FlagType, value: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
set_flag
sets the flagflag
to the ExpressionIndexvalue
- Parameters:
flag (str) – the low register name
value (ExpressionIndex) – an expression to set the flag to
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression FLAG.flag = value
- Return type:
ExpressionIndex
- set_indirect_branches(branches: List[Tuple[Architecture, int]]) None [source]¶
- Parameters:
branches (List[Tuple[Architecture, int]]) –
- Return type:
None
- set_reg(size: int, reg: architecture.RegisterType, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
set_reg
sets the registerreg
of sizesize
to the expressionvalue
- Parameters:
size (int) – size of the register parameter in bytes
reg (str) – the register name
value (ExpressionIndex) – an expression to set the register to
flags (str) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
reg = value
- Return type:
ExpressionIndex
- set_reg_split(size: int, hi: architecture.RegisterType, lo: architecture.RegisterType, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
set_reg_split
useshi
andlo
as a single extended register settinghi:lo
to the expressionvalue
.- Parameters:
size (int) – size of the register parameter in bytes
hi (str) – the high register name
lo (str) – the low register name
value (ExpressionIndex) – an expression to set the split registers to
flags (str) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
hi:lo = value
- Return type:
ExpressionIndex
- set_reg_stack_top_relative(size: int, reg_stack: architecture.RegisterStackType, entry: ExpressionIndex, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
set_reg_stack_top_relative
sets the top-relative entryentry
of sizesize
in register stackreg_stack
to the expressionvalue
- Parameters:
size (int) – size of the register parameter in bytes
reg_stack (str) – the register stack name
entry (ExpressionIndex) – an expression for which stack entry to set
value (ExpressionIndex) – an expression to set the entry to
flags (str) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
reg_stack[entry] = value
- Return type:
ExpressionIndex
- shift_left(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
shift_left
shifts left expressiona
by expressionb
from expressiona
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
lsl.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- sign_extend(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
sign_extend
two’s complement sign-extends the expression invalue
tosize
bytes- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to sign extend
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
sx.<size>(value)
- Return type:
ExpressionIndex
- store(size: int, addr: ExpressionIndex, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
store
Writessize
bytes to expressionaddr
read from expressionvalue
- Parameters:
size (int) – number of bytes to write
addr (ExpressionIndex) – the expression to write to
value (ExpressionIndex) – the expression to be written
flags (FlagType) – which flags are set by this operation
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
[addr].size = value
- Return type:
ExpressionIndex
- sub(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
sub
subtracts expressionb
from expressiona
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
sub.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- sub_borrow(size: int, a: ExpressionIndex, b: ExpressionIndex, carry: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
sub_borrow
subtracts with borrow expressionb
from expressiona
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
carry (ExpressionIndex) – Carry flag expression
flags (str) – flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
sbb.<size>{<flags>}(a, b, carry)
- Return type:
ExpressionIndex
- system_call(loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
system_call
return a system call expression.- Parameters:
loc (ILSourceLocation) – location of returned expression
- Returns:
a system call expression.
- Return type:
ExpressionIndex
- tailcall(dest: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
tailcall
returns an expression which jumps (branches) to the expressiondest
- Parameters:
dest (ExpressionIndex) – the expression to jump to
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
tailcall(dest)
- Return type:
ExpressionIndex
- test_bit(size: int, a: ExpressionIndex, b: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
test_bit
returns an expression of sizesize
that tells whether expressiona
has its bit with an index of the expressionb
is set- Parameters:
size (int) – size in bytes
a (ExpressionIndex) – an expression to be tested
b (ExpressionIndex) – an expression for the index of the big
loc (ILSourceLocation) – location of returned expression
- Returns:
the result expression.
- Return type:
ExpressionIndex
- translate(expr_handler: Callable[[LowLevelILFunction, LowLevelILBasicBlock, LowLevelILInstruction], ExpressionIndex]) LowLevelILFunction [source]¶
translate
clones an IL function and modifies its expressions as specified by a givenexpr_handler
, returning the updated IL function.- Parameters:
expr_handler (Callable[[LowLevelILFunction, LowLevelILBasicBlock, LowLevelILInstruction], ExpressionIndex]) –
Function to modify an expression and copy it to the new function. The function should have the following signature:
expr_handler(new_func: LowLevelILFunction, old_block: LowLevelILBasicBlock, old_instr: LowLevelILInstruction) -> ExpressionIndex
- Where:
new_func (LowLevelILFunction): New function to receive translated instructions
old_block (LowLevelILBasicBlock): Original block containing old_instr
old_instr (LowLevelILInstruction): Original instruction
returns (ExpressionIndex): Expression index of newly created instruction in
new_func
- Returns:
Cloned IL function with modifications
- Return type:
- trap(value: int, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
trap
returns a processor trap (interrupt) expression of the given integervalue
.- Parameters:
value (int) – trap (interrupt) number
loc (ILSourceLocation) – location of returned expression
- Returns:
a trap expression.
- Return type:
ExpressionIndex
- traverse(cb: Callable[[LowLevelILInstruction, Any], Any], *args: Any, **kwargs: Any) Iterator[Any] [source]¶
traverse
iterates through all the instructions in the LowLevelILFunction and calls the callback function for each instruction and sub-instruction. See the Developer Docs for more examples.- Parameters:
cb (Callable[[LowLevelILInstruction, Any], Any]) – The callback function to call for each node in the LowLevelILInstruction
args (Any) – Custom user-defined arguments
kwargs (Any) – Custom user-defined keyword arguments
cb –
- Returns:
An iterator of the results of the callback function
- Return type:
Iterator[Any]
- Example:
>>> def find_constants(instr) -> Optional[int]: ... if isinstance(instr, Constant): ... return instr.constant >>> print(list(current_il_function.traverse(find_constants)))
- undefined(loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
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 (ILSourceLocation) – location of returned expression
- Returns:
the undefined expression.
- Return type:
ExpressionIndex
- unimplemented(loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
unimplemented
returns the unimplemented expression. This should be used for all instructions which aren’t implemented.- Parameters:
loc (ILSourceLocation) – location of returned expression
- Returns:
the unimplemented expression.
- Return type:
ExpressionIndex
- unimplemented_memory_ref(size: int, addr: ExpressionIndex, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
unimplemented_memory_ref
a memory reference to expressionaddr
of sizesize
with unimplemented operation.- Parameters:
size (int) – size in bytes of the memory reference
addr (ExpressionIndex) – expression to reference memory
loc (ILSourceLocation) – location of returned expression
- Returns:
the unimplemented memory reference expression.
- Return type:
ExpressionIndex
- visit(cb: Callable[[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str, LowLevelILInstruction | None], bool]) bool [source]¶
Iterates over all the instructions in the function and calls the callback function for each instruction and each sub-instruction.
- Parameters:
cb (LowLevelILVisitorCallback) – Callback function that takes the name of the operand, the operand, operand type, and parent instruction
- Returns:
True if all instructions were visited, False if the callback function returned False.
- Return type:
Deprecated since version 4.0.4907: Use
LowLevelILFunction.traverse
instead.
- visit_all(cb: Callable[[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str, LowLevelILInstruction | None], bool]) bool [source]¶
Iterates over all the instructions in the function and calls the callback function for each instruction and their operands.
- Parameters:
cb (LowLevelILVisitorCallback) – Callback function that takes the name of the operand, the operand, operand type, and parent instruction
- Returns:
True if all instructions were visited, False if the callback function returned False.
- Return type:
Deprecated since version 4.0.4907: Use
LowLevelILFunction.traverse
instead.
- visit_operands(cb: Callable[[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str, LowLevelILInstruction | None], bool]) bool [source]¶
- Iterates over all the instructions in the function and calls the callback function for each operand and
the operands of each sub-instruction.
- Parameters:
cb (LowLevelILVisitorCallback) – Callback function that takes the name of the operand, the operand, operand type, and parent instruction
- Returns:
True if all instructions were visited, False if the callback function returned False.
- Return type:
Deprecated since version 4.0.4907: Use
LowLevelILFunction.traverse
instead.
- xor_expr(size: int, a: ExpressionIndex, b: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
xor_expr
xor’s expressiona
with expressionb
potentially setting flagsflags
and returning an expression ofsize
bytes.- Parameters:
size (int) – the size of the result in bytes
a (ExpressionIndex) – LHS expression
b (ExpressionIndex) – RHS expression
flags (str) – optional, flags to set
loc (ILSourceLocation) – location of returned expression
- Returns:
The expression
xor.<size>{<flags>}(a, b)
- Return type:
ExpressionIndex
- zero_extend(size: int, value: ExpressionIndex, flags: architecture.FlagType | None = None, loc: ILSourceLocation | None = None) ExpressionIndex [source]¶
zero_extend
zero-extends the expression invalue
tosize
bytes- Parameters:
size (int) – the size of the result in bytes
value (ExpressionIndex) – the expression to zero extend
loc (ILSourceLocation) – location of returned expression
flags (architecture.FlagType | None) –
- Returns:
The expression
zx.<size>(value)
- Return type:
ExpressionIndex
- property arch: Architecture¶
- property basic_blocks: LowLevelILBasicBlockList¶
- property il_form: FunctionGraphType¶
- property instructions: Generator[LowLevelILInstruction, None, None]¶
A generator of llil instructions of the current llil function
- property mapped_medium_level_il: MediumLevelILFunction¶
Medium level IL with mappings between low level IL and medium level IL. Unused stores are not removed. Typically, this should only be used to answer queries on assembly or low level IL where the query is easier to perform on medium level IL.
- property medium_level_il: MediumLevelILFunction¶
Medium level IL for this low level IL.
- property mlil: MediumLevelILFunction¶
- property mmlil: MediumLevelILFunction¶
- property non_ssa_form: LowLevelILFunction¶
Low level IL in non-SSA (default) form (read-only)
- property reg_stacks: List[SSARegisterStack]¶
List of register stacks used in this IL
- property register_stacks: List[SSARegisterStack]¶
Deprecated, use reg_stacks instead. List of register stacks used in this IL
- property registers: List[SSARegister]¶
Deprecated, use regs instead. List of registers used in this IL
- property regs: List[SSARegister]¶
List of registers used in this IL
- property ssa_form: LowLevelILFunction¶
Low level IL in SSA form (read-only)
- property ssa_reg_stacks: List[SSARegisterStack]¶
List of all SSA register stacks and versions used in this IL
- property ssa_reg_stacks_without_versions: List[SSARegisterStack]¶
List of SSA register stacks used in this IL
- property ssa_register_stacks: List[SSARegisterStack]¶
- property ssa_registers: List[SSARegister]¶
- property ssa_regs: List[SSARegister]¶
List of all SSA registers and versions used in this IL
- property ssa_regs_without_versions: List[SSARegister]¶
List of SSA registers used in this IL
- property ssa_vars: List[SSARegister | SSARegisterStack | SSAFlag]¶
This is the union LowLevelILFunction.ssa_regs, LowLevelILFunction.ssa_reg_stacks, and LowLevelILFunction.ssa_flags
- property ssa_vars_without_versions: List[SSARegister | SSARegisterStack | SSAFlag]¶
This is the union LowLevelILFunction.ssa_regs_without_versions, LowLevelILFunction.ssa_reg_stacks_without_versions, and LowLevelILFunction.ssa_flags_without_versions
- property vars: List[ILRegister | ILRegisterStack | ILFlag]¶
This is the union LowLevelILFunction.regs, LowLevelILFunction.reg_stacks, and LowLevelILFunction.flags
- property view: BinaryView | None¶
LowLevelILGoto¶
- class LowLevelILGoto[source]¶
Bases:
LowLevelILInstruction
,Terminal
LowLevelILGoto(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: InstructionIndex¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILIf¶
- class LowLevelILIf[source]¶
Bases:
LowLevelILInstruction
,ControlFlow
LowLevelILIf(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property condition: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property false: InstructionIndex¶
- property true: InstructionIndex¶
LowLevelILInstruction¶
- class LowLevelILInstruction[source]¶
Bases:
BaseILInstruction
class LowLevelILInstruction
Low Level Intermediate Language Instructions are infinite length tree-based instructions. Tree-based instructions use infix notation with the left hand operand being the destination operand. Infix notation is thus more natural to read than other notations (e.g. x86mov eax, 0
vs. LLILeax = 0
).- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- copy_to(dest: LowLevelILFunction, sub_expr_handler: Callable[[LowLevelILInstruction], ExpressionIndex] | None = None) ExpressionIndex [source]¶
copy_to
deep copies an expression into a new IL function. If provided, the functionsub_expr_handler
will be called on every copied sub-expressionWarning
This function should ONLY be called as a part of a lifter or workflow. It will otherwise not do anything useful as analysis will not be running.
- Parameters:
dest (LowLevelILFunction) – Function to copy the expression to
sub_expr_handler (Callable[[LowLevelILInstruction], ExpressionIndex] | None) – Optional function to call on every copied sub-expression
- Returns:
Index of the copied expression in the target function
- Return type:
ExpressionIndex
- classmethod create(func: LowLevelILFunction, expr_index: ExpressionIndex, instr_index: InstructionIndex | None = None) LowLevelILInstruction [source]¶
- Parameters:
func (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr_index (InstructionIndex | None) –
- Return type:
- get_flag_value(flag: architecture.FlagType) RegisterValue [source]¶
- Parameters:
flag (architecture.FlagType) –
- Return type:
- get_flag_value_after(flag: architecture.FlagType) RegisterValue [source]¶
- Parameters:
flag (architecture.FlagType) –
- Return type:
- get_possible_flag_values(flag: architecture.FlagType, options: List[DataFlowQueryOption] | None = None) PossibleValueSet [source]¶
- Parameters:
flag (architecture.FlagType) –
options (List[DataFlowQueryOption] | None) –
- Return type:
- get_possible_flag_values_after(flag: architecture.FlagType, options: List[DataFlowQueryOption] | None = None) PossibleValueSet [source]¶
- Parameters:
flag (architecture.FlagType) –
options (List[DataFlowQueryOption] | None) –
- Return type:
- get_possible_reg_values(reg: architecture.RegisterType, options: List[DataFlowQueryOption] | None = None) PossibleValueSet [source]¶
- Parameters:
reg (architecture.RegisterType) –
options (List[DataFlowQueryOption] | None) –
- Return type:
- get_possible_reg_values_after(reg: architecture.RegisterType, options: List[DataFlowQueryOption] | None = None) PossibleValueSet [source]¶
- Parameters:
reg (architecture.RegisterType) –
options (List[DataFlowQueryOption] | None) –
- Return type:
- get_possible_stack_contents(offset: int, size: int, options: List[DataFlowQueryOption] | None = None) PossibleValueSet [source]¶
- Parameters:
offset (int) –
size (int) –
options (List[DataFlowQueryOption] | None) –
- Return type:
- get_possible_stack_contents_after(offset: int, size: int, options: List[DataFlowQueryOption] | None = None) PossibleValueSet [source]¶
- Parameters:
offset (int) –
size (int) –
options (List[DataFlowQueryOption] | None) –
- Return type:
- get_possible_values(options: List[DataFlowQueryOption] | None = None) PossibleValueSet [source]¶
- Parameters:
options (List[DataFlowQueryOption] | None) –
- Return type:
- get_reg_value(reg: architecture.RegisterType) RegisterValue [source]¶
- Parameters:
reg (architecture.RegisterType) –
- Return type:
- get_reg_value_after(reg: architecture.RegisterType) RegisterValue [source]¶
- Parameters:
reg (architecture.RegisterType) –
- Return type:
- get_stack_contents(offset: int, size: int) RegisterValue [source]¶
- Parameters:
- Return type:
- get_stack_contents_after(offset: int, size: int) RegisterValue [source]¶
- Parameters:
- Return type:
- static show_llil_hierarchy()[source]¶
Opens a new tab showing the LLIL hierarchy which includes classes which can easily be used with isinstance to match multiple types of IL instructions.
- traverse(cb: Callable[[LowLevelILInstruction, Any], Any], *args: Any, **kwargs: Any) Iterator[Any] [source]¶
traverse
is a generator that allows you to traverse the LowLevelILInstruction in a depth-first manner. It will yield the result of the callback function for each node in the tree. Arguments can be passed to the callback function usingargs
andkwargs
. See the Developer Docs for more examples.- Parameters:
cb (Callable[[LowLevelILInstruction, Any], Any]) – The callback function to call for each node in the LowLevelILInstruction
args (Any) – Custom user-defined arguments
kwargs (Any) – Custom user-defined keyword arguments
cb –
- Returns:
An iterator of the results of the callback function
- Return type:
Iterator[Any]
- Example:
>>> def get_constant_less_than_value(inst: LowLevelILInstruction, value: int) -> int: >>> if isinstance(inst, Constant) and inst.constant < value: >>> return inst.constant >>> >>> list(inst.traverse(get_constant_less_than_value, 10))
- visit(cb: Callable[[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str, LowLevelILInstruction | None], bool], name: str = 'root', parent: LowLevelILInstruction | None = None) bool [source]¶
Visits all LowLevelILInstructions in the operands of this instruction and any sub-instructions.
- Parameters:
cb (LowLevelILVisitorCallback) – Callback function that takes the name of the operand, the operand, operand type, and parent instruction
name (str) –
parent (LowLevelILInstruction | None) –
- Returns:
True if all instructions were visited, False if the callback returned False
- Return type:
Deprecated since version 4.0.4907: Use
LowLevelILInstruction.traverse
instead.
- visit_all(cb: Callable[[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str, LowLevelILInstruction | None], bool], name: str = 'root', parent: LowLevelILInstruction | None = None) bool [source]¶
Visits all operands of this instruction and all operands of any sub-instructions. Using pre-order traversal.
- Parameters:
cb (LowLevelILVisitorCallback) – Callback function that takes the name of the operand, the operand, operand type, and parent instruction
name (str) –
parent (LowLevelILInstruction | None) –
- Returns:
True if all instructions were visited, False if the callback returned False
- Return type:
Deprecated since version 4.0.4907: Use
LowLevelILInstruction.traverse
instead.
- visit_operands(cb: Callable[[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str, LowLevelILInstruction | None], bool], name: str = 'root', parent: LowLevelILInstruction | None = None) bool [source]¶
Visits all leaf operands of this instruction and any sub-instructions.
- Parameters:
cb (LowLevelILVisitorCallback) – Callback function that takes the name of the operand, the operand, operand type, and parent instruction
name (str) –
parent (LowLevelILInstruction | None) –
- Returns:
True if all instructions were visited, False if the callback returned False
- Return type:
Deprecated since version 4.0.4907: Use
LowLevelILInstruction.traverse
instead.
- ILOperations: ClassVar[Dict[LowLevelILOperation, List[Tuple[str, str]]]] = {LowLevelILOperation.LLIL_NOP: [], LowLevelILOperation.LLIL_SET_REG: [('dest', 'reg'), ('src', 'expr')], LowLevelILOperation.LLIL_SET_REG_SPLIT: [('hi', 'reg'), ('lo', 'reg'), ('src', 'expr')], LowLevelILOperation.LLIL_SET_FLAG: [('dest', 'flag'), ('src', 'expr')], LowLevelILOperation.LLIL_SET_REG_STACK_REL: [('stack', 'reg_stack'), ('dest', 'expr'), ('src', 'expr')], LowLevelILOperation.LLIL_REG_STACK_PUSH: [('stack', 'reg_stack'), ('src', 'expr')], LowLevelILOperation.LLIL_LOAD: [('src', 'expr')], LowLevelILOperation.LLIL_STORE: [('dest', 'expr'), ('src', 'expr')], LowLevelILOperation.LLIL_PUSH: [('src', 'expr')], LowLevelILOperation.LLIL_POP: [], LowLevelILOperation.LLIL_REG: [('src', 'reg')], LowLevelILOperation.LLIL_REG_SPLIT: [('hi', 'reg'), ('lo', 'reg')], LowLevelILOperation.LLIL_REG_STACK_REL: [('stack', 'reg_stack'), ('src', 'expr')], LowLevelILOperation.LLIL_REG_STACK_POP: [('stack', 'reg_stack')], LowLevelILOperation.LLIL_REG_STACK_FREE_REG: [('dest', 'reg')], LowLevelILOperation.LLIL_REG_STACK_FREE_REL: [('stack', 'reg_stack'), ('dest', 'expr')], LowLevelILOperation.LLIL_CONST: [('constant', 'int')], LowLevelILOperation.LLIL_CONST_PTR: [('constant', 'int')], LowLevelILOperation.LLIL_EXTERN_PTR: [('constant', 'int'), ('offset', 'int')], LowLevelILOperation.LLIL_FLOAT_CONST: [('constant', 'float')], LowLevelILOperation.LLIL_FLAG: [('src', 'flag')], LowLevelILOperation.LLIL_FLAG_BIT: [('src', 'flag'), ('bit', 'int')], LowLevelILOperation.LLIL_ADD: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_ADC: [('left', 'expr'), ('right', 'expr'), ('carry', 'expr')], LowLevelILOperation.LLIL_SUB: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_SBB: [('left', 'expr'), ('right', 'expr'), ('carry', 'expr')], LowLevelILOperation.LLIL_AND: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_OR: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_XOR: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_LSL: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_LSR: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_ASR: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_ROL: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_RLC: [('left', 'expr'), ('right', 'expr'), ('carry', 'expr')], LowLevelILOperation.LLIL_ROR: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_RRC: [('left', 'expr'), ('right', 'expr'), ('carry', 'expr')], LowLevelILOperation.LLIL_MUL: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_MULU_DP: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_MULS_DP: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_DIVU: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_DIVU_DP: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_DIVS: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_DIVS_DP: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_MODU: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_MODU_DP: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_MODS: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_MODS_DP: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_NEG: [('src', 'expr')], LowLevelILOperation.LLIL_NOT: [('src', 'expr')], LowLevelILOperation.LLIL_SX: [('src', 'expr')], LowLevelILOperation.LLIL_ZX: [('src', 'expr')], LowLevelILOperation.LLIL_LOW_PART: [('src', 'expr')], LowLevelILOperation.LLIL_JUMP: [('dest', 'expr')], LowLevelILOperation.LLIL_JUMP_TO: [('dest', 'expr'), ('targets', 'target_map')], LowLevelILOperation.LLIL_CALL: [('dest', 'expr')], LowLevelILOperation.LLIL_CALL_STACK_ADJUST: [('dest', 'expr'), ('stack_adjustment', 'int'), ('reg_stack_adjustments', 'reg_stack_adjust')], LowLevelILOperation.LLIL_TAILCALL: [('dest', 'expr')], LowLevelILOperation.LLIL_RET: [('dest', 'expr')], LowLevelILOperation.LLIL_NORET: [], LowLevelILOperation.LLIL_IF: [('condition', 'expr'), ('true', 'int'), ('false', 'int')], LowLevelILOperation.LLIL_GOTO: [('dest', 'int')], LowLevelILOperation.LLIL_FLAG_COND: [('condition', 'cond'), ('semantic_class', 'sem_class')], LowLevelILOperation.LLIL_FLAG_GROUP: [('semantic_group', 'sem_group')], LowLevelILOperation.LLIL_CMP_E: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_NE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_SLT: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_ULT: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_SLE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_ULE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_SGE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_UGE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_SGT: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_CMP_UGT: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_TEST_BIT: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_BOOL_TO_INT: [('src', 'expr')], LowLevelILOperation.LLIL_ADD_OVERFLOW: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_SYSCALL: [], LowLevelILOperation.LLIL_BP: [], LowLevelILOperation.LLIL_TRAP: [('vector', 'int')], LowLevelILOperation.LLIL_INTRINSIC: [('output', 'reg_or_flag_list'), ('intrinsic', 'intrinsic'), ('param', 'expr')], LowLevelILOperation.LLIL_UNDEF: [], LowLevelILOperation.LLIL_UNIMPL: [], LowLevelILOperation.LLIL_UNIMPL_MEM: [('src', 'expr')], LowLevelILOperation.LLIL_FADD: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FSUB: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FMUL: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FDIV: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FSQRT: [('src', 'expr')], LowLevelILOperation.LLIL_FNEG: [('src', 'expr')], LowLevelILOperation.LLIL_FABS: [('src', 'expr')], LowLevelILOperation.LLIL_FLOAT_TO_INT: [('src', 'expr')], LowLevelILOperation.LLIL_INT_TO_FLOAT: [('src', 'expr')], LowLevelILOperation.LLIL_FLOAT_CONV: [('src', 'expr')], LowLevelILOperation.LLIL_ROUND_TO_INT: [('src', 'expr')], LowLevelILOperation.LLIL_FLOOR: [('src', 'expr')], LowLevelILOperation.LLIL_CEIL: [('src', 'expr')], LowLevelILOperation.LLIL_FTRUNC: [('src', 'expr')], LowLevelILOperation.LLIL_FCMP_E: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FCMP_NE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FCMP_LT: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FCMP_LE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FCMP_GE: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FCMP_GT: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FCMP_O: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_FCMP_UO: [('left', 'expr'), ('right', 'expr')], LowLevelILOperation.LLIL_SET_REG_SSA: [('dest', 'reg_ssa'), ('src', 'expr')], LowLevelILOperation.LLIL_SET_REG_SSA_PARTIAL: [('full_reg', 'reg_ssa'), ('dest', 'reg'), ('src', 'expr')], LowLevelILOperation.LLIL_SET_REG_SPLIT_SSA: [('hi', 'expr'), ('lo', 'expr'), ('src', 'expr')], LowLevelILOperation.LLIL_SET_REG_STACK_REL_SSA: [('stack', 'expr'), ('dest', 'expr'), ('top', 'expr'), ('src', 'expr')], LowLevelILOperation.LLIL_SET_REG_STACK_ABS_SSA: [('stack', 'expr'), ('dest', 'reg'), ('src', 'expr')], LowLevelILOperation.LLIL_REG_SPLIT_DEST_SSA: [('dest', 'reg_ssa')], LowLevelILOperation.LLIL_REG_STACK_DEST_SSA: [('src', 'reg_stack_ssa_dest_and_src')], LowLevelILOperation.LLIL_REG_SSA: [('src', 'reg_ssa')], LowLevelILOperation.LLIL_REG_SSA_PARTIAL: [('full_reg', 'reg_ssa'), ('src', 'reg')], LowLevelILOperation.LLIL_REG_SPLIT_SSA: [('hi', 'reg_ssa'), ('lo', 'reg_ssa')], LowLevelILOperation.LLIL_REG_STACK_REL_SSA: [('stack', 'reg_stack_ssa'), ('src', 'expr'), ('top', 'expr')], LowLevelILOperation.LLIL_REG_STACK_ABS_SSA: [('stack', 'reg_stack_ssa'), ('src', 'reg')], LowLevelILOperation.LLIL_REG_STACK_FREE_REL_SSA: [('stack', 'expr'), ('dest', 'expr'), ('top', 'expr')], LowLevelILOperation.LLIL_REG_STACK_FREE_ABS_SSA: [('stack', 'expr'), ('dest', 'reg')], LowLevelILOperation.LLIL_SET_FLAG_SSA: [('dest', 'flag_ssa'), ('src', 'expr')], LowLevelILOperation.LLIL_FLAG_SSA: [('src', 'flag_ssa')], LowLevelILOperation.LLIL_FLAG_BIT_SSA: [('src', 'flag_ssa'), ('bit', 'int')], LowLevelILOperation.LLIL_CALL_SSA: [('output', 'expr'), ('dest', 'expr'), ('stack', 'expr'), ('param', 'expr')], LowLevelILOperation.LLIL_SYSCALL_SSA: [('output', 'expr'), ('stack', 'expr'), ('param', 'expr')], LowLevelILOperation.LLIL_TAILCALL_SSA: [('output', 'expr'), ('dest', 'expr'), ('stack', 'expr'), ('param', 'expr')], LowLevelILOperation.LLIL_CALL_PARAM: [('src', 'expr_list')], LowLevelILOperation.LLIL_CALL_STACK_SSA: [('src', 'reg_ssa'), ('src_memory', 'int')], LowLevelILOperation.LLIL_CALL_OUTPUT_SSA: [('dest_memory', 'int'), ('dest', 'reg_ssa_list')], LowLevelILOperation.LLIL_SEPARATE_PARAM_LIST_SSA: [('src', 'expr_list')], LowLevelILOperation.LLIL_SHARED_PARAM_SLOT_SSA: [('src', 'expr_list')], LowLevelILOperation.LLIL_MEMORY_INTRINSIC_OUTPUT_SSA: [('dest_memory', 'int'), ('output', 'reg_ssa_list')], LowLevelILOperation.LLIL_LOAD_SSA: [('src', 'expr'), ('src_memory', 'int')], LowLevelILOperation.LLIL_STORE_SSA: [('dest', 'expr'), ('dest_memory', 'int'), ('src_memory', 'int'), ('src', 'expr')], LowLevelILOperation.LLIL_INTRINSIC_SSA: [('output', 'reg_or_flag_ssa_list'), ('intrinsic', 'intrinsic'), ('param', 'expr')], LowLevelILOperation.LLIL_MEMORY_INTRINSIC_SSA: [('output', 'expr'), ('intrinsic', 'intrinsic'), ('params', 'expr_list'), ('src_memory', 'int')], LowLevelILOperation.LLIL_REG_PHI: [('dest', 'reg_ssa'), ('src', 'reg_ssa_list')], LowLevelILOperation.LLIL_REG_STACK_PHI: [('dest', 'reg_stack_ssa'), ('src', 'reg_stack_ssa_list')], LowLevelILOperation.LLIL_FLAG_PHI: [('dest', 'flag_ssa'), ('src', 'flag_ssa_list')], LowLevelILOperation.LLIL_MEM_PHI: [('dest_memory', 'int'), ('src_memory', 'int_list')]}¶
- property attributes: Set[ILInstructionAttribute]¶
The set of optional attributes placed on the instruction
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- property high_level_il: HighLevelILInstruction | None¶
Gets the high level IL expression corresponding to this expression (may be None for eliminated instructions)
- property hlil: HighLevelILInstruction | None¶
- property hlils: List[HighLevelILInstruction]¶
- property il_basic_block: LowLevelILBasicBlock¶
IL basic block object containing this expression (read-only) (only available on finalized functions)
- instr: CoreLowLevelILInstruction¶
- property mapped_medium_level_il: MediumLevelILInstruction | None¶
Gets the mapped medium level IL expression corresponding to this expression
- property medium_level_il: MediumLevelILInstruction | None¶
Gets the medium level IL expression corresponding to this expression (may be None for eliminated instructions)
- property mlil: MediumLevelILInstruction | None¶
- property mlils: List[MediumLevelILInstruction]¶
- property mmlil: MediumLevelILInstruction | None¶
- property non_ssa_form: LowLevelILInstruction¶
Non-SSA form of expression (read-only)
- property operands: List[LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None]¶
Operands for the instruction
Consider using more specific APIs for
src
,dest
,params
, etc where appropriate.
- property operation: LowLevelILOperation¶
- property possible_values: PossibleValueSet¶
Possible values of expression using path-sensitive static data flow analysis (read-only)
- property postfix_operands: List[LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None]¶
All operands in the expression tree in postfix order
- property prefix_operands: List[LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None]¶
All operands in the expression tree in prefix order
- property raw_operands: Tuple[ExpressionIndex, ExpressionIndex, ExpressionIndex, ExpressionIndex]¶
Raw operand expression indices as specified by the core structure (read-only)
- property source_location: ILSourceLocation¶
- property ssa_form: LowLevelILInstruction¶
SSA form of expression (read-only)
- property tokens: List[InstructionTextToken]¶
LLIL tokens (read-only)
- property value: RegisterValue¶
Value of expression if constant or a known value (read-only)
LowLevelILIntToFloat¶
- class LowLevelILIntToFloat[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILIntToFloat(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILIntrinsic¶
- class LowLevelILIntrinsic[source]¶
Bases:
LowLevelILInstruction
,Intrinsic
LowLevelILIntrinsic(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property intrinsic: ILIntrinsic¶
- property output: List[ILFlag | ILRegister]¶
- property param: LowLevelILCallParam¶
- property params: List[LowLevelILInstruction]¶
LowLevelILIntrinsicSsa¶
- class LowLevelILIntrinsicSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILIntrinsicSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property intrinsic: ILIntrinsic¶
- property output: List[SSARegisterOrFlag]¶
- property param: LowLevelILCallParam¶
- property params: List[LowLevelILInstruction]¶
LowLevelILJump¶
- class LowLevelILJump[source]¶
Bases:
LowLevelILInstruction
,Terminal
LowLevelILJump(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILJumpTo¶
- class LowLevelILJumpTo[source]¶
Bases:
LowLevelILInstruction
LowLevelILJumpTo(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILLabel¶
LowLevelILLoad¶
- class LowLevelILLoad[source]¶
Bases:
LowLevelILInstruction
,Load
LowLevelILLoad(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILLoadSsa¶
- class LowLevelILLoadSsa[source]¶
Bases:
LowLevelILInstruction
,Load
,SSA
LowLevelILLoadSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILLowPart¶
- class LowLevelILLowPart[source]¶
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILLowPart(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILLsl¶
- class LowLevelILLsl[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILLsl(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILLsr¶
- class LowLevelILLsr[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILLsr(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILMemPhi¶
- class LowLevelILMemPhi[source]¶
Bases:
LowLevelILInstruction
,Memory
,Phi
LowLevelILMemPhi(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILMemoryIntrinsicOutputSsa¶
- class LowLevelILMemoryIntrinsicOutputSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILMemoryIntrinsicOutputSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property output: List[SSARegisterOrFlag]¶
LowLevelILMemoryIntrinsicSsa¶
- class LowLevelILMemoryIntrinsicSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILMemoryIntrinsicSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property intrinsic: ILIntrinsic¶
- property output: List[SSARegisterOrFlag]¶
- property param: LowLevelILCallParam¶
- property params: List[LowLevelILInstruction]¶
LowLevelILMods¶
- class LowLevelILMods[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
,Signed
LowLevelILMods(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILModsDp¶
- class LowLevelILModsDp[source]¶
Bases:
LowLevelILBinaryBase
,DoublePrecision
,Signed
LowLevelILModsDp(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILModu¶
- class LowLevelILModu[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILModu(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILModuDp¶
- class LowLevelILModuDp[source]¶
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILModuDp(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILMul¶
- class LowLevelILMul[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILMul(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILMulsDp¶
- class LowLevelILMulsDp[source]¶
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILMulsDp(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILMuluDp¶
- class LowLevelILMuluDp[source]¶
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILMuluDp(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILNeg¶
- class LowLevelILNeg[source]¶
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILNeg(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILNop¶
- class LowLevelILNop[source]¶
Bases:
LowLevelILInstruction
LowLevelILNop(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILNoret¶
- class LowLevelILNoret[source]¶
Bases:
LowLevelILInstruction
,Terminal
LowLevelILNoret(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILNot¶
- class LowLevelILNot[source]¶
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILNot(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILOperationAndSize¶
- class LowLevelILOperationAndSize[source]¶
Bases:
object
LowLevelILOperationAndSize(operation: ‘LowLevelILOperation’, size: int)
- __init__(operation: LowLevelILOperation, size: int) None ¶
- Parameters:
operation (LowLevelILOperation) –
size (int) –
- Return type:
None
- operation: LowLevelILOperation¶
LowLevelILOr¶
- class LowLevelILOr[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILOr(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILPop¶
- class LowLevelILPop[source]¶
Bases:
LowLevelILInstruction
,StackOperation
LowLevelILPop(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILPush¶
- class LowLevelILPush[source]¶
Bases:
LowLevelILInstruction
,StackOperation
LowLevelILPush(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILReg¶
- class LowLevelILReg[source]¶
Bases:
LowLevelILInstruction
LowLevelILReg(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: ILRegister¶
LowLevelILRegPhi¶
- class LowLevelILRegPhi[source]¶
Bases:
LowLevelILInstruction
,Phi
LowLevelILRegPhi(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: SSARegister¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: List[SSARegister]¶
LowLevelILRegSplit¶
- class LowLevelILRegSplit[source]¶
Bases:
LowLevelILInstruction
LowLevelILRegSplit(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property hi: ILRegister¶
- property lo: ILRegister¶
LowLevelILRegSplitDestSsa¶
- class LowLevelILRegSplitDestSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILRegSplitDestSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: SSARegister¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILRegSplitSsa¶
- class LowLevelILRegSplitSsa[source]¶
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILRegSplitSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property hi: SSARegister¶
- property lo: SSARegister¶
LowLevelILRegSsa¶
- class LowLevelILRegSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILRegSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: SSARegister¶
LowLevelILRegSsaPartial¶
- class LowLevelILRegSsaPartial[source]¶
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILRegSsaPartial(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property full_reg: SSARegister¶
- property src: ILRegister¶
LowLevelILRegStackAbsSsa¶
- class LowLevelILRegStackAbsSsa[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackAbsSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: ILRegister¶
- property stack: SSARegisterStack¶
LowLevelILRegStackDestSsa¶
- class LowLevelILRegStackDestSsa[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackDestSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: SSARegisterStack¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: SSARegisterStack¶
LowLevelILRegStackFreeAbsSsa¶
- class LowLevelILRegStackFreeAbsSsa[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackFreeAbsSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: ILRegister¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property stack: LowLevelILInstruction¶
LowLevelILRegStackFreeReg¶
- class LowLevelILRegStackFreeReg[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackFreeReg(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: ILRegister¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILRegStackFreeRel¶
- class LowLevelILRegStackFreeRel[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackFreeRel(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property stack: ILRegisterStack¶
LowLevelILRegStackFreeRelSsa¶
- class LowLevelILRegStackFreeRelSsa[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackFreeRelSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property stack: LowLevelILInstruction¶
- property top: LowLevelILInstruction¶
LowLevelILRegStackPhi¶
- class LowLevelILRegStackPhi[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
,Phi
LowLevelILRegStackPhi(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: SSARegisterStack¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: List[SSARegisterStack]¶
LowLevelILRegStackPop¶
- class LowLevelILRegStackPop[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackPop(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property stack: ILRegisterStack¶
LowLevelILRegStackPush¶
- class LowLevelILRegStackPush[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackPush(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
- property stack: ILRegisterStack¶
LowLevelILRegStackRel¶
- class LowLevelILRegStackRel[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackRel(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
- property stack: ILRegisterStack¶
LowLevelILRegStackRelSsa¶
- class LowLevelILRegStackRelSsa[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackRelSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
- property stack: SSARegisterStack¶
- property top: LowLevelILInstruction¶
LowLevelILRet¶
- class LowLevelILRet[source]¶
Bases:
LowLevelILInstruction
,Return
LowLevelILRet(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILRlc¶
- class LowLevelILRlc[source]¶
Bases:
LowLevelILCarryBase
LowLevelILRlc(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILRol¶
- class LowLevelILRol[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILRol(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILRor¶
- class LowLevelILRor[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILRor(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILRoundToInt¶
- class LowLevelILRoundToInt[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILRoundToInt(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILRrc¶
- class LowLevelILRrc[source]¶
Bases:
LowLevelILCarryBase
LowLevelILRrc(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILSbb¶
- class LowLevelILSbb[source]¶
Bases:
LowLevelILCarryBase
LowLevelILSbb(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILSeparateParamListSsa¶
- class LowLevelILSeparateParamListSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILSeparateParamListSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: List[LowLevelILInstruction]¶
LowLevelILSetFlag¶
- class LowLevelILSetFlag[source]¶
Bases:
LowLevelILInstruction
LowLevelILSetFlag(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILSetFlagSsa¶
- class LowLevelILSetFlagSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILSetFlagSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILSetReg¶
- class LowLevelILSetReg[source]¶
Bases:
LowLevelILInstruction
,SetReg
LowLevelILSetReg(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: ILRegister¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILSetRegSplit¶
- class LowLevelILSetRegSplit[source]¶
Bases:
LowLevelILInstruction
,SetReg
LowLevelILSetRegSplit(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property hi: ILRegister¶
- property lo: ILRegister¶
- property src: LowLevelILInstruction¶
LowLevelILSetRegSplitSsa¶
- class LowLevelILSetRegSplitSsa[source]¶
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILSetRegSplitSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property hi: LowLevelILInstruction¶
- property lo: LowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILSetRegSsa¶
- class LowLevelILSetRegSsa[source]¶
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILSetRegSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: SSARegister¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILSetRegSsaPartial¶
- class LowLevelILSetRegSsaPartial[source]¶
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILSetRegSsaPartial(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: ILRegister¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property full_reg: SSARegister¶
- property src: LowLevelILInstruction¶
LowLevelILSetRegStackAbsSsa¶
- class LowLevelILSetRegStackAbsSsa[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILSetRegStackAbsSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: ILRegister¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
- property stack: LowLevelILInstruction¶
LowLevelILSetRegStackRel¶
- class LowLevelILSetRegStackRel[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILSetRegStackRel(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
- property stack: ILRegisterStack¶
LowLevelILSetRegStackRelSsa¶
- class LowLevelILSetRegStackRelSsa[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILSetRegStackRelSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
- property stack: LowLevelILInstruction¶
- property top: LowLevelILInstruction¶
LowLevelILStore¶
- class LowLevelILStore[source]¶
Bases:
LowLevelILInstruction
,Store
LowLevelILStore(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILStoreSsa¶
- class LowLevelILStoreSsa[source]¶
Bases:
LowLevelILInstruction
,Store
,SSA
LowLevelILStoreSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILSub¶
- class LowLevelILSub[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILSub(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILSx¶
- class LowLevelILSx[source]¶
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILSx(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILSyscall¶
- class LowLevelILSyscall[source]¶
Bases:
LowLevelILInstruction
,Syscall
LowLevelILSyscall(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILSyscallSsa¶
- class LowLevelILSyscallSsa[source]¶
Bases:
LowLevelILInstruction
,Syscall
,SSA
LowLevelILSyscallSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property output: List[SSARegister]¶
- property param: LowLevelILCallParam¶
- property params: List[LowLevelILInstruction]¶
- property stack: LowLevelILCallStackSsa¶
- property stack_reg: SSARegister¶
LowLevelILTailcall¶
- class LowLevelILTailcall[source]¶
Bases:
LowLevelILInstruction
,Tailcall
LowLevelILTailcall(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILTailcallSsa¶
- class LowLevelILTailcallSsa[source]¶
Bases:
LowLevelILInstruction
,Tailcall
,SSA
,Terminal
LowLevelILTailcallSsa(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property dest: LowLevelILInstruction¶
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property output: List[SSARegister]¶
- property param: LowLevelILCallParam¶
- property params: List[LowLevelILInstruction]¶
- property stack: LowLevelILInstruction¶
LowLevelILTestBit¶
- class LowLevelILTestBit[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILTestBit(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILTrap¶
- class LowLevelILTrap[source]¶
Bases:
LowLevelILInstruction
,Terminal
LowLevelILTrap(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
LowLevelILUnaryBase¶
- class LowLevelILUnaryBase[source]¶
Bases:
LowLevelILInstruction
,UnaryOperation
LowLevelILUnaryBase(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILUndef¶
- class LowLevelILUndef[source]¶
Bases:
LowLevelILInstruction
,Terminal
LowLevelILUndef(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILUnimpl¶
- class LowLevelILUnimpl[source]¶
Bases:
LowLevelILInstruction
LowLevelILUnimpl(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILUnimplMem¶
- class LowLevelILUnimplMem[source]¶
Bases:
LowLevelILInstruction
,Memory
LowLevelILUnimplMem(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- property detailed_operands: List[Tuple[str, LowLevelILOperationAndSize | ILRegister | ILFlag | ILIntrinsic | ILRegisterStack | int | Dict[int, int] | float | LowLevelILInstruction | Dict[RegisterStackName, int] | SSAFlag | SSARegister | SSARegisterStack | ILSemanticFlagClass | ILSemanticFlagGroup | LowLevelILFlagCondition | List[int] | List[LowLevelILInstruction] | List[ILFlag | ILRegister] | List[SSARegister] | List[SSARegisterStack] | List[SSAFlag] | List[SSARegisterOrFlag] | None, str]]¶
Returns a list of tuples containing the name of the operand, the operand, and the type of the operand. Useful for iterating over all operands of an instruction and sub-instructions.
- property src: LowLevelILInstruction¶
LowLevelILXor¶
- class LowLevelILXor[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILXor(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
LowLevelILZx¶
- class LowLevelILZx[source]¶
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILZx(function: ‘LowLevelILFunction’, expr_index: binaryninja.lowlevelil.ExpressionIndex, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[binaryninja.lowlevelil.InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
SSAFlag¶
SSARegister¶
- class SSARegister[source]¶
Bases:
object
SSARegister(reg: binaryninja.lowlevelil.ILRegister, version: int)
- __init__(reg: ILRegister, version: int) None ¶
- Parameters:
reg (ILRegister) –
version (int) –
- Return type:
None
- reg: ILRegister¶
SSARegisterOrFlag¶
- class SSARegisterOrFlag[source]¶
Bases:
object
SSARegisterOrFlag(reg_or_flag: Union[binaryninja.lowlevelil.ILRegister, binaryninja.lowlevelil.ILFlag], version: int)
- __init__(reg_or_flag: ILRegister | ILFlag, version: int) None ¶
- Parameters:
reg_or_flag (ILRegister | ILFlag) –
version (int) –
- Return type:
None
- reg_or_flag: ILRegister | ILFlag¶
SSARegisterStack¶
- class SSARegisterStack[source]¶
Bases:
object
SSARegisterStack(reg_stack: binaryninja.lowlevelil.ILRegisterStack, version: int)
- __init__(reg_stack: ILRegisterStack, version: int) None ¶
- Parameters:
reg_stack (ILRegisterStack) –
version (int) –
- Return type:
None
- reg_stack: ILRegisterStack¶