binaryninja.lowlevelil.LowLevelILFunction¶

class binaryninja.lowlevelil.LowLevelILFunction(arch, handle=None, source_func=None)[source]¶

class LowLevelILFunction contains the list of LowLevelILExpr objects that make up a binaryninja.function. LowLevelILExpr objects can be added to the LowLevelILFunction by calling append and passing the result of the various class methods which return LowLevelILExpr 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 greather than

LLFC_UGT u> Unsigned greater than

LLFC_NEG

Negative

LLFC_POS

Positive

LLFC_O overflow Overflow

LLFC_NO !overflow No overflow

__init__(arch, handle=None, source_func=None)[source]¶

Methods

`__init__`(arch[, handle, source_func])
`add`(size, a, b[, flags])	`add` adds expression `a` to expression `b` potentially setting flags `flags` and returning
`add_carry`(size, a, b, carry[, flags])	`add_carry` adds with carry expression `a` to expression `b` potentially setting flags `flags` and
`add_label_for_address`(arch, addr)	`add_label_for_address` adds a low-level IL label for the given architecture `arch` at the given virtual
`add_label_list`(labels)	`add_label_list` returns a label list expression for the given list of LowLevelILLabel objects.
`add_operand_list`(operands)	`add_operand_list` returns an operand list expression for the given list of integer operands.
`and_expr`(size, a, b[, flags])	`and_expr` bitwise and’s expression `a` and expression `b` potentially setting flags `flags`
`append`(expr)	`append` adds the LowLevelILExpr `expr` to the current LowLevelILFunction.
`arith_shift_right`(size, a, b[, flags])	`arith_shift_right` shifts arithmatic right expression `a` by expression `b` potentially setting flags
`breakpoint`()	`breakpoint` returns a processor breakpoint expression.
`call`(dest)	`call` returns an expression which first pushes the address of the next instruction onto the stack then jumps
`call_stack_adjust`(dest, stack_adjust)	`call_stack_adjust` returns an expression which first pushes the address of the next instruction onto the stack
`ceil`(size, value[, flags])	`ceil` rounds a floating point value to an integer towards positive infinity
`clear_indirect_branches`()
`compare_equal`(size, a, b)	`compare_equal` returns comparison expression of size `size` checking if expression `a` is equal to
`compare_not_equal`(size, a, b)	`compare_not_equal` returns comparison expression of size `size` checking if expression `a` is not equal to
`compare_signed_greater_equal`(size, a, b)	`compare_signed_greater_equal` returns comparison expression of size `size` checking if expression `a` is
`compare_signed_greater_than`(size, a, b)	`compare_signed_greater_than` returns comparison expression of size `size` checking if expression `a` is
`compare_signed_less_equal`(size, a, b)	`compare_signed_less_equal` returns comparison expression of size `size` checking if expression `a` is
`compare_signed_less_than`(size, a, b)	`compare_signed_less_than` returns comparison expression of size `size` checking if expression `a` is
`compare_unsigned_greater_equal`(size, a, b)	`compare_unsigned_greater_equal` returns comparison expression of size `size` checking if expression `a`
`compare_unsigned_greater_than`(size, a, b)	`compare_unsigned_greater_than` returns comparison expression of size `size` checking if expression `a` is
`compare_unsigned_less_equal`(size, a, b)	`compare_unsigned_less_equal` returns comparison expression of size `size` checking if expression `a` is
`compare_unsigned_less_than`(size, a, b)	`compare_unsigned_less_than` returns comparison expression of size `size` checking if expression `a` is
`const`(size, value)	`const` returns an expression for the constant integer `value` with size `size`
`const_pointer`(size, value)	`const_pointer` returns an expression for the constant pointer `value` with size `size`
`div_double_prec_signed`(size, a, b[, flags])	`div_double_prec_signed` signed double precision divide using expression `a` as a
`div_double_prec_unsigned`(size, a, b[, flags])	`div_double_prec_unsigned` unsigned double precision divide using expression `a` as
`div_signed`(size, a, b[, flags])	`div_signed` signed divide expression `a` by expression `b` potentially setting flags `flags`
`div_unsigned`(size, a, b[, flags])	`div_unsigned` unsigned divide expression `a` by expression `b` potentially setting flags `flags`
`expr`(operation[, a, b, c, d, size, flags])
`finalize`()	`finalize` ends the function and computes the list of basic blocks.
`flag`(reg)	`flag` returns a flag expression for the given flag name.
`flag_bit`(size, reg, bit)	`flag_bit` sets the flag named `reg` and size `size` to the constant integer value `bit`
`flag_condition`(cond[, sem_class])	`flag_condition` returns a flag_condition expression for the given LowLevelILFlagCondition
`flag_group`(sem_group)	`flag_group` returns a flag_group expression for the given semantic flag group
`float_abs`(size, value[, flags])	`float_abs` returns absolute value of floating point expression `value` of size `size` potentially setting flags
`float_add`(size, a, b[, flags])	`float_add` adds floating point expression `a` to expression `b` potentially setting flags `flags`
`float_compare_equal`(size, a, b)	`float_compare_equal` returns floating point comparison expression of size `size` checking if
`float_compare_greater_equal`(size, a, b)	`float_compare_greater_equal` returns floating point comparison expression of size `size` checking if
`float_compare_greater_than`(size, a, b)	`float_compare_greater_than` returns floating point comparison expression of size `size` checking if
`float_compare_less_equal`(size, a, b)	`float_compare_less_equal` returns floating point comparison expression of size `size` checking if
`float_compare_less_than`(size, a, b)	`float_compare_less_than` returns floating point comparison expression of size `size` checking if
`float_compare_not_equal`(size, a, b)	`float_compare_not_equal` returns floating point comparison expression of size `size` checking if
`float_compare_unordered`(size, a, b)	`float_compare_unordered` returns floating point comparison expression of size `size` checking if
`float_const_double`(value)	`float_const_double` returns an expression for the double precision floating point value `value`
`float_const_raw`(size, value)	`float_const_raw` returns an expression for the constant raw binary floating point
`float_const_single`(value)	`float_const_single` returns an expression for the single precision floating point value `value`
`float_convert`(size, value[, flags])	`int_to_float` converts floating point value of expression `value` to size `size` potentially setting flags
`float_div`(size, a, b[, flags])	`float_div` divides floating point expression `a` by expression `b` potentially setting flags `flags`
`float_mult`(size, a, b[, flags])	`float_mult` multiplies floating point expression `a` by expression `b` potentially setting flags `flags`
`float_neg`(size, value[, flags])	`float_neg` returns sign negation of floating point expression `value` of size `size` potentially setting flags
`float_sqrt`(size, value[, flags])	`float_sqrt` returns square root of floating point expression `value` of size `size` potentially setting flags
`float_sub`(size, a, b[, flags])	`float_sub` subtracts floating point expression `b` from expression `a` potentially setting flags `flags`
`float_to_int`(size, value[, flags])	`float_to_int` returns integer value of floating point expression `value` of size `size` potentially setting flags
`float_trunc`(size, value[, flags])	`float_trunc` rounds a floating point value to an integer towards zero
`floor`(size, value[, flags])	`floor` rounds a floating point value to an integer towards negative infinity
`get_instruction_start`(addr[, arch])
`get_label_for_address`(arch, addr)	`get_label_for_address` returns the LowLevelILLabel for the given Architecture `arch` and IL address `addr`.
`get_mapped_medium_level_il_expr_index`(expr)
`get_mapped_medium_level_il_instruction_index`(instr)
`get_medium_level_il_expr_index`(expr)
`get_medium_level_il_instruction_index`(instr)
`get_non_ssa_instruction_index`(instr)
`get_ssa_flag_definition`(flag_ssa)
`get_ssa_flag_uses`(flag_ssa)
`get_ssa_flag_value`(flag_ssa)
`get_ssa_instruction_index`(instr)
`get_ssa_memory_definition`(index)
`get_ssa_memory_uses`(index)
`get_ssa_reg_definition`(reg_ssa)
`get_ssa_reg_uses`(reg_ssa)
`get_ssa_reg_value`(reg_ssa)
`goto`(label)	`goto` returns a goto expression which jumps to the provided LowLevelILLabel.
`if_expr`(operand, t, f)	`if_expr` returns the `if` expression which depending on condition `operand` jumps to the LowLevelILLabel
`int_to_float`(size, value[, flags])	`int_to_float` returns floating point value of integer expression `value` of size `size` potentially setting flags
`intrinsic`(outputs, intrinsic, params[, flags])	`intrinsic` return an intrinsic expression.
`jump`(dest)	`jump` returns an expression which jumps (branches) to the expression `dest`
`load`(size, addr)	`load` Reads `size` bytes from the expression `addr`
`logical_shift_right`(size, a, b[, flags])	`logical_shift_right` shifts logically right expression `a` by expression `b` potentially setting flags
`low_part`(size, value[, flags])	`low_part` truncates `value` to `size` bytes
`mark_label`(label)	`mark_label` assigns a LowLevelILLabel to the current IL address.
`mod_double_prec_signed`(size, a, b[, flags])	`mod_double_prec_signed` signed double precision modulus using expression `a` as a single
`mod_double_prec_unsigned`(size, a, b[, flags])	`mod_double_prec_unsigned` unsigned double precision modulus using expression `a` as
`mod_signed`(size, a, b[, flags])	`mod_signed` signed modulus expression `a` by expression `b` potentially setting flags `flags`
`mod_unsigned`(size, a, b[, flags])	`mod_unsigned` unsigned modulus expression `a` by expression `b` potentially setting flags `flags`
`mult`(size, a, b[, flags])	`mult` multiplies expression `a` by expression `b` potentially setting flags `flags` and returning an
`mult_double_prec_signed`(size, a, b[, flags])	`mult_double_prec_signed` multiplies signed with double precision expression `a` by expression `b`
`mult_double_prec_unsigned`(size, a, b[, flags])	`mult_double_prec_unsigned` multiplies unsigned with double precision expression `a` by expression `b`
`neg_expr`(size, value[, flags])	`neg_expr` two’s complement sign negation of expression `value` of size `size` potentially setting flags
`no_ret`()	`no_ret` returns an expression halts disassembly
`nop`()	`nop` no operation, this instruction does nothing
`not_expr`(size, value[, flags])	`not_expr` bitwise inverse of expression `value` of size `size` potentially setting flags
`operand`(n, expr)	`operand` sets the operand number of the expression `expr` and passes back `expr` without modification.
`or_expr`(size, a, b[, flags])	`or_expr` bitwise or’s expression `a` and expression `b` potentially setting flags `flags`
`pop`(size)	`pop` reads `size` bytes from the stack, adjusting the stack by `size`.
`push`(size, value)	`push` writes `size` bytes from expression `value` to the stack, adjusting the stack by `size`.
`reg`(size, reg)	`reg` returns a register of size `size` with name `reg`
`reg_split`(size, hi, lo)	`reg_split` combines registers of size `size` with names `hi` and `lo`
`reg_stack_pop`(size, reg_stack)	`reg_stack_pop` returns the top entry of size `size` in register stack with name `reg_stack`, and
`reg_stack_push`(size, reg_stack, value[, flags])	`reg_stack_push` pushes the expression `value` of size `size` onto the top of the register
`reg_stack_top_relative`(size, reg_stack, entry)	`reg_stack_top_relative` returns a register stack entry of size `size` at top-relative
`ret`(dest)	`ret` returns an expression which jumps (branches) to the expression `dest`. `ret` is a special alias for
`rotate_left`(size, a, b[, flags])	`rotate_left` bitwise rotates left expression `a` by expression `b` potentially setting flags `flags`
`rotate_left_carry`(size, a, b, carry[, flags])	`rotate_left_carry` bitwise rotates left with carry expression `a` by expression `b` potentially setting
`rotate_right`(size, a, b[, flags])	`rotate_right` bitwise rotates right expression `a` by expression `b` potentially setting flags `flags`
`rotate_right_carry`(size, a, b, carry[, flags])	`rotate_right_carry` bitwise rotates right with carry expression `a` by expression `b` potentially setting
`round_to_int`(size, value[, flags])	`round_to_int` rounds a floating point value to the nearest integer
`set_current_address`(value[, arch])
`set_flag`(flag, value)	`set_flag` sets the flag `flag` to the LowLevelILExpr `value`
`set_indirect_branches`(branches)
`set_reg`(size, reg, value[, flags])	`set_reg` sets the register `reg` of size `size` to the expression `value`
`set_reg_split`(size, hi, lo, value[, flags])	`set_reg_split` uses `hi` and `lo` as a single extended register setting `hi:lo` to the expression
`set_reg_stack_top_relative`(size, reg_stack, ...)	`set_reg_stack_top_relative` sets the top-relative entry `entry` of size `size` in register
`shift_left`(size, a, b[, flags])	`shift_left` subtracts with borrow expression `b` from expression `a` potentially setting flags `flags`
`sign_extend`(size, value[, flags])	`sign_extend` two’s complement sign-extends the expression in `value` to `size` bytes
`store`(size, addr, value[, flags])	`store` Writes `size` bytes to expression `addr` read from expression `value`
`sub`(size, a, b[, flags])	`sub` subtracts expression `b` from expression `a` potentially setting flags `flags` and returning
`sub_borrow`(size, a, b, carry[, flags])	`sub_borrow` subtracts with borrow expression `b` from expression `a` potentially setting flags `flags`
`system_call`()	`system_call` return a system call expression.
`tailcall`(dest)	`tailcall` returns an expression which jumps (branches) to the expression `dest`
`test_bit`(size, a, b)
`trap`(value)	`trap` returns a processor trap (interrupt) expression of the given integer `value`.
`undefined`()	`undefined` returns the undefined expression. This should be used for instructions which perform functions but
`unimplemented`()	`unimplemented` returns the unimplemented expression. This should be used for all instructions which aren’t
`unimplemented_memory_ref`(size, addr)	`unimplemented_memory_ref` a memory reference to expression `addr` of size `size` with unimplemented operation.
`xor_expr`(size, a, b[, flags])	`xor_expr` xor’s expression `a` with expression `b` potentially setting flags `flags`
`zero_extend`(size, value[, flags])	`zero_extend` zero-extends the expression in `value` to `size` bytes

Attributes

`basic_blocks`	list of LowLevelILBasicBlock objects (read-only)
`current_address`	Current IL Address (read/write)
`mapped_medium_level_il`	Medium level IL with mappings between low level IL and medium level IL.
`medium_level_il`	Medium level IL for this low level IL.
`non_ssa_form`	Low level IL in non-SSA (default) form (read-only)
`ssa_form`	Low level IL in SSA form (read-only)
`temp_flag_count`	Number of temporary flags (read-only)
`temp_reg_count`	Number of temporary registers (read-only)