lowlevelil module¶
Class |
Description |
---|---|
The |
|
|
|
|
|
|
|
- class CoreLowLevelILInstruction[source]
Bases:
object
CoreLowLevelILInstruction(operation: binaryninja.enums.LowLevelILOperation, attributes: int, size: int, flags: int, source_operand: <function NewType.<locals>.new_type at 0x112ace310>, operands: Tuple[ExpressionIndex, ExpressionIndex, ExpressionIndex, 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILAdd[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAdd(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILAddOverflow[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAddOverflow(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILAnd[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAnd(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILAsr[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAsr(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILAssert[source]
Bases:
LowLevelILInstruction
LowLevelILAssert(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: ILRegister
- class LowLevelILAssertSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILAssertSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property left: LowLevelILInstruction
- property right: LowLevelILInstruction
- class LowLevelILBoolToInt[source]
Bases:
LowLevelILInstruction
LowLevelILBoolToInt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILBp[source]
Bases:
LowLevelILInstruction
,Terminal
LowLevelILBp(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILCall[source]
Bases:
LowLevelILInstruction
,Localcall
LowLevelILCall(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILCallOutputSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILCallOutputSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILCallParam[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILCallParam(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: List[LowLevelILInstruction]
- class LowLevelILCallSsa[source]
Bases:
LowLevelILInstruction
,Localcall
,SSA
LowLevelILCallSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property stack_adjustment: int
- class LowLevelILCallStackSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILCallStackSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: SSARegister
- property src_memory: int
- class LowLevelILCarryBase[source]
Bases:
LowLevelILInstruction
,Carry
LowLevelILCarryBase(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property left: LowLevelILInstruction
- property right: LowLevelILInstruction
- class LowLevelILCeil[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILCeil(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILCmpE[source]
Bases:
LowLevelILComparisonBase
LowLevelILCmpE(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILCmpNe[source]
Bases:
LowLevelILComparisonBase
LowLevelILCmpNe(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILCmpSge[source]
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSge(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILCmpSgt[source]
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSgt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILCmpSle[source]
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSle(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILCmpSlt[source]
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSlt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILCmpUge[source]
Bases:
LowLevelILComparisonBase
LowLevelILCmpUge(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILCmpUgt[source]
Bases:
LowLevelILComparisonBase
LowLevelILCmpUgt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILCmpUle[source]
Bases:
LowLevelILComparisonBase
LowLevelILCmpUle(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILCmpUlt[source]
Bases:
LowLevelILComparisonBase
LowLevelILCmpUlt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILComparisonBase[source]
Bases:
LowLevelILBinaryBase
,Comparison
LowLevelILComparisonBase(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILConst[source]
Bases:
LowLevelILConstantBase
LowLevelILConst(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILConstPtr[source]
Bases:
LowLevelILConstantBase
LowLevelILConstPtr(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILConstantBase[source]
Bases:
LowLevelILInstruction
,Constant
LowLevelILConstantBase(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILDivs[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
,Signed
LowLevelILDivs(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILDivsDp[source]
Bases:
LowLevelILBinaryBase
,DoublePrecision
,Signed
LowLevelILDivsDp(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILDivu[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILDivu(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILDivuDp[source]
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILDivuDp(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property offset: int
- class LowLevelILFabs[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFabs(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILFadd[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFadd(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILFcmpE[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpE(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILFcmpGe[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpGe(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILFcmpGt[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpGt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILFcmpLe[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpLe(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILFcmpLt[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpLt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILFcmpNe[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpNe(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILFcmpO[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpO(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILFcmpUo[source]
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpUo(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILFdiv[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFdiv(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILFlag[source]
Bases:
LowLevelILInstruction
LowLevelILFlag(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: ILFlag
- class LowLevelILFlagBit[source]
Bases:
LowLevelILInstruction
LowLevelILFlagBit(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: ILFlag
- class LowLevelILFlagBitSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILFlagBitSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: SSAFlag
- class LowLevelILFlagCond[source]
Bases:
LowLevelILInstruction
LowLevelILFlagCond(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property semantic_class: ILSemanticFlagClass | None
- class LowLevelILFlagGroup[source]
Bases:
LowLevelILInstruction
LowLevelILFlagGroup(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property semantic_group: ILSemanticFlagGroup
- class LowLevelILFlagPhi[source]
Bases:
LowLevelILInstruction
,Phi
LowLevelILFlagPhi(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILFlagSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILFlagSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: SSAFlag
- class LowLevelILFloatConst[source]
Bases:
LowLevelILConstantBase
,FloatingPoint
LowLevelILFloatConst(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILFloatConv[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFloatConv(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILFloatToInt[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFloatToInt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILFloor[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFloor(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILFmul[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFmul(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILFneg[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFneg(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILForceVer[source]
Bases:
LowLevelILInstruction
LowLevelILForceVer(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILForceVerSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILForceVerSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: SSARegister
- class LowLevelILFsqrt[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFsqrt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILFsub[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFsub(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILFtrunc[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFtrunc(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- 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_exits_for_instr(idx: InstructionIndex) List[InstructionIndex] [source]
- Parameters:
idx (InstructionIndex) –
- Return type:
List[InstructionIndex]
- 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_instructions_at(addr: int, arch: Architecture | None = None) List[InstructionIndex] [source]
get_instructions_at
gets the InstructionIndex(s) corresponding to the given virtual address See the docs for mappings between ils for more information.- Parameters:
addr (int) – virtual address of the instruction to be queried
arch (Architecture) – (optional) Architecture for the given function
- Return type:
list(InstructionIndex)
- Example:
>>> func = next(bv.functions) >>> func.llil.get_instructions_at(func.start) [0]
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILIf[source]
Bases:
LowLevelILInstruction
,ControlFlow
LowLevelILIf(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- property false: InstructionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILIntrinsic[source]
Bases:
LowLevelILInstruction
,Intrinsic
LowLevelILIntrinsic(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILJumpTo[source]
Bases:
LowLevelILInstruction
LowLevelILJumpTo(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILLoadSsa[source]
Bases:
LowLevelILInstruction
,Load
,SSA
LowLevelILLoadSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- property src_memory: int
- class LowLevelILLowPart[source]
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILLowPart(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILLsl[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILLsl(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILLsr[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILLsr(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILMemPhi[source]
Bases:
LowLevelILInstruction
,Memory
,Phi
LowLevelILMemPhi(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILMemoryIntrinsicOutputSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILMemoryIntrinsicOutputSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property output: List[SSARegisterOrFlag]
- class LowLevelILMemoryIntrinsicSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILMemoryIntrinsicSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILModsDp[source]
Bases:
LowLevelILBinaryBase
,DoublePrecision
,Signed
LowLevelILModsDp(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILModu[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILModu(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILModuDp[source]
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILModuDp(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILMul[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILMul(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILMulsDp[source]
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILMulsDp(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILMuluDp[source]
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILMuluDp(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILNeg[source]
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILNeg(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILNop[source]
Bases:
LowLevelILInstruction
LowLevelILNop(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILNoret[source]
Bases:
LowLevelILInstruction
,Terminal
LowLevelILNoret(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILNot[source]
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILNot(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILPop[source]
Bases:
LowLevelILInstruction
,StackOperation
LowLevelILPop(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILPush[source]
Bases:
LowLevelILInstruction
,StackOperation
LowLevelILPush(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILReg[source]
Bases:
LowLevelILInstruction
LowLevelILReg(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: ILRegister
- class LowLevelILRegPhi[source]
Bases:
LowLevelILInstruction
,Phi
LowLevelILRegPhi(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: List[SSARegister]
- class LowLevelILRegSplit[source]
Bases:
LowLevelILInstruction
LowLevelILRegSplit(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- property hi: ILRegister
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property lo: ILRegister
- class LowLevelILRegSplitDestSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILRegSplitDestSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILRegSplitSsa[source]
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILRegSplitSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- property hi: SSARegister
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property lo: SSARegister
- class LowLevelILRegSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILRegSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: SSARegister
- class LowLevelILRegSsaPartial[source]
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILRegSsaPartial(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- property full_reg: SSARegister
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: ILRegister
- class LowLevelILRegStackAbsSsa[source]
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackAbsSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: ILRegister
- property stack: SSARegisterStack
- class LowLevelILRegStackDestSsa[source]
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackDestSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: SSARegisterStack
- class LowLevelILRegStackFreeAbsSsa[source]
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackFreeAbsSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property stack: LowLevelILInstruction
- class LowLevelILRegStackFreeReg[source]
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackFreeReg(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILRegStackFreeRel[source]
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackFreeRel(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property stack: ILRegisterStack
- class LowLevelILRegStackFreeRelSsa[source]
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackFreeRelSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property stack: LowLevelILInstruction
- property top: LowLevelILInstruction
- class LowLevelILRegStackPhi[source]
Bases:
LowLevelILInstruction
,RegisterStack
,Phi
LowLevelILRegStackPhi(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: List[SSARegisterStack]
- class LowLevelILRegStackPop[source]
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackPop(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property stack: ILRegisterStack
- class LowLevelILRegStackPush[source]
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackPush(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- property stack: ILRegisterStack
- class LowLevelILRegStackRel[source]
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackRel(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- property stack: ILRegisterStack
- class LowLevelILRegStackRelSsa[source]
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackRelSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- property stack: SSARegisterStack
- property top: LowLevelILInstruction
- class LowLevelILRet[source]
Bases:
LowLevelILInstruction
,Return
LowLevelILRet(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILRlc[source]
Bases:
LowLevelILCarryBase
LowLevelILRlc(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILRol[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILRol(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILRor[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILRor(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILRoundToInt[source]
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILRoundToInt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILRrc[source]
Bases:
LowLevelILCarryBase
LowLevelILRrc(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILSbb[source]
Bases:
LowLevelILCarryBase
LowLevelILSbb(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILSeparateParamListSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILSeparateParamListSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: List[LowLevelILInstruction]
- class LowLevelILSetFlag[source]
Bases:
LowLevelILInstruction
LowLevelILSetFlag(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILSetFlagSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILSetFlagSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILSetReg[source]
Bases:
LowLevelILInstruction
,SetReg
LowLevelILSetReg(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILSetRegSplit[source]
Bases:
LowLevelILInstruction
,SetReg
LowLevelILSetRegSplit(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- property hi: ILRegister
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property lo: ILRegister
- property src: LowLevelILInstruction
- class LowLevelILSetRegSplitSsa[source]
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILSetRegSplitSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- property hi: LowLevelILInstruction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property lo: LowLevelILInstruction
- property src: LowLevelILInstruction
- class LowLevelILSetRegSsa[source]
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILSetRegSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILSetRegSsaPartial[source]
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILSetRegSsaPartial(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- property full_reg: SSARegister
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILSetRegStackAbsSsa[source]
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILSetRegStackAbsSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- property stack: LowLevelILInstruction
- class LowLevelILSetRegStackRel[source]
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILSetRegStackRel(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- property stack: ILRegisterStack
- class LowLevelILSetRegStackRelSsa[source]
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILSetRegStackRelSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- property stack: LowLevelILInstruction
- property top: LowLevelILInstruction
- class LowLevelILSharedParamSlotSsa[source]
Bases:
LowLevelILInstruction
,SSA
LowLevelILSharedParamSlotSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: List[LowLevelILInstruction]
- class LowLevelILStore[source]
Bases:
LowLevelILInstruction
,Store
LowLevelILStore(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILStoreSsa[source]
Bases:
LowLevelILInstruction
,Store
,SSA
LowLevelILStoreSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- property src_memory: int
- class LowLevelILSub[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILSub(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILSx[source]
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILSx(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILSyscall[source]
Bases:
LowLevelILInstruction
,Syscall
LowLevelILSyscall(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILSyscallSsa[source]
Bases:
LowLevelILInstruction
,Syscall
,SSA
LowLevelILSyscallSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILTailcallSsa[source]
Bases:
LowLevelILInstruction
,Tailcall
,SSA
,Terminal
LowLevelILTailcallSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILTrap[source]
Bases:
LowLevelILInstruction
,Terminal
LowLevelILTrap(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property vector: int
- class LowLevelILUnaryBase[source]
Bases:
LowLevelILInstruction
,UnaryOperation
LowLevelILUnaryBase(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILUndef[source]
Bases:
LowLevelILInstruction
,Terminal
LowLevelILUndef(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILUnimpl[source]
Bases:
LowLevelILInstruction
LowLevelILUnimpl(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILUnimplMem[source]
Bases:
LowLevelILInstruction
,Memory
LowLevelILUnimplMem(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- property src: LowLevelILInstruction
- class LowLevelILXor[source]
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILXor(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | None
- class LowLevelILZx[source]
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILZx(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex
- function: LowLevelILFunction
- instr: CoreLowLevelILInstruction
- instr_index: InstructionIndex | 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: <function NewType.<locals>.new_type at 0x112ace310>, operands: Tuple[ExpressionIndex, ExpressionIndex, ExpressionIndex, 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILAdd¶
- class LowLevelILAdd[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAdd(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILAddOverflow¶
- class LowLevelILAddOverflow[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAddOverflow(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILAnd¶
- class LowLevelILAnd[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAnd(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILAsr¶
- class LowLevelILAsr[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILAsr(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILAssert¶
- class LowLevelILAssert[source]¶
Bases:
LowLevelILInstruction
LowLevelILAssert(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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¶
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: ILRegister¶
LowLevelILAssertSsa¶
- class LowLevelILAssertSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILAssertSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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¶
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property left: LowLevelILInstruction¶
- property right: LowLevelILInstruction¶
LowLevelILBoolToInt¶
- class LowLevelILBoolToInt[source]¶
Bases:
LowLevelILInstruction
LowLevelILBoolToInt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILBp¶
- class LowLevelILBp[source]¶
Bases:
LowLevelILInstruction
,Terminal
LowLevelILBp(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILCall¶
- class LowLevelILCall[source]¶
Bases:
LowLevelILInstruction
,Localcall
LowLevelILCall(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILCallOutputSsa¶
- class LowLevelILCallOutputSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILCallOutputSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILCallParam¶
- class LowLevelILCallParam[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILCallParam(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: List[LowLevelILInstruction]¶
LowLevelILCallSsa¶
- class LowLevelILCallSsa[source]¶
Bases:
LowLevelILInstruction
,Localcall
,SSA
LowLevelILCallSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILCallStackSsa¶
- class LowLevelILCallStackSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILCallStackSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: SSARegister¶
LowLevelILCarryBase¶
- class LowLevelILCarryBase[source]¶
Bases:
LowLevelILInstruction
,Carry
LowLevelILCarryBase(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property left: LowLevelILInstruction¶
- property right: LowLevelILInstruction¶
LowLevelILCeil¶
- class LowLevelILCeil[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILCeil(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILCmpE¶
- class LowLevelILCmpE[source]¶
Bases:
LowLevelILComparisonBase
LowLevelILCmpE(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILCmpNe¶
- class LowLevelILCmpNe[source]¶
Bases:
LowLevelILComparisonBase
LowLevelILCmpNe(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILCmpSge¶
- class LowLevelILCmpSge[source]¶
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSge(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILCmpSgt¶
- class LowLevelILCmpSgt[source]¶
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSgt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILCmpSle¶
- class LowLevelILCmpSle[source]¶
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSle(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILCmpSlt¶
- class LowLevelILCmpSlt[source]¶
Bases:
LowLevelILComparisonBase
,Signed
LowLevelILCmpSlt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILCmpUge¶
- class LowLevelILCmpUge[source]¶
Bases:
LowLevelILComparisonBase
LowLevelILCmpUge(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILCmpUgt¶
- class LowLevelILCmpUgt[source]¶
Bases:
LowLevelILComparisonBase
LowLevelILCmpUgt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILCmpUle¶
- class LowLevelILCmpUle[source]¶
Bases:
LowLevelILComparisonBase
LowLevelILCmpUle(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILCmpUlt¶
- class LowLevelILCmpUlt[source]¶
Bases:
LowLevelILComparisonBase
LowLevelILCmpUlt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILComparisonBase¶
- class LowLevelILComparisonBase[source]¶
Bases:
LowLevelILBinaryBase
,Comparison
LowLevelILComparisonBase(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILConst¶
- class LowLevelILConst[source]¶
Bases:
LowLevelILConstantBase
LowLevelILConst(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILConstPtr¶
- class LowLevelILConstPtr[source]¶
Bases:
LowLevelILConstantBase
LowLevelILConstPtr(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILConstantBase¶
- class LowLevelILConstantBase[source]¶
Bases:
LowLevelILInstruction
,Constant
LowLevelILConstantBase(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILDivs¶
- class LowLevelILDivs[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
,Signed
LowLevelILDivs(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILDivsDp¶
- class LowLevelILDivsDp[source]¶
Bases:
LowLevelILBinaryBase
,DoublePrecision
,Signed
LowLevelILDivsDp(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILDivu¶
- class LowLevelILDivu[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILDivu(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILDivuDp¶
- class LowLevelILDivuDp[source]¶
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILDivuDp(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILExpr¶
LowLevelILExternPtr¶
- class LowLevelILExternPtr[source]¶
Bases:
LowLevelILConstantBase
LowLevelILExternPtr(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFabs¶
- class LowLevelILFabs[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFabs(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILFadd¶
- class LowLevelILFadd[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFadd(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFcmpE¶
- class LowLevelILFcmpE[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpE(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFcmpGe¶
- class LowLevelILFcmpGe[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpGe(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFcmpGt¶
- class LowLevelILFcmpGt[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpGt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFcmpLe¶
- class LowLevelILFcmpLe[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpLe(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFcmpLt¶
- class LowLevelILFcmpLt[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpLt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFcmpNe¶
- class LowLevelILFcmpNe[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpNe(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFcmpO¶
- class LowLevelILFcmpO[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpO(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFcmpUo¶
- class LowLevelILFcmpUo[source]¶
Bases:
LowLevelILComparisonBase
,FloatingPoint
LowLevelILFcmpUo(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFdiv¶
- class LowLevelILFdiv[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFdiv(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFlag¶
- class LowLevelILFlag[source]¶
Bases:
LowLevelILInstruction
LowLevelILFlag(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFlagBit¶
- class LowLevelILFlagBit[source]¶
Bases:
LowLevelILInstruction
LowLevelILFlagBit(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFlagBitSsa¶
- class LowLevelILFlagBitSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILFlagBitSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFlagCond¶
- class LowLevelILFlagCond[source]¶
Bases:
LowLevelILInstruction
LowLevelILFlagCond(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property semantic_class: ILSemanticFlagClass | None¶
LowLevelILFlagGroup¶
- class LowLevelILFlagGroup[source]¶
Bases:
LowLevelILInstruction
LowLevelILFlagGroup(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property semantic_group: ILSemanticFlagGroup¶
LowLevelILFlagPhi¶
- class LowLevelILFlagPhi[source]¶
Bases:
LowLevelILInstruction
,Phi
LowLevelILFlagPhi(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFlagSsa¶
- class LowLevelILFlagSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILFlagSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFloatConst¶
- class LowLevelILFloatConst[source]¶
Bases:
LowLevelILConstantBase
,FloatingPoint
LowLevelILFloatConst(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFloatConv¶
- class LowLevelILFloatConv[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFloatConv(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILFloatToInt¶
- class LowLevelILFloatToInt[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFloatToInt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILFloor¶
- class LowLevelILFloor[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFloor(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILFmul¶
- class LowLevelILFmul[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFmul(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFneg¶
- class LowLevelILFneg[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFneg(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILForceVer¶
- class LowLevelILForceVer[source]¶
Bases:
LowLevelILInstruction
LowLevelILForceVer(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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¶
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILForceVerSsa¶
- class LowLevelILForceVerSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILForceVerSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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¶
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: SSARegister¶
LowLevelILFsqrt¶
- class LowLevelILFsqrt[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFsqrt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILFsub¶
- class LowLevelILFsub[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
,FloatingPoint
LowLevelILFsub(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILFtrunc¶
- class LowLevelILFtrunc[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILFtrunc(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- 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_exits_for_instr(idx: InstructionIndex) List[InstructionIndex] [source]¶
- Parameters:
idx (InstructionIndex) –
- Return type:
List[InstructionIndex]
- 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_instructions_at(addr: int, arch: Architecture | None = None) List[InstructionIndex] [source]¶
get_instructions_at
gets the InstructionIndex(s) corresponding to the given virtual address See the docs for mappings between ils for more information.- Parameters:
addr (int) – virtual address of the instruction to be queried
arch (Architecture) – (optional) Architecture for the given function
- Return type:
list(InstructionIndex)
- Example:
>>> func = next(bv.functions) >>> func.llil.get_instructions_at(func.start) [0]
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILIf¶
- class LowLevelILIf[source]¶
Bases:
LowLevelILInstruction
,ControlFlow
LowLevelILIf(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- property false: InstructionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILIntrinsic¶
- class LowLevelILIntrinsic[source]¶
Bases:
LowLevelILInstruction
,Intrinsic
LowLevelILIntrinsic(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILJumpTo¶
- class LowLevelILJumpTo[source]¶
Bases:
LowLevelILInstruction
LowLevelILJumpTo(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILLabel¶
LowLevelILLoad¶
- class LowLevelILLoad[source]¶
Bases:
LowLevelILInstruction
,Load
LowLevelILLoad(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILLoadSsa¶
- class LowLevelILLoadSsa[source]¶
Bases:
LowLevelILInstruction
,Load
,SSA
LowLevelILLoadSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILLowPart¶
- class LowLevelILLowPart[source]¶
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILLowPart(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILLsl¶
- class LowLevelILLsl[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILLsl(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILLsr¶
- class LowLevelILLsr[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILLsr(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILMemPhi¶
- class LowLevelILMemPhi[source]¶
Bases:
LowLevelILInstruction
,Memory
,Phi
LowLevelILMemPhi(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILMemoryIntrinsicOutputSsa¶
- class LowLevelILMemoryIntrinsicOutputSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILMemoryIntrinsicOutputSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property output: List[SSARegisterOrFlag]¶
LowLevelILMemoryIntrinsicSsa¶
- class LowLevelILMemoryIntrinsicSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILMemoryIntrinsicSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILModsDp¶
- class LowLevelILModsDp[source]¶
Bases:
LowLevelILBinaryBase
,DoublePrecision
,Signed
LowLevelILModsDp(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILModu¶
- class LowLevelILModu[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILModu(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILModuDp¶
- class LowLevelILModuDp[source]¶
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILModuDp(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILMul¶
- class LowLevelILMul[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILMul(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILMulsDp¶
- class LowLevelILMulsDp[source]¶
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILMulsDp(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILMuluDp¶
- class LowLevelILMuluDp[source]¶
Bases:
LowLevelILBinaryBase
,DoublePrecision
LowLevelILMuluDp(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILNeg¶
- class LowLevelILNeg[source]¶
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILNeg(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILNop¶
- class LowLevelILNop[source]¶
Bases:
LowLevelILInstruction
LowLevelILNop(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILNoret¶
- class LowLevelILNoret[source]¶
Bases:
LowLevelILInstruction
,Terminal
LowLevelILNoret(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILNot¶
- class LowLevelILNot[source]¶
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILNot(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILPop¶
- class LowLevelILPop[source]¶
Bases:
LowLevelILInstruction
,StackOperation
LowLevelILPop(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILPush¶
- class LowLevelILPush[source]¶
Bases:
LowLevelILInstruction
,StackOperation
LowLevelILPush(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILReg¶
- class LowLevelILReg[source]¶
Bases:
LowLevelILInstruction
LowLevelILReg(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: ILRegister¶
LowLevelILRegPhi¶
- class LowLevelILRegPhi[source]¶
Bases:
LowLevelILInstruction
,Phi
LowLevelILRegPhi(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: List[SSARegister]¶
LowLevelILRegSplit¶
- class LowLevelILRegSplit[source]¶
Bases:
LowLevelILInstruction
LowLevelILRegSplit(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- property hi: ILRegister¶
- instr: CoreLowLevelILInstruction¶
- property lo: ILRegister¶
LowLevelILRegSplitDestSsa¶
- class LowLevelILRegSplitDestSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILRegSplitDestSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILRegSplitSsa¶
- class LowLevelILRegSplitSsa[source]¶
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILRegSplitSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- property hi: SSARegister¶
- instr: CoreLowLevelILInstruction¶
- property lo: SSARegister¶
LowLevelILRegSsa¶
- class LowLevelILRegSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILRegSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: SSARegister¶
LowLevelILRegSsaPartial¶
- class LowLevelILRegSsaPartial[source]¶
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILRegSsaPartial(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- property full_reg: SSARegister¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: ILRegister¶
LowLevelILRegStackAbsSsa¶
- class LowLevelILRegStackAbsSsa[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackAbsSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: ILRegister¶
- property stack: SSARegisterStack¶
LowLevelILRegStackDestSsa¶
- class LowLevelILRegStackDestSsa[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackDestSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: SSARegisterStack¶
LowLevelILRegStackFreeAbsSsa¶
- class LowLevelILRegStackFreeAbsSsa[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackFreeAbsSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property stack: LowLevelILInstruction¶
LowLevelILRegStackFreeReg¶
- class LowLevelILRegStackFreeReg[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackFreeReg(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILRegStackFreeRel¶
- class LowLevelILRegStackFreeRel[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackFreeRel(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property stack: ILRegisterStack¶
LowLevelILRegStackFreeRelSsa¶
- class LowLevelILRegStackFreeRelSsa[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackFreeRelSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property stack: LowLevelILInstruction¶
- property top: LowLevelILInstruction¶
LowLevelILRegStackPhi¶
- class LowLevelILRegStackPhi[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
,Phi
LowLevelILRegStackPhi(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: List[SSARegisterStack]¶
LowLevelILRegStackPop¶
- class LowLevelILRegStackPop[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackPop(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property stack: ILRegisterStack¶
LowLevelILRegStackPush¶
- class LowLevelILRegStackPush[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackPush(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
- property stack: ILRegisterStack¶
LowLevelILRegStackRel¶
- class LowLevelILRegStackRel[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILRegStackRel(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
- property stack: ILRegisterStack¶
LowLevelILRegStackRelSsa¶
- class LowLevelILRegStackRelSsa[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILRegStackRelSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
- property stack: SSARegisterStack¶
- property top: LowLevelILInstruction¶
LowLevelILRet¶
- class LowLevelILRet[source]¶
Bases:
LowLevelILInstruction
,Return
LowLevelILRet(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILRlc¶
- class LowLevelILRlc[source]¶
Bases:
LowLevelILCarryBase
LowLevelILRlc(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILRol¶
- class LowLevelILRol[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILRol(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILRor¶
- class LowLevelILRor[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILRor(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILRoundToInt¶
- class LowLevelILRoundToInt[source]¶
Bases:
LowLevelILInstruction
,FloatingPoint
,Arithmetic
LowLevelILRoundToInt(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILRrc¶
- class LowLevelILRrc[source]¶
Bases:
LowLevelILCarryBase
LowLevelILRrc(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILSbb¶
- class LowLevelILSbb[source]¶
Bases:
LowLevelILCarryBase
LowLevelILSbb(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILSeparateParamListSsa¶
- class LowLevelILSeparateParamListSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILSeparateParamListSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: List[LowLevelILInstruction]¶
LowLevelILSetFlag¶
- class LowLevelILSetFlag[source]¶
Bases:
LowLevelILInstruction
LowLevelILSetFlag(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILSetFlagSsa¶
- class LowLevelILSetFlagSsa[source]¶
Bases:
LowLevelILInstruction
,SSA
LowLevelILSetFlagSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILSetReg¶
- class LowLevelILSetReg[source]¶
Bases:
LowLevelILInstruction
,SetReg
LowLevelILSetReg(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILSetRegSplit¶
- class LowLevelILSetRegSplit[source]¶
Bases:
LowLevelILInstruction
,SetReg
LowLevelILSetRegSplit(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- property hi: ILRegister¶
- instr: CoreLowLevelILInstruction¶
- property lo: ILRegister¶
- property src: LowLevelILInstruction¶
LowLevelILSetRegSplitSsa¶
- class LowLevelILSetRegSplitSsa[source]¶
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILSetRegSplitSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- property hi: LowLevelILInstruction¶
- instr: CoreLowLevelILInstruction¶
- property lo: LowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILSetRegSsa¶
- class LowLevelILSetRegSsa[source]¶
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILSetRegSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILSetRegSsaPartial¶
- class LowLevelILSetRegSsaPartial[source]¶
Bases:
LowLevelILInstruction
,SetReg
,SSA
LowLevelILSetRegSsaPartial(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- property full_reg: SSARegister¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILSetRegStackAbsSsa¶
- class LowLevelILSetRegStackAbsSsa[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILSetRegStackAbsSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
- property stack: LowLevelILInstruction¶
LowLevelILSetRegStackRel¶
- class LowLevelILSetRegStackRel[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
LowLevelILSetRegStackRel(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
- property stack: ILRegisterStack¶
LowLevelILSetRegStackRelSsa¶
- class LowLevelILSetRegStackRelSsa[source]¶
Bases:
LowLevelILInstruction
,RegisterStack
,SSA
LowLevelILSetRegStackRelSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
- property stack: LowLevelILInstruction¶
- property top: LowLevelILInstruction¶
LowLevelILStore¶
- class LowLevelILStore[source]¶
Bases:
LowLevelILInstruction
,Store
LowLevelILStore(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILStoreSsa¶
- class LowLevelILStoreSsa[source]¶
Bases:
LowLevelILInstruction
,Store
,SSA
LowLevelILStoreSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILSub¶
- class LowLevelILSub[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILSub(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILSx¶
- class LowLevelILSx[source]¶
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILSx(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILSyscall¶
- class LowLevelILSyscall[source]¶
Bases:
LowLevelILInstruction
,Syscall
LowLevelILSyscall(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILSyscallSsa¶
- class LowLevelILSyscallSsa[source]¶
Bases:
LowLevelILInstruction
,Syscall
,SSA
LowLevelILSyscallSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILTailcallSsa¶
- class LowLevelILTailcallSsa[source]¶
Bases:
LowLevelILInstruction
,Tailcall
,SSA
,Terminal
LowLevelILTailcallSsa(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- 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: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILTrap¶
- class LowLevelILTrap[source]¶
Bases:
LowLevelILInstruction
,Terminal
LowLevelILTrap(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILUnaryBase¶
- class LowLevelILUnaryBase[source]¶
Bases:
LowLevelILInstruction
,UnaryOperation
LowLevelILUnaryBase(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILUndef¶
- class LowLevelILUndef[source]¶
Bases:
LowLevelILInstruction
,Terminal
LowLevelILUndef(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILUnimpl¶
- class LowLevelILUnimpl[source]¶
Bases:
LowLevelILInstruction
LowLevelILUnimpl(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILUnimplMem¶
- class LowLevelILUnimplMem[source]¶
Bases:
LowLevelILInstruction
,Memory
LowLevelILUnimplMem(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_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.
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
- property src: LowLevelILInstruction¶
LowLevelILXor¶
- class LowLevelILXor[source]¶
Bases:
LowLevelILBinaryBase
,Arithmetic
LowLevelILXor(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
LowLevelILZx¶
- class LowLevelILZx[source]¶
Bases:
LowLevelILUnaryBase
,Arithmetic
LowLevelILZx(function: ‘LowLevelILFunction’, expr_index: <function NewType.<locals>.new_type at 0x112ace310>, instr: binaryninja.lowlevelil.CoreLowLevelILInstruction, instr_index: Optional[InstructionIndex])
- __init__(function: LowLevelILFunction, expr_index: ExpressionIndex, instr: CoreLowLevelILInstruction, instr_index: InstructionIndex | None) None ¶
- Parameters:
function (LowLevelILFunction) –
expr_index (ExpressionIndex) –
instr (CoreLowLevelILInstruction) –
instr_index (InstructionIndex | None) –
- Return type:
None
- expr_index: ExpressionIndex¶
- function: LowLevelILFunction¶
- instr: CoreLowLevelILInstruction¶
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¶