summaryrefslogtreecommitdiff
path: root/rust/src/hlil
diff options
context:
space:
mode:
authorRubens Brandao <git@rubens.io>2023-11-22 18:57:28 -0300
committerKyleMiles <krm504@nyu.edu>2024-02-02 13:32:45 -0500
commitf682ca69b356755fe6c06bcdd8f4fab73f7d2c78 (patch)
tree3cfc324cfe8043ccc8db1161f1f90c448d097c8a /rust/src/hlil
parente1a6bdcd576f7caeaa6f97ff1e337a259057b333 (diff)
Rust API : Add HLIL Bindings
Diffstat (limited to 'rust/src/hlil')
-rw-r--r--rust/src/hlil/block.rs63
-rw-r--r--rust/src/hlil/function.rs107
-rw-r--r--rust/src/hlil/instruction.rs1282
-rw-r--r--rust/src/hlil/lift.rs385
-rw-r--r--rust/src/hlil/mod.rs10
-rw-r--r--rust/src/hlil/operation.rs2373
6 files changed, 4220 insertions, 0 deletions
diff --git a/rust/src/hlil/block.rs b/rust/src/hlil/block.rs
new file mode 100644
index 00000000..a90429a4
--- /dev/null
+++ b/rust/src/hlil/block.rs
@@ -0,0 +1,63 @@
+use std::ops::Range;
+
+use binaryninjacore_sys::BNGetHighLevelILIndexForInstruction;
+
+use crate::basicblock::{BasicBlock, BlockContext};
+use crate::rc::Ref;
+
+use super::{HighLevelILFunction, HighLevelILInstruction};
+
+pub struct HighLevelILBlockIter {
+ function: Ref<HighLevelILFunction>,
+ range: Range<u64>,
+}
+
+impl Iterator for HighLevelILBlockIter {
+ type Item = HighLevelILInstruction;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.range
+ .next()
+ .map(|i| unsafe {
+ BNGetHighLevelILIndexForInstruction(self.function.handle, i as usize)
+ })
+ .map(|i| HighLevelILInstruction::new(&self.function, i))
+ }
+}
+
+pub struct HighLevelILBlock {
+ pub(crate) function: Ref<HighLevelILFunction>,
+}
+
+impl core::fmt::Debug for HighLevelILBlock {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ write!(f, "mlil_bb {:?}", self.function)
+ }
+}
+
+impl BlockContext for HighLevelILBlock {
+ type Iter = HighLevelILBlockIter;
+ type Instruction = HighLevelILInstruction;
+
+ fn start(&self, block: &BasicBlock<Self>) -> HighLevelILInstruction {
+ let expr_idx = unsafe {
+ BNGetHighLevelILIndexForInstruction(self.function.handle, block.raw_start() as usize)
+ };
+ HighLevelILInstruction::new(&self.function, expr_idx)
+ }
+
+ fn iter(&self, block: &BasicBlock<Self>) -> HighLevelILBlockIter {
+ HighLevelILBlockIter {
+ function: self.function.to_owned(),
+ range: block.raw_start()..block.raw_end(),
+ }
+ }
+}
+
+impl Clone for HighLevelILBlock {
+ fn clone(&self) -> Self {
+ HighLevelILBlock {
+ function: self.function.to_owned(),
+ }
+ }
+}
diff --git a/rust/src/hlil/function.rs b/rust/src/hlil/function.rs
new file mode 100644
index 00000000..40d01dfe
--- /dev/null
+++ b/rust/src/hlil/function.rs
@@ -0,0 +1,107 @@
+use std::hash::{Hash, Hasher};
+
+use binaryninjacore_sys::BNFreeHighLevelILFunction;
+use binaryninjacore_sys::BNGetHighLevelILBasicBlockList;
+use binaryninjacore_sys::BNGetHighLevelILInstructionCount;
+use binaryninjacore_sys::BNGetHighLevelILOwnerFunction;
+use binaryninjacore_sys::BNGetHighLevelILSSAForm;
+use binaryninjacore_sys::BNHighLevelILFunction;
+use binaryninjacore_sys::BNNewHighLevelILFunctionReference;
+
+use crate::basicblock::BasicBlock;
+use crate::function::Function;
+use crate::rc::{Array, Ref, RefCountable};
+
+use super::{HighLevelILBlock, HighLevelILInstruction};
+
+pub struct HighLevelILFunction {
+ pub(crate) full_ast: bool,
+ pub(crate) handle: *mut BNHighLevelILFunction,
+}
+
+unsafe impl Send for HighLevelILFunction {}
+unsafe impl Sync for HighLevelILFunction {}
+
+impl Eq for HighLevelILFunction {}
+impl PartialEq for HighLevelILFunction {
+ fn eq(&self, rhs: &Self) -> bool {
+ self.get_function().eq(&rhs.get_function())
+ }
+}
+
+impl Hash for HighLevelILFunction {
+ fn hash<H: Hasher>(&self, state: &mut H) {
+ self.get_function().hash(state)
+ }
+}
+
+impl HighLevelILFunction {
+ pub(crate) unsafe fn ref_from_raw(
+ handle: *mut BNHighLevelILFunction,
+ full_ast: bool,
+ ) -> Ref<Self> {
+ debug_assert!(!handle.is_null());
+ Self { handle, full_ast }.to_owned()
+ }
+
+ pub fn instruction_from_idx(&self, expr_idx: usize) -> HighLevelILInstruction {
+ HighLevelILInstruction::new(self, expr_idx)
+ }
+
+ pub fn instruction_count(&self) -> usize {
+ unsafe { BNGetHighLevelILInstructionCount(self.handle) }
+ }
+
+ pub fn ssa_form(&self) -> HighLevelILFunction {
+ let ssa = unsafe { BNGetHighLevelILSSAForm(self.handle) };
+ assert!(!ssa.is_null());
+ HighLevelILFunction {
+ handle: ssa,
+ full_ast: self.full_ast,
+ }
+ }
+
+ pub fn get_function(&self) -> Ref<Function> {
+ unsafe {
+ let func = BNGetHighLevelILOwnerFunction(self.handle);
+ Function::from_raw(func)
+ }
+ }
+
+ pub fn basic_blocks(&self) -> Array<BasicBlock<HighLevelILBlock>> {
+ let mut count = 0;
+ let blocks = unsafe { BNGetHighLevelILBasicBlockList(self.handle, &mut count) };
+ let context = HighLevelILBlock {
+ function: self.to_owned(),
+ };
+
+ unsafe { Array::new(blocks, count, context) }
+ }
+}
+
+impl ToOwned for HighLevelILFunction {
+ type Owned = Ref<Self>;
+
+ fn to_owned(&self) -> Self::Owned {
+ unsafe { RefCountable::inc_ref(self) }
+ }
+}
+
+unsafe impl RefCountable for HighLevelILFunction {
+ unsafe fn inc_ref(handle: &Self) -> Ref<Self> {
+ Ref::new(Self {
+ handle: BNNewHighLevelILFunctionReference(handle.handle),
+ full_ast: handle.full_ast,
+ })
+ }
+
+ unsafe fn dec_ref(handle: &Self) {
+ BNFreeHighLevelILFunction(handle.handle);
+ }
+}
+
+impl core::fmt::Debug for HighLevelILFunction {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ write!(f, "<hlil func handle {:p}>", self.handle)
+ }
+}
diff --git a/rust/src/hlil/instruction.rs b/rust/src/hlil/instruction.rs
new file mode 100644
index 00000000..acdc5cf7
--- /dev/null
+++ b/rust/src/hlil/instruction.rs
@@ -0,0 +1,1282 @@
+use binaryninjacore_sys::BNGetHighLevelILByIndex;
+use binaryninjacore_sys::BNHighLevelILOperation;
+
+use super::operation::*;
+use super::{HighLevelILFunction, HighLevelILLiftedInstruction};
+
+#[derive(Clone)]
+pub enum HighLevelILInstruction {
+ Adc(BinaryOpCarry),
+ Sbb(BinaryOpCarry),
+ Rlc(BinaryOpCarry),
+ Rrc(BinaryOpCarry),
+ Add(BinaryOp),
+ Sub(BinaryOp),
+ And(BinaryOp),
+ Or(BinaryOp),
+ Xor(BinaryOp),
+ Lsl(BinaryOp),
+ Lsr(BinaryOp),
+ Asr(BinaryOp),
+ Rol(BinaryOp),
+ Ror(BinaryOp),
+ Mul(BinaryOp),
+ MuluDp(BinaryOp),
+ MulsDp(BinaryOp),
+ Divu(BinaryOp),
+ DivuDp(BinaryOp),
+ Divs(BinaryOp),
+ DivsDp(BinaryOp),
+ Modu(BinaryOp),
+ ModuDp(BinaryOp),
+ Mods(BinaryOp),
+ ModsDp(BinaryOp),
+ CmpE(BinaryOp),
+ CmpNe(BinaryOp),
+ CmpSlt(BinaryOp),
+ CmpUlt(BinaryOp),
+ CmpSle(BinaryOp),
+ CmpUle(BinaryOp),
+ CmpSge(BinaryOp),
+ CmpUge(BinaryOp),
+ CmpSgt(BinaryOp),
+ CmpUgt(BinaryOp),
+ TestBit(BinaryOp),
+ AddOverflow(BinaryOp),
+ Fadd(BinaryOp),
+ Fsub(BinaryOp),
+ Fmul(BinaryOp),
+ Fdiv(BinaryOp),
+ FcmpE(BinaryOp),
+ FcmpNe(BinaryOp),
+ FcmpLt(BinaryOp),
+ FcmpLe(BinaryOp),
+ FcmpGe(BinaryOp),
+ FcmpGt(BinaryOp),
+ FcmpO(BinaryOp),
+ FcmpUo(BinaryOp),
+ ArrayIndex(ArrayIndex),
+ ArrayIndexSsa(ArrayIndexSsa),
+ Assign(Assign),
+ AssignMemSsa(AssignMemSsa),
+ AssignUnpack(AssignUnpack),
+ AssignUnpackMemSsa(AssignUnpackMemSsa),
+ Block(Block),
+ Call(Call),
+ Tailcall(Call),
+ CallSsa(CallSsa),
+ Case(Case),
+ Const(Const),
+ ConstPtr(Const),
+ Import(Const),
+ ConstData(ConstData),
+ Deref(UnaryOp),
+ AddressOf(UnaryOp),
+ Neg(UnaryOp),
+ Not(UnaryOp),
+ Sx(UnaryOp),
+ Zx(UnaryOp),
+ LowPart(UnaryOp),
+ BoolToInt(UnaryOp),
+ UnimplMem(UnaryOp),
+ Fsqrt(UnaryOp),
+ Fneg(UnaryOp),
+ Fabs(UnaryOp),
+ FloatToInt(UnaryOp),
+ IntToFloat(UnaryOp),
+ FloatConv(UnaryOp),
+ RoundToInt(UnaryOp),
+ Floor(UnaryOp),
+ Ceil(UnaryOp),
+ Ftrunc(UnaryOp),
+ DerefFieldSsa(DerefFieldSsa),
+ DerefSsa(DerefSsa),
+ ExternPtr(ExternPtr),
+ FloatConst(FloatConst),
+ For(ForLoop),
+ ForSsa(ForLoopSsa),
+ Goto(Label),
+ Label(Label),
+ If(If),
+ Intrinsic(Intrinsic),
+ IntrinsicSsa(IntrinsicSsa),
+ Jump(Jump),
+ MemPhi(MemPhi),
+ Nop(NoArgs),
+ Break(NoArgs),
+ Continue(NoArgs),
+ Noret(NoArgs),
+ Unreachable(NoArgs),
+ Bp(NoArgs),
+ Undef(NoArgs),
+ Unimpl(NoArgs),
+ Ret(Ret),
+ Split(Split),
+ StructField(StructField),
+ DerefField(StructField),
+ Switch(Switch),
+ Syscall(Syscall),
+ SyscallSsa(SyscallSsa),
+ Trap(Trap),
+ VarDeclare(Var),
+ Var(Var),
+ VarInit(VarInit),
+ VarInitSsa(VarInitSsa),
+ VarPhi(VarPhi),
+ VarSsa(VarSsa),
+ While(While),
+ DoWhile(While),
+ WhileSsa(WhileSsa),
+ DoWhileSsa(WhileSsa),
+}
+impl HighLevelILInstruction {
+ pub(crate) fn new(function: &HighLevelILFunction, idx: usize) -> Self {
+ let op = unsafe { BNGetHighLevelILByIndex(function.handle, idx, function.full_ast) };
+ use BNHighLevelILOperation::*;
+ use HighLevelILInstruction as Op;
+ match op.operation {
+ HLIL_ADC => Op::Adc(BinaryOpCarry::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ op.operands[2usize] as usize,
+ )),
+ HLIL_SBB => Op::Sbb(BinaryOpCarry::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ op.operands[2usize] as usize,
+ )),
+ HLIL_RLC => Op::Rlc(BinaryOpCarry::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ op.operands[2usize] as usize,
+ )),
+ HLIL_RRC => Op::Rrc(BinaryOpCarry::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ op.operands[2usize] as usize,
+ )),
+ HLIL_ADD => Op::Add(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_SUB => Op::Sub(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_AND => Op::And(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_OR => Op::Or(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_XOR => Op::Xor(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_LSL => Op::Lsl(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_LSR => Op::Lsr(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_ASR => Op::Asr(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_ROL => Op::Rol(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_ROR => Op::Ror(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_MUL => Op::Mul(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_MULU_DP => Op::MuluDp(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_MULS_DP => Op::MulsDp(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_DIVU => Op::Divu(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_DIVU_DP => Op::DivuDp(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_DIVS => Op::Divs(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_DIVS_DP => Op::DivsDp(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_MODU => Op::Modu(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_MODU_DP => Op::ModuDp(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_MODS => Op::Mods(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_MODS_DP => Op::ModsDp(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_CMP_E => Op::CmpE(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_CMP_NE => Op::CmpNe(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_CMP_SLT => Op::CmpSlt(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_CMP_ULT => Op::CmpUlt(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_CMP_SLE => Op::CmpSle(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_CMP_ULE => Op::CmpUle(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_CMP_SGE => Op::CmpSge(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_CMP_UGE => Op::CmpUge(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_CMP_SGT => Op::CmpSgt(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_CMP_UGT => Op::CmpUgt(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_TEST_BIT => Op::TestBit(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_ADD_OVERFLOW => Op::AddOverflow(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_FADD => Op::Fadd(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_FSUB => Op::Fsub(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_FMUL => Op::Fmul(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_FDIV => Op::Fdiv(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_FCMP_E => Op::FcmpE(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_FCMP_NE => Op::FcmpNe(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_FCMP_LT => Op::FcmpLt(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_FCMP_LE => Op::FcmpLe(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_FCMP_GE => Op::FcmpGe(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_FCMP_GT => Op::FcmpGt(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_FCMP_O => Op::FcmpO(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_FCMP_UO => Op::FcmpUo(BinaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_ARRAY_INDEX => Op::ArrayIndex(ArrayIndex::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_ARRAY_INDEX_SSA => Op::ArrayIndexSsa(ArrayIndexSsa::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize],
+ op.operands[2usize] as usize,
+ )),
+ HLIL_ASSIGN => Op::Assign(Assign::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_ASSIGN_MEM_SSA => Op::AssignMemSsa(AssignMemSsa::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize],
+ op.operands[2usize] as usize,
+ op.operands[3usize],
+ )),
+ HLIL_ASSIGN_UNPACK => Op::AssignUnpack(AssignUnpack::new(
+ function.to_owned(),
+ op.address,
+ (op.operands[0usize] as usize, op.operands[1usize] as usize),
+ op.operands[2usize] as usize,
+ )),
+ HLIL_ASSIGN_UNPACK_MEM_SSA => Op::AssignUnpackMemSsa(AssignUnpackMemSsa::new(
+ function.to_owned(),
+ op.address,
+ (op.operands[0usize] as usize, op.operands[1usize] as usize),
+ op.operands[2usize],
+ op.operands[3usize] as usize,
+ op.operands[4usize],
+ )),
+ HLIL_BLOCK => Op::Block(Block::new(
+ function.to_owned(),
+ op.address,
+ (op.operands[0usize] as usize, op.operands[1usize] as usize),
+ )),
+ HLIL_CALL => Op::Call(Call::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ (op.operands[1usize] as usize, op.operands[2usize] as usize),
+ )),
+ HLIL_TAILCALL => Op::Tailcall(Call::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ (op.operands[1usize] as usize, op.operands[2usize] as usize),
+ )),
+ HLIL_CALL_SSA => Op::CallSsa(CallSsa::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ (op.operands[1usize] as usize, op.operands[2usize] as usize),
+ op.operands[3usize],
+ op.operands[4usize],
+ )),
+ HLIL_CASE => Op::Case(Case::new(
+ function.to_owned(),
+ op.address,
+ (op.operands[0usize] as usize, op.operands[1usize] as usize),
+ op.operands[2usize] as usize,
+ )),
+ HLIL_CONST => Op::Const(Const::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize],
+ )),
+ HLIL_CONST_PTR => Op::ConstPtr(Const::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize],
+ )),
+ HLIL_IMPORT => Op::Import(Const::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize],
+ )),
+ HLIL_CONST_DATA => Op::ConstData(ConstData::new(
+ function.to_owned(),
+ op.address,
+ (
+ op.operands[0usize].try_into().unwrap(),
+ op.operands[1usize],
+ op.size,
+ ),
+ )),
+ HLIL_DEREF => Op::Deref(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_ADDRESS_OF => Op::AddressOf(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_NEG => Op::Neg(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_NOT => Op::Not(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_SX => Op::Sx(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_ZX => Op::Zx(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_LOW_PART => Op::LowPart(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_BOOL_TO_INT => Op::BoolToInt(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_UNIMPL_MEM => Op::UnimplMem(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_FSQRT => Op::Fsqrt(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_FNEG => Op::Fneg(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_FABS => Op::Fabs(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_FLOAT_TO_INT => Op::FloatToInt(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_INT_TO_FLOAT => Op::IntToFloat(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_FLOAT_CONV => Op::FloatConv(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_ROUND_TO_INT => Op::RoundToInt(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_FLOOR => Op::Floor(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_CEIL => Op::Ceil(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_FTRUNC => Op::Ftrunc(UnaryOp::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_DEREF_FIELD_SSA => Op::DerefFieldSsa(DerefFieldSsa::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize],
+ op.operands[2usize],
+ op.operands[3usize],
+ )),
+ HLIL_DEREF_SSA => Op::DerefSsa(DerefSsa::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize],
+ )),
+ HLIL_EXTERN_PTR => Op::ExternPtr(ExternPtr::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize],
+ op.operands[1usize],
+ )),
+ HLIL_FLOAT_CONST => Op::FloatConst(FloatConst::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize],
+ op.size,
+ )),
+ HLIL_FOR => Op::For(ForLoop::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ op.operands[2usize] as usize,
+ op.operands[3usize] as usize,
+ )),
+ HLIL_FOR_SSA => Op::ForSsa(ForLoopSsa::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ op.operands[2usize] as usize,
+ op.operands[3usize] as usize,
+ op.operands[4usize] as usize,
+ )),
+ HLIL_GOTO => Op::Goto(Label::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize],
+ )),
+ HLIL_LABEL => Op::Label(Label::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize],
+ )),
+ HLIL_IF => Op::If(If::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ op.operands[2usize] as usize,
+ )),
+ HLIL_INTRINSIC => Op::Intrinsic(Intrinsic::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as u32,
+ (op.operands[1usize] as usize, op.operands[2usize] as usize),
+ )),
+ HLIL_INTRINSIC_SSA => Op::IntrinsicSsa(IntrinsicSsa::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as u32,
+ (op.operands[1usize] as usize, op.operands[2usize] as usize),
+ op.operands[3usize],
+ op.operands[4usize],
+ )),
+ HLIL_JUMP => Op::Jump(Jump::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ )),
+ HLIL_MEM_PHI => Op::MemPhi(MemPhi::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize],
+ (op.operands[1usize] as usize, op.operands[2usize] as usize),
+ )),
+ HLIL_NOP => Op::Nop(NoArgs::new(function.to_owned(), op.address)),
+ HLIL_BREAK => Op::Break(NoArgs::new(function.to_owned(), op.address)),
+ HLIL_CONTINUE => Op::Continue(NoArgs::new(function.to_owned(), op.address)),
+ HLIL_NORET => Op::Noret(NoArgs::new(function.to_owned(), op.address)),
+ HLIL_UNREACHABLE => Op::Unreachable(NoArgs::new(function.to_owned(), op.address)),
+ HLIL_BP => Op::Bp(NoArgs::new(function.to_owned(), op.address)),
+ HLIL_UNDEF => Op::Undef(NoArgs::new(function.to_owned(), op.address)),
+ HLIL_UNIMPL => Op::Unimpl(NoArgs::new(function.to_owned(), op.address)),
+ HLIL_RET => Op::Ret(Ret::new(
+ function.to_owned(),
+ op.address,
+ (op.operands[0usize] as usize, op.operands[1usize] as usize),
+ )),
+ HLIL_SPLIT => Op::Split(Split::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_STRUCT_FIELD => Op::StructField(StructField::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize],
+ op.operands[2usize],
+ )),
+ HLIL_DEREF_FIELD => Op::DerefField(StructField::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize],
+ op.operands[2usize],
+ )),
+ HLIL_SWITCH => Op::Switch(Switch::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ (op.operands[2usize] as usize, op.operands[3usize] as usize),
+ )),
+ HLIL_SYSCALL => Op::Syscall(Syscall::new(
+ function.to_owned(),
+ op.address,
+ (op.operands[0usize] as usize, op.operands[1usize] as usize),
+ )),
+ HLIL_SYSCALL_SSA => Op::SyscallSsa(SyscallSsa::new(
+ function.to_owned(),
+ op.address,
+ (op.operands[0usize] as usize, op.operands[1usize] as usize),
+ op.operands[2usize],
+ op.operands[3usize],
+ )),
+ HLIL_TRAP => Op::Trap(Trap::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize],
+ )),
+ HLIL_VAR_DECLARE => Op::VarDeclare(Var::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize],
+ )),
+ HLIL_VAR => Op::Var(Var::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize],
+ )),
+ HLIL_VAR_INIT => Op::VarInit(VarInit::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize],
+ op.operands[1usize] as usize,
+ )),
+ HLIL_VAR_INIT_SSA => Op::VarInitSsa(VarInitSsa::new(
+ function.to_owned(),
+ op.address,
+ (op.operands[0usize], op.operands[1usize] as usize),
+ op.operands[2usize] as usize,
+ )),
+ HLIL_VAR_PHI => Op::VarPhi(VarPhi::new(
+ function.to_owned(),
+ op.address,
+ (op.operands[0usize], op.operands[1usize] as usize),
+ (op.operands[2usize] as usize, op.operands[3usize] as usize),
+ )),
+ HLIL_VAR_SSA => Op::VarSsa(VarSsa::new(
+ function.to_owned(),
+ op.address,
+ (op.operands[0usize], op.operands[1usize] as usize),
+ )),
+ HLIL_WHILE => Op::While(While::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_DO_WHILE => Op::DoWhile(While::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ )),
+ HLIL_WHILE_SSA => Op::WhileSsa(WhileSsa::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ op.operands[2usize] as usize,
+ )),
+ HLIL_DO_WHILE_SSA => Op::DoWhileSsa(WhileSsa::new(
+ function.to_owned(),
+ op.address,
+ op.operands[0usize] as usize,
+ op.operands[1usize] as usize,
+ op.operands[2usize] as usize,
+ )),
+ }
+ }
+ pub fn function(&self) -> &HighLevelILFunction {
+ use HighLevelILInstruction::*;
+ match self {
+ Adc(op) => &op.function,
+ Sbb(op) => &op.function,
+ Rlc(op) => &op.function,
+ Rrc(op) => &op.function,
+ Add(op) => &op.function,
+ Sub(op) => &op.function,
+ And(op) => &op.function,
+ Or(op) => &op.function,
+ Xor(op) => &op.function,
+ Lsl(op) => &op.function,
+ Lsr(op) => &op.function,
+ Asr(op) => &op.function,
+ Rol(op) => &op.function,
+ Ror(op) => &op.function,
+ Mul(op) => &op.function,
+ MuluDp(op) => &op.function,
+ MulsDp(op) => &op.function,
+ Divu(op) => &op.function,
+ DivuDp(op) => &op.function,
+ Divs(op) => &op.function,
+ DivsDp(op) => &op.function,
+ Modu(op) => &op.function,
+ ModuDp(op) => &op.function,
+ Mods(op) => &op.function,
+ ModsDp(op) => &op.function,
+ CmpE(op) => &op.function,
+ CmpNe(op) => &op.function,
+ CmpSlt(op) => &op.function,
+ CmpUlt(op) => &op.function,
+ CmpSle(op) => &op.function,
+ CmpUle(op) => &op.function,
+ CmpSge(op) => &op.function,
+ CmpUge(op) => &op.function,
+ CmpSgt(op) => &op.function,
+ CmpUgt(op) => &op.function,
+ TestBit(op) => &op.function,
+ AddOverflow(op) => &op.function,
+ Fadd(op) => &op.function,
+ Fsub(op) => &op.function,
+ Fmul(op) => &op.function,
+ Fdiv(op) => &op.function,
+ FcmpE(op) => &op.function,
+ FcmpNe(op) => &op.function,
+ FcmpLt(op) => &op.function,
+ FcmpLe(op) => &op.function,
+ FcmpGe(op) => &op.function,
+ FcmpGt(op) => &op.function,
+ FcmpO(op) => &op.function,
+ FcmpUo(op) => &op.function,
+ ArrayIndex(op) => &op.function,
+ ArrayIndexSsa(op) => &op.function,
+ Assign(op) => &op.function,
+ AssignMemSsa(op) => &op.function,
+ AssignUnpack(op) => &op.function,
+ AssignUnpackMemSsa(op) => &op.function,
+ Block(op) => &op.function,
+ Call(op) => &op.function,
+ Tailcall(op) => &op.function,
+ CallSsa(op) => &op.function,
+ Case(op) => &op.function,
+ Const(op) => &op.function,
+ ConstPtr(op) => &op.function,
+ Import(op) => &op.function,
+ ConstData(op) => &op.function,
+ Deref(op) => &op.function,
+ AddressOf(op) => &op.function,
+ Neg(op) => &op.function,
+ Not(op) => &op.function,
+ Sx(op) => &op.function,
+ Zx(op) => &op.function,
+ LowPart(op) => &op.function,
+ BoolToInt(op) => &op.function,
+ UnimplMem(op) => &op.function,
+ Fsqrt(op) => &op.function,
+ Fneg(op) => &op.function,
+ Fabs(op) => &op.function,
+ FloatToInt(op) => &op.function,
+ IntToFloat(op) => &op.function,
+ FloatConv(op) => &op.function,
+ RoundToInt(op) => &op.function,
+ Floor(op) => &op.function,
+ Ceil(op) => &op.function,
+ Ftrunc(op) => &op.function,
+ DerefFieldSsa(op) => &op.function,
+ DerefSsa(op) => &op.function,
+ ExternPtr(op) => &op.function,
+ FloatConst(op) => &op.function,
+ For(op) => &op.function,
+ ForSsa(op) => &op.function,
+ Goto(op) => &op.function,
+ Label(op) => &op.function,
+ If(op) => &op.function,
+ Intrinsic(op) => &op.function,
+ IntrinsicSsa(op) => &op.function,
+ Jump(op) => &op.function,
+ MemPhi(op) => &op.function,
+ Nop(op) => &op.function,
+ Break(op) => &op.function,
+ Continue(op) => &op.function,
+ Noret(op) => &op.function,
+ Unreachable(op) => &op.function,
+ Bp(op) => &op.function,
+ Undef(op) => &op.function,
+ Unimpl(op) => &op.function,
+ Ret(op) => &op.function,
+ Split(op) => &op.function,
+ StructField(op) => &op.function,
+ DerefField(op) => &op.function,
+ Switch(op) => &op.function,
+ Syscall(op) => &op.function,
+ SyscallSsa(op) => &op.function,
+ Trap(op) => &op.function,
+ VarDeclare(op) => &op.function,
+ Var(op) => &op.function,
+ VarInit(op) => &op.function,
+ VarInitSsa(op) => &op.function,
+ VarPhi(op) => &op.function,
+ VarSsa(op) => &op.function,
+ While(op) => &op.function,
+ DoWhile(op) => &op.function,
+ WhileSsa(op) => &op.function,
+ DoWhileSsa(op) => &op.function,
+ }
+ }
+ pub fn address(&self) -> u64 {
+ use HighLevelILInstruction::*;
+ match self {
+ Adc(op) => op.address,
+ Sbb(op) => op.address,
+ Rlc(op) => op.address,
+ Rrc(op) => op.address,
+ Add(op) => op.address,
+ Sub(op) => op.address,
+ And(op) => op.address,
+ Or(op) => op.address,
+ Xor(op) => op.address,
+ Lsl(op) => op.address,
+ Lsr(op) => op.address,
+ Asr(op) => op.address,
+ Rol(op) => op.address,
+ Ror(op) => op.address,
+ Mul(op) => op.address,
+ MuluDp(op) => op.address,
+ MulsDp(op) => op.address,
+ Divu(op) => op.address,
+ DivuDp(op) => op.address,
+ Divs(op) => op.address,
+ DivsDp(op) => op.address,
+ Modu(op) => op.address,
+ ModuDp(op) => op.address,
+ Mods(op) => op.address,
+ ModsDp(op) => op.address,
+ CmpE(op) => op.address,
+ CmpNe(op) => op.address,
+ CmpSlt(op) => op.address,
+ CmpUlt(op) => op.address,
+ CmpSle(op) => op.address,
+ CmpUle(op) => op.address,
+ CmpSge(op) => op.address,
+ CmpUge(op) => op.address,
+ CmpSgt(op) => op.address,
+ CmpUgt(op) => op.address,
+ TestBit(op) => op.address,
+ AddOverflow(op) => op.address,
+ Fadd(op) => op.address,
+ Fsub(op) => op.address,
+ Fmul(op) => op.address,
+ Fdiv(op) => op.address,
+ FcmpE(op) => op.address,
+ FcmpNe(op) => op.address,
+ FcmpLt(op) => op.address,
+ FcmpLe(op) => op.address,
+ FcmpGe(op) => op.address,
+ FcmpGt(op) => op.address,
+ FcmpO(op) => op.address,
+ FcmpUo(op) => op.address,
+ ArrayIndex(op) => op.address,
+ ArrayIndexSsa(op) => op.address,
+ Assign(op) => op.address,
+ AssignMemSsa(op) => op.address,
+ AssignUnpack(op) => op.address,
+ AssignUnpackMemSsa(op) => op.address,
+ Block(op) => op.address,
+ Call(op) => op.address,
+ Tailcall(op) => op.address,
+ CallSsa(op) => op.address,
+ Case(op) => op.address,
+ Const(op) => op.address,
+ ConstPtr(op) => op.address,
+ Import(op) => op.address,
+ ConstData(op) => op.address,
+ Deref(op) => op.address,
+ AddressOf(op) => op.address,
+ Neg(op) => op.address,
+ Not(op) => op.address,
+ Sx(op) => op.address,
+ Zx(op) => op.address,
+ LowPart(op) => op.address,
+ BoolToInt(op) => op.address,
+ UnimplMem(op) => op.address,
+ Fsqrt(op) => op.address,
+ Fneg(op) => op.address,
+ Fabs(op) => op.address,
+ FloatToInt(op) => op.address,
+ IntToFloat(op) => op.address,
+ FloatConv(op) => op.address,
+ RoundToInt(op) => op.address,
+ Floor(op) => op.address,
+ Ceil(op) => op.address,
+ Ftrunc(op) => op.address,
+ DerefFieldSsa(op) => op.address,
+ DerefSsa(op) => op.address,
+ ExternPtr(op) => op.address,
+ FloatConst(op) => op.address,
+ For(op) => op.address,
+ ForSsa(op) => op.address,
+ Goto(op) => op.address,
+ Label(op) => op.address,
+ If(op) => op.address,
+ Intrinsic(op) => op.address,
+ IntrinsicSsa(op) => op.address,
+ Jump(op) => op.address,
+ MemPhi(op) => op.address,
+ Nop(op) => op.address,
+ Break(op) => op.address,
+ Continue(op) => op.address,
+ Noret(op) => op.address,
+ Unreachable(op) => op.address,
+ Bp(op) => op.address,
+ Undef(op) => op.address,
+ Unimpl(op) => op.address,
+ Ret(op) => op.address,
+ Split(op) => op.address,
+ StructField(op) => op.address,
+ DerefField(op) => op.address,
+ Switch(op) => op.address,
+ Syscall(op) => op.address,
+ SyscallSsa(op) => op.address,
+ Trap(op) => op.address,
+ VarDeclare(op) => op.address,
+ Var(op) => op.address,
+ VarInit(op) => op.address,
+ VarInitSsa(op) => op.address,
+ VarPhi(op) => op.address,
+ VarSsa(op) => op.address,
+ While(op) => op.address,
+ DoWhile(op) => op.address,
+ WhileSsa(op) => op.address,
+ DoWhileSsa(op) => op.address,
+ }
+ }
+ pub fn lift(&self) -> HighLevelILLiftedInstruction {
+ use HighLevelILInstruction::*;
+ use HighLevelILLiftedInstruction as Lifted;
+ match self {
+ Nop(op) => Lifted::Nop(op.clone()),
+ Block(op) => Lifted::Block(op.lift()),
+ If(op) => Lifted::If(op.lift()),
+ While(op) => Lifted::While(op.lift()),
+ WhileSsa(op) => Lifted::WhileSsa(op.lift()),
+ DoWhile(op) => Lifted::DoWhile(op.lift()),
+ DoWhileSsa(op) => Lifted::DoWhileSsa(op.lift()),
+ For(op) => Lifted::For(op.lift()),
+ ForSsa(op) => Lifted::ForSsa(op.lift()),
+ Switch(op) => Lifted::Switch(op.lift()),
+ Case(op) => Lifted::Case(op.lift()),
+ Break(op) => Lifted::Break(op.clone()),
+ Continue(op) => Lifted::Continue(op.clone()),
+ Jump(op) => Lifted::Jump(op.clone()),
+ Ret(op) => Lifted::Ret(op.lift()),
+ Noret(op) => Lifted::Noret(op.clone()),
+ Unreachable(op) => Lifted::Unreachable(op.clone()),
+ Goto(op) => Lifted::Goto(op.clone()),
+ Label(op) => Lifted::Label(op.clone()),
+ VarDeclare(op) => Lifted::VarDeclare(op.clone()),
+ VarInit(op) => Lifted::VarInit(op.lift()),
+ VarInitSsa(op) => Lifted::VarInitSsa(op.lift()),
+ Assign(op) => Lifted::Assign(op.lift()),
+ AssignUnpack(op) => Lifted::AssignUnpack(op.lift()),
+ AssignMemSsa(op) => Lifted::AssignMemSsa(op.lift()),
+ AssignUnpackMemSsa(op) => Lifted::AssignUnpackMemSsa(op.lift()),
+ Var(op) => Lifted::Var(op.clone()),
+ VarSsa(op) => Lifted::VarSsa(op.clone()),
+ VarPhi(op) => Lifted::VarPhi(op.lift()),
+ MemPhi(op) => Lifted::MemPhi(op.lift()),
+ ArrayIndex(op) => Lifted::ArrayIndex(op.lift()),
+ ArrayIndexSsa(op) => Lifted::ArrayIndexSsa(op.lift()),
+ Split(op) => Lifted::Split(op.lift()),
+ Deref(op) => Lifted::Deref(op.lift()),
+ StructField(op) => Lifted::StructField(op.lift()),
+ DerefField(op) => Lifted::DerefField(op.lift()),
+ DerefSsa(op) => Lifted::DerefSsa(op.lift()),
+ DerefFieldSsa(op) => Lifted::DerefFieldSsa(op.lift()),
+ AddressOf(op) => Lifted::AddressOf(op.lift()),
+ Const(op) => Lifted::Const(op.clone()),
+ ConstPtr(op) => Lifted::ConstPtr(op.clone()),
+ ExternPtr(op) => Lifted::ExternPtr(op.clone()),
+ FloatConst(op) => Lifted::FloatConst(op.clone()),
+ Import(op) => Lifted::Import(op.clone()),
+ ConstData(op) => Lifted::ConstData(op.lift()),
+ Add(op) => Lifted::Add(op.lift()),
+ Adc(op) => Lifted::Adc(op.lift()),
+ Sub(op) => Lifted::Sub(op.lift()),
+ Sbb(op) => Lifted::Sbb(op.lift()),
+ And(op) => Lifted::And(op.lift()),
+ Or(op) => Lifted::Or(op.lift()),
+ Xor(op) => Lifted::Xor(op.lift()),
+ Lsl(op) => Lifted::Lsl(op.lift()),
+ Lsr(op) => Lifted::Lsr(op.lift()),
+ Asr(op) => Lifted::Asr(op.lift()),
+ Rol(op) => Lifted::Rol(op.lift()),
+ Rlc(op) => Lifted::Rlc(op.lift()),
+ Ror(op) => Lifted::Ror(op.lift()),
+ Rrc(op) => Lifted::Rrc(op.lift()),
+ Mul(op) => Lifted::Mul(op.lift()),
+ MuluDp(op) => Lifted::MuluDp(op.lift()),
+ MulsDp(op) => Lifted::MulsDp(op.lift()),
+ Divu(op) => Lifted::Divu(op.lift()),
+ DivuDp(op) => Lifted::DivuDp(op.lift()),
+ Divs(op) => Lifted::Divs(op.lift()),
+ DivsDp(op) => Lifted::DivsDp(op.lift()),
+ Modu(op) => Lifted::Modu(op.lift()),
+ ModuDp(op) => Lifted::ModuDp(op.lift()),
+ Mods(op) => Lifted::Mods(op.lift()),
+ ModsDp(op) => Lifted::ModsDp(op.lift()),
+ Neg(op) => Lifted::Neg(op.lift()),
+ Not(op) => Lifted::Not(op.lift()),
+ Sx(op) => Lifted::Sx(op.lift()),
+ Zx(op) => Lifted::Zx(op.lift()),
+ LowPart(op) => Lifted::LowPart(op.lift()),
+ Call(op) => Lifted::Call(op.lift()),
+ CallSsa(op) => Lifted::CallSsa(op.lift()),
+ CmpE(op) => Lifted::CmpE(op.lift()),
+ CmpNe(op) => Lifted::CmpNe(op.lift()),
+ CmpSlt(op) => Lifted::CmpSlt(op.lift()),
+ CmpUlt(op) => Lifted::CmpUlt(op.lift()),
+ CmpSle(op) => Lifted::CmpSle(op.lift()),
+ CmpUle(op) => Lifted::CmpUle(op.lift()),
+ CmpSge(op) => Lifted::CmpSge(op.lift()),
+ CmpUge(op) => Lifted::CmpUge(op.lift()),
+ CmpSgt(op) => Lifted::CmpSgt(op.lift()),
+ CmpUgt(op) => Lifted::CmpUgt(op.lift()),
+ TestBit(op) => Lifted::TestBit(op.lift()),
+ BoolToInt(op) => Lifted::BoolToInt(op.lift()),
+ AddOverflow(op) => Lifted::AddOverflow(op.lift()),
+ Syscall(op) => Lifted::Syscall(op.lift()),
+ SyscallSsa(op) => Lifted::SyscallSsa(op.lift()),
+ Tailcall(op) => Lifted::Tailcall(op.lift()),
+ Bp(op) => Lifted::Bp(op.clone()),
+ Trap(op) => Lifted::Trap(op.clone()),
+ Intrinsic(op) => Lifted::Intrinsic(op.lift()),
+ IntrinsicSsa(op) => Lifted::IntrinsicSsa(op.lift()),
+ Undef(op) => Lifted::Undef(op.clone()),
+ Unimpl(op) => Lifted::Unimpl(op.clone()),
+ UnimplMem(op) => Lifted::UnimplMem(op.lift()),
+ Fadd(op) => Lifted::Fadd(op.lift()),
+ Fsub(op) => Lifted::Fsub(op.lift()),
+ Fmul(op) => Lifted::Fmul(op.lift()),
+ Fdiv(op) => Lifted::Fdiv(op.lift()),
+ Fsqrt(op) => Lifted::Fsqrt(op.lift()),
+ Fneg(op) => Lifted::Fneg(op.lift()),
+ Fabs(op) => Lifted::Fabs(op.lift()),
+ FloatToInt(op) => Lifted::FloatToInt(op.lift()),
+ IntToFloat(op) => Lifted::IntToFloat(op.lift()),
+ FloatConv(op) => Lifted::FloatConv(op.lift()),
+ RoundToInt(op) => Lifted::RoundToInt(op.lift()),
+ Floor(op) => Lifted::Floor(op.lift()),
+ Ceil(op) => Lifted::Ceil(op.lift()),
+ Ftrunc(op) => Lifted::Ftrunc(op.lift()),
+ FcmpE(op) => Lifted::FcmpE(op.lift()),
+ FcmpNe(op) => Lifted::FcmpNe(op.lift()),
+ FcmpLt(op) => Lifted::FcmpLt(op.lift()),
+ FcmpLe(op) => Lifted::FcmpLe(op.lift()),
+ FcmpGe(op) => Lifted::FcmpGe(op.lift()),
+ FcmpGt(op) => Lifted::FcmpGt(op.lift()),
+ FcmpO(op) => Lifted::FcmpO(op.lift()),
+ FcmpUo(op) => Lifted::FcmpUo(op.lift()),
+ }
+ }
+ pub fn operands<'a>(
+ &'a self,
+ ) -> Box<dyn Iterator<Item = (&'static str, HighLevelILOperand)> + 'a> {
+ use HighLevelILInstruction::*;
+ match self {
+ Adc(op) | Sbb(op) | Rlc(op) | Rrc(op) => Box::new(op.operands()),
+ Add(op) | Sub(op) | And(op) | Or(op) | Xor(op) | Lsl(op) | Lsr(op) | Asr(op)
+ | Rol(op) | Ror(op) | Mul(op) | MuluDp(op) | MulsDp(op) | Divu(op) | DivuDp(op)
+ | Divs(op) | DivsDp(op) | Modu(op) | ModuDp(op) | Mods(op) | ModsDp(op) | CmpE(op)
+ | CmpNe(op) | CmpSlt(op) | CmpUlt(op) | CmpSle(op) | CmpUle(op) | CmpSge(op)
+ | CmpUge(op) | CmpSgt(op) | CmpUgt(op) | TestBit(op) | AddOverflow(op) | Fadd(op)
+ | Fsub(op) | Fmul(op) | Fdiv(op) | FcmpE(op) | FcmpNe(op) | FcmpLt(op) | FcmpLe(op)
+ | FcmpGe(op) | FcmpGt(op) | FcmpO(op) | FcmpUo(op) => Box::new(op.operands()),
+ ArrayIndex(op) => Box::new(op.operands()),
+ ArrayIndexSsa(op) => Box::new(op.operands()),
+ Assign(op) => Box::new(op.operands()),
+ AssignMemSsa(op) => Box::new(op.operands()),
+ AssignUnpack(op) => Box::new(op.operands()),
+ AssignUnpackMemSsa(op) => Box::new(op.operands()),
+ Block(op) => Box::new(op.operands()),
+ Call(op) | Tailcall(op) => Box::new(op.operands()),
+ CallSsa(op) => Box::new(op.operands()),
+ Case(op) => Box::new(op.operands()),
+ Const(op) | ConstPtr(op) | Import(op) => Box::new(op.operands()),
+ ConstData(op) => Box::new(op.operands()),
+ Deref(op) | AddressOf(op) | Neg(op) | Not(op) | Sx(op) | Zx(op) | LowPart(op)
+ | BoolToInt(op) | UnimplMem(op) | Fsqrt(op) | Fneg(op) | Fabs(op) | FloatToInt(op)
+ | IntToFloat(op) | FloatConv(op) | RoundToInt(op) | Floor(op) | Ceil(op)
+ | Ftrunc(op) => Box::new(op.operands()),
+ DerefFieldSsa(op) => Box::new(op.operands()),
+ DerefSsa(op) => Box::new(op.operands()),
+ ExternPtr(op) => Box::new(op.operands()),
+ FloatConst(op) => Box::new(op.operands()),
+ For(op) => Box::new(op.operands()),
+ ForSsa(op) => Box::new(op.operands()),
+ Goto(op) | Label(op) => Box::new(op.operands()),
+ If(op) => Box::new(op.operands()),
+ Intrinsic(op) => Box::new(op.operands()),
+ IntrinsicSsa(op) => Box::new(op.operands()),
+ Jump(op) => Box::new(op.operands()),
+ MemPhi(op) => Box::new(op.operands()),
+ Nop(op) | Break(op) | Continue(op) | Noret(op) | Unreachable(op) | Bp(op)
+ | Undef(op) | Unimpl(op) => Box::new(op.operands()),
+ Ret(op) => Box::new(op.operands()),
+ Split(op) => Box::new(op.operands()),
+ StructField(op) | DerefField(op) => Box::new(op.operands()),
+ Switch(op) => Box::new(op.operands()),
+ Syscall(op) => Box::new(op.operands()),
+ SyscallSsa(op) => Box::new(op.operands()),
+ Trap(op) => Box::new(op.operands()),
+ VarDeclare(op) | Var(op) => Box::new(op.operands()),
+ VarInit(op) => Box::new(op.operands()),
+ VarInitSsa(op) => Box::new(op.operands()),
+ VarPhi(op) => Box::new(op.operands()),
+ VarSsa(op) => Box::new(op.operands()),
+ While(op) | DoWhile(op) => Box::new(op.operands()),
+ WhileSsa(op) | DoWhileSsa(op) => Box::new(op.operands()),
+ }
+ }
+}
+
+impl core::fmt::Debug for HighLevelILInstruction {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ write!(
+ f,
+ "<{} at 0x{:08}>",
+ core::any::type_name::<Self>(),
+ self.address(),
+ )
+ }
+}
diff --git a/rust/src/hlil/lift.rs b/rust/src/hlil/lift.rs
new file mode 100644
index 00000000..5ed7a33c
--- /dev/null
+++ b/rust/src/hlil/lift.rs
@@ -0,0 +1,385 @@
+use super::{operation::*, HighLevelILFunction};
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum HighLevelILLiftedInstruction {
+ Adc(LiftedBinaryOpCarry),
+ Sbb(LiftedBinaryOpCarry),
+ Rlc(LiftedBinaryOpCarry),
+ Rrc(LiftedBinaryOpCarry),
+ Add(LiftedBinaryOp),
+ Sub(LiftedBinaryOp),
+ And(LiftedBinaryOp),
+ Or(LiftedBinaryOp),
+ Xor(LiftedBinaryOp),
+ Lsl(LiftedBinaryOp),
+ Lsr(LiftedBinaryOp),
+ Asr(LiftedBinaryOp),
+ Rol(LiftedBinaryOp),
+ Ror(LiftedBinaryOp),
+ Mul(LiftedBinaryOp),
+ MuluDp(LiftedBinaryOp),
+ MulsDp(LiftedBinaryOp),
+ Divu(LiftedBinaryOp),
+ DivuDp(LiftedBinaryOp),
+ Divs(LiftedBinaryOp),
+ DivsDp(LiftedBinaryOp),
+ Modu(LiftedBinaryOp),
+ ModuDp(LiftedBinaryOp),
+ Mods(LiftedBinaryOp),
+ ModsDp(LiftedBinaryOp),
+ CmpE(LiftedBinaryOp),
+ CmpNe(LiftedBinaryOp),
+ CmpSlt(LiftedBinaryOp),
+ CmpUlt(LiftedBinaryOp),
+ CmpSle(LiftedBinaryOp),
+ CmpUle(LiftedBinaryOp),
+ CmpSge(LiftedBinaryOp),
+ CmpUge(LiftedBinaryOp),
+ CmpSgt(LiftedBinaryOp),
+ CmpUgt(LiftedBinaryOp),
+ TestBit(LiftedBinaryOp),
+ AddOverflow(LiftedBinaryOp),
+ Fadd(LiftedBinaryOp),
+ Fsub(LiftedBinaryOp),
+ Fmul(LiftedBinaryOp),
+ Fdiv(LiftedBinaryOp),
+ FcmpE(LiftedBinaryOp),
+ FcmpNe(LiftedBinaryOp),
+ FcmpLt(LiftedBinaryOp),
+ FcmpLe(LiftedBinaryOp),
+ FcmpGe(LiftedBinaryOp),
+ FcmpGt(LiftedBinaryOp),
+ FcmpO(LiftedBinaryOp),
+ FcmpUo(LiftedBinaryOp),
+ ArrayIndex(LiftedArrayIndex),
+ ArrayIndexSsa(LiftedArrayIndexSsa),
+ Assign(LiftedAssign),
+ AssignMemSsa(LiftedAssignMemSsa),
+ AssignUnpack(LiftedAssignUnpack),
+ AssignUnpackMemSsa(LiftedAssignUnpackMemSsa),
+ Block(LiftedBlock),
+ Call(LiftedCall),
+ Tailcall(LiftedCall),
+ CallSsa(LiftedCallSsa),
+ Case(LiftedCase),
+ Const(Const),
+ ConstPtr(Const),
+ Import(Const),
+ ConstData(LiftedConstantData),
+ Deref(LiftedUnaryOp),
+ AddressOf(LiftedUnaryOp),
+ Neg(LiftedUnaryOp),
+ Not(LiftedUnaryOp),
+ Sx(LiftedUnaryOp),
+ Zx(LiftedUnaryOp),
+ LowPart(LiftedUnaryOp),
+ BoolToInt(LiftedUnaryOp),
+ UnimplMem(LiftedUnaryOp),
+ Fsqrt(LiftedUnaryOp),
+ Fneg(LiftedUnaryOp),
+ Fabs(LiftedUnaryOp),
+ FloatToInt(LiftedUnaryOp),
+ IntToFloat(LiftedUnaryOp),
+ FloatConv(LiftedUnaryOp),
+ RoundToInt(LiftedUnaryOp),
+ Floor(LiftedUnaryOp),
+ Ceil(LiftedUnaryOp),
+ Ftrunc(LiftedUnaryOp),
+ DerefFieldSsa(LiftedDerefFieldSsa),
+ DerefSsa(LiftedDerefSsa),
+ ExternPtr(ExternPtr),
+ FloatConst(FloatConst),
+ For(LiftedForLoop),
+ ForSsa(LiftedForLoopSsa),
+ Goto(Label),
+ Label(Label),
+ If(LiftedIf),
+ Intrinsic(LiftedIntrinsic),
+ IntrinsicSsa(LiftedIntrinsicSsa),
+ Jump(Jump),
+ MemPhi(LiftedMemPhi),
+ Nop(NoArgs),
+ Break(NoArgs),
+ Continue(NoArgs),
+ Noret(NoArgs),
+ Unreachable(NoArgs),
+ Bp(NoArgs),
+ Undef(NoArgs),
+ Unimpl(NoArgs),
+ Ret(LiftedRet),
+ Split(LiftedSplit),
+ StructField(LiftedStructField),
+ DerefField(LiftedStructField),
+ Switch(LiftedSwitch),
+ Syscall(LiftedSyscall),
+ SyscallSsa(LiftedSyscallSsa),
+ Trap(Trap),
+ VarDeclare(Var),
+ Var(Var),
+ VarInit(LiftedVarInit),
+ VarInitSsa(LiftedVarInitSsa),
+ VarPhi(LiftedVarPhi),
+ VarSsa(VarSsa),
+ While(LiftedWhile),
+ DoWhile(LiftedWhile),
+ WhileSsa(LiftedWhileSsa),
+ DoWhileSsa(LiftedWhileSsa),
+}
+
+impl HighLevelILLiftedInstruction {
+ pub fn address(&self) -> u64 {
+ use HighLevelILLiftedInstruction::*;
+ match self {
+ Adc(op) => op.address,
+ Sbb(op) => op.address,
+ Rlc(op) => op.address,
+ Rrc(op) => op.address,
+ Add(op) => op.address,
+ Sub(op) => op.address,
+ And(op) => op.address,
+ Or(op) => op.address,
+ Xor(op) => op.address,
+ Lsl(op) => op.address,
+ Lsr(op) => op.address,
+ Asr(op) => op.address,
+ Rol(op) => op.address,
+ Ror(op) => op.address,
+ Mul(op) => op.address,
+ MuluDp(op) => op.address,
+ MulsDp(op) => op.address,
+ Divu(op) => op.address,
+ DivuDp(op) => op.address,
+ Divs(op) => op.address,
+ DivsDp(op) => op.address,
+ Modu(op) => op.address,
+ ModuDp(op) => op.address,
+ Mods(op) => op.address,
+ ModsDp(op) => op.address,
+ CmpE(op) => op.address,
+ CmpNe(op) => op.address,
+ CmpSlt(op) => op.address,
+ CmpUlt(op) => op.address,
+ CmpSle(op) => op.address,
+ CmpUle(op) => op.address,
+ CmpSge(op) => op.address,
+ CmpUge(op) => op.address,
+ CmpSgt(op) => op.address,
+ CmpUgt(op) => op.address,
+ TestBit(op) => op.address,
+ AddOverflow(op) => op.address,
+ Fadd(op) => op.address,
+ Fsub(op) => op.address,
+ Fmul(op) => op.address,
+ Fdiv(op) => op.address,
+ FcmpE(op) => op.address,
+ FcmpNe(op) => op.address,
+ FcmpLt(op) => op.address,
+ FcmpLe(op) => op.address,
+ FcmpGe(op) => op.address,
+ FcmpGt(op) => op.address,
+ FcmpO(op) => op.address,
+ FcmpUo(op) => op.address,
+ ArrayIndex(op) => op.address,
+ ArrayIndexSsa(op) => op.address,
+ Assign(op) => op.address,
+ AssignMemSsa(op) => op.address,
+ AssignUnpack(op) => op.address,
+ AssignUnpackMemSsa(op) => op.address,
+ Block(op) => op.address,
+ Call(op) => op.address,
+ Tailcall(op) => op.address,
+ CallSsa(op) => op.address,
+ Case(op) => op.address,
+ Const(op) => op.address,
+ ConstPtr(op) => op.address,
+ Import(op) => op.address,
+ ConstData(op) => op.address,
+ Deref(op) => op.address,
+ AddressOf(op) => op.address,
+ Neg(op) => op.address,
+ Not(op) => op.address,
+ Sx(op) => op.address,
+ Zx(op) => op.address,
+ LowPart(op) => op.address,
+ BoolToInt(op) => op.address,
+ UnimplMem(op) => op.address,
+ Fsqrt(op) => op.address,
+ Fneg(op) => op.address,
+ Fabs(op) => op.address,
+ FloatToInt(op) => op.address,
+ IntToFloat(op) => op.address,
+ FloatConv(op) => op.address,
+ RoundToInt(op) => op.address,
+ Floor(op) => op.address,
+ Ceil(op) => op.address,
+ Ftrunc(op) => op.address,
+ DerefFieldSsa(op) => op.address,
+ DerefSsa(op) => op.address,
+ ExternPtr(op) => op.address,
+ FloatConst(op) => op.address,
+ For(op) => op.address,
+ ForSsa(op) => op.address,
+ Goto(op) => op.address,
+ Label(op) => op.address,
+ If(op) => op.address,
+ Intrinsic(op) => op.address,
+ IntrinsicSsa(op) => op.address,
+ Jump(op) => op.address,
+ MemPhi(op) => op.address,
+ Nop(op) => op.address,
+ Break(op) => op.address,
+ Continue(op) => op.address,
+ Noret(op) => op.address,
+ Unreachable(op) => op.address,
+ Bp(op) => op.address,
+ Undef(op) => op.address,
+ Unimpl(op) => op.address,
+ Ret(op) => op.address,
+ Split(op) => op.address,
+ StructField(op) => op.address,
+ DerefField(op) => op.address,
+ Switch(op) => op.address,
+ Syscall(op) => op.address,
+ SyscallSsa(op) => op.address,
+ Trap(op) => op.address,
+ VarDeclare(op) => op.address,
+ Var(op) => op.address,
+ VarInit(op) => op.address,
+ VarInitSsa(op) => op.address,
+ VarPhi(op) => op.address,
+ VarSsa(op) => op.address,
+ While(op) => op.address,
+ DoWhile(op) => op.address,
+ WhileSsa(op) => op.address,
+ DoWhileSsa(op) => op.address,
+ }
+ }
+
+ pub fn function(&self) -> &HighLevelILFunction {
+ use HighLevelILLiftedInstruction::*;
+ match self {
+ Adc(op) => &op.function,
+ Sbb(op) => &op.function,
+ Rlc(op) => &op.function,
+ Rrc(op) => &op.function,
+ Add(op) => &op.function,
+ Sub(op) => &op.function,
+ And(op) => &op.function,
+ Or(op) => &op.function,
+ Xor(op) => &op.function,
+ Lsl(op) => &op.function,
+ Lsr(op) => &op.function,
+ Asr(op) => &op.function,
+ Rol(op) => &op.function,
+ Ror(op) => &op.function,
+ Mul(op) => &op.function,
+ MuluDp(op) => &op.function,
+ MulsDp(op) => &op.function,
+ Divu(op) => &op.function,
+ DivuDp(op) => &op.function,
+ Divs(op) => &op.function,
+ DivsDp(op) => &op.function,
+ Modu(op) => &op.function,
+ ModuDp(op) => &op.function,
+ Mods(op) => &op.function,
+ ModsDp(op) => &op.function,
+ CmpE(op) => &op.function,
+ CmpNe(op) => &op.function,
+ CmpSlt(op) => &op.function,
+ CmpUlt(op) => &op.function,
+ CmpSle(op) => &op.function,
+ CmpUle(op) => &op.function,
+ CmpSge(op) => &op.function,
+ CmpUge(op) => &op.function,
+ CmpSgt(op) => &op.function,
+ CmpUgt(op) => &op.function,
+ TestBit(op) => &op.function,
+ AddOverflow(op) => &op.function,
+ Fadd(op) => &op.function,
+ Fsub(op) => &op.function,
+ Fmul(op) => &op.function,
+ Fdiv(op) => &op.function,
+ FcmpE(op) => &op.function,
+ FcmpNe(op) => &op.function,
+ FcmpLt(op) => &op.function,
+ FcmpLe(op) => &op.function,
+ FcmpGe(op) => &op.function,
+ FcmpGt(op) => &op.function,
+ FcmpO(op) => &op.function,
+ FcmpUo(op) => &op.function,
+ ArrayIndex(op) => &op.function,
+ ArrayIndexSsa(op) => &op.function,
+ Assign(op) => &op.function,
+ AssignMemSsa(op) => &op.function,
+ AssignUnpack(op) => &op.function,
+ AssignUnpackMemSsa(op) => &op.function,
+ Block(op) => &op.function,
+ Call(op) => &op.function,
+ Tailcall(op) => &op.function,
+ CallSsa(op) => &op.function,
+ Case(op) => &op.function,
+ Const(op) => &op.function,
+ ConstPtr(op) => &op.function,
+ Import(op) => &op.function,
+ ConstData(op) => &op.function,
+ Deref(op) => &op.function,
+ AddressOf(op) => &op.function,
+ Neg(op) => &op.function,
+ Not(op) => &op.function,
+ Sx(op) => &op.function,
+ Zx(op) => &op.function,
+ LowPart(op) => &op.function,
+ BoolToInt(op) => &op.function,
+ UnimplMem(op) => &op.function,
+ Fsqrt(op) => &op.function,
+ Fneg(op) => &op.function,
+ Fabs(op) => &op.function,
+ FloatToInt(op) => &op.function,
+ IntToFloat(op) => &op.function,
+ FloatConv(op) => &op.function,
+ RoundToInt(op) => &op.function,
+ Floor(op) => &op.function,
+ Ceil(op) => &op.function,
+ Ftrunc(op) => &op.function,
+ DerefFieldSsa(op) => &op.function,
+ DerefSsa(op) => &op.function,
+ ExternPtr(op) => &op.function,
+ FloatConst(op) => &op.function,
+ For(op) => &op.function,
+ ForSsa(op) => &op.function,
+ Goto(op) => &op.function,
+ Label(op) => &op.function,
+ If(op) => &op.function,
+ Intrinsic(op) => &op.function,
+ IntrinsicSsa(op) => &op.function,
+ Jump(op) => &op.function,
+ MemPhi(op) => &op.function,
+ Nop(op) => &op.function,
+ Break(op) => &op.function,
+ Continue(op) => &op.function,
+ Noret(op) => &op.function,
+ Unreachable(op) => &op.function,
+ Bp(op) => &op.function,
+ Undef(op) => &op.function,
+ Unimpl(op) => &op.function,
+ Ret(op) => &op.function,
+ Split(op) => &op.function,
+ StructField(op) => &op.function,
+ DerefField(op) => &op.function,
+ Switch(op) => &op.function,
+ Syscall(op) => &op.function,
+ SyscallSsa(op) => &op.function,
+ Trap(op) => &op.function,
+ VarDeclare(op) => &op.function,
+ Var(op) => &op.function,
+ VarInit(op) => &op.function,
+ VarInitSsa(op) => &op.function,
+ VarPhi(op) => &op.function,
+ VarSsa(op) => &op.function,
+ While(op) => &op.function,
+ DoWhile(op) => &op.function,
+ WhileSsa(op) => &op.function,
+ DoWhileSsa(op) => &op.function,
+ }
+ }
+}
diff --git a/rust/src/hlil/mod.rs b/rust/src/hlil/mod.rs
new file mode 100644
index 00000000..8a9103ac
--- /dev/null
+++ b/rust/src/hlil/mod.rs
@@ -0,0 +1,10 @@
+mod block;
+mod function;
+mod instruction;
+mod lift;
+pub mod operation;
+
+pub use self::block::*;
+pub use self::function::*;
+pub use self::instruction::*;
+pub use self::lift::*;
diff --git a/rust/src/hlil/operation.rs b/rust/src/hlil/operation.rs
new file mode 100644
index 00000000..769861e0
--- /dev/null
+++ b/rust/src/hlil/operation.rs
@@ -0,0 +1,2373 @@
+use binaryninjacore_sys::BNFromVariableIdentifier;
+use binaryninjacore_sys::BNGetGotoLabelName;
+use binaryninjacore_sys::BNGetHighLevelILByIndex;
+use binaryninjacore_sys::BNHighLevelILInstruction;
+use binaryninjacore_sys::BNHighLevelILOperation;
+
+use crate::function::Function;
+use crate::rc::Ref;
+use crate::types::{
+ ConstantData, ILIntrinsic, RegisterValue, RegisterValueType, SSAVariable, Variable,
+};
+
+use super::{HighLevelILFunction, HighLevelILInstruction, HighLevelILLiftedInstruction};
+
+pub enum HighLevelILOperand {
+ ConstantData(ConstantData),
+ Expr(HighLevelILInstruction),
+ ExprList(OperandExprList),
+ Float(f64),
+ Int(u64),
+ IntList(OperandList),
+ Intrinsic(ILIntrinsic),
+ Label(GotoLabel),
+ MemberIndex(Option<usize>),
+ Var(Variable),
+ VarSsa(SSAVariable),
+ VarSsaList(OperandSSAVariableList),
+}
+
+// Iterator for the get_list, this is better then a inline iterator because
+// this also implement ExactSizeIterator, what a inline iterator does not.
+pub struct OperandList {
+ function: Ref<HighLevelILFunction>,
+ remaining: usize,
+ next_node_idx: Option<usize>,
+
+ current_node: core::array::IntoIter<u64, 4>,
+}
+impl OperandList {
+ fn new(function: &HighLevelILFunction, idx: usize, number: usize) -> Self {
+ // alternative to core::array::IntoIter::empty();
+ let mut iter = [0; 4].into_iter();
+ for _ in 0..4 {
+ let _ = iter.next();
+ }
+ Self {
+ function: function.to_owned(),
+ remaining: number,
+ next_node_idx: Some(idx),
+ current_node: iter,
+ }
+ }
+ fn double(self) -> OperandDubleList {
+ assert_eq!(self.len() % 2, 0);
+ OperandDubleList(self)
+ }
+ fn map_expr(self) -> OperandExprList {
+ OperandExprList(self)
+ }
+ fn map_ssa_var(self) -> OperandSSAVariableList {
+ OperandSSAVariableList(self.double())
+ }
+}
+impl Iterator for OperandList {
+ type Item = u64;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ // if there is an item in this node, return it
+ if let Some(current_node) = self.current_node.next() {
+ return Some(current_node);
+ }
+
+ // no more items to fetch
+ if self.remaining == 0 {
+ return None;
+ }
+
+ // otherwise get the next node
+ let next_idx = self.next_node_idx?;
+ let node = get_raw_operation(&self.function, next_idx);
+ assert_eq!(node.operation, BNHighLevelILOperation::HLIL_UNDEF);
+
+ // each node contains at most 4, the last is reserved to next node idx
+ let consume = if self.remaining > 4 {
+ // there are more nodes after this one
+ self.next_node_idx = Some(node.operands[4] as usize);
+ self.remaining -= 4;
+ &node.operands[0..4]
+ } else {
+ // last part of the list, there is no next node
+ self.next_node_idx = None;
+ let nodes = &node.operands[0..self.remaining];
+ self.remaining = 0;
+ nodes
+ };
+ // the iter need to have a space of 4, but we may have less then that,
+ // solution is create a dummy elements at the start and discard it
+ let mut nodes = [0; 4];
+ let dummy_values = 4 - consume.len();
+ nodes[dummy_values..4].copy_from_slice(consume);
+ self.current_node = nodes.into_iter();
+ for _ in 0..dummy_values {
+ let _ = self.current_node.next();
+ }
+
+ self.current_node.next()
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ (self.len(), Some(self.len()))
+ }
+}
+impl ExactSizeIterator for OperandList {
+ fn len(&self) -> usize {
+ self.remaining + self.current_node.len()
+ }
+}
+
+// Iterator similar to OperationList, but returns two elements
+pub struct OperandDubleList(OperandList);
+impl Iterator for OperandDubleList {
+ type Item = (u64, u64);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let first = self.0.next()?;
+ let second = self.0.next().unwrap();
+ Some((first, second))
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ (self.len(), Some(self.len()))
+ }
+}
+impl ExactSizeIterator for OperandDubleList {
+ fn len(&self) -> usize {
+ self.0.len() / 2
+ }
+}
+
+pub struct OperandExprList(OperandList);
+impl Iterator for OperandExprList {
+ type Item = HighLevelILInstruction;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.0
+ .next()
+ .map(|idx| get_instruction(&self.0.function, idx as usize))
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ (self.0.len(), Some(self.0.len()))
+ }
+}
+impl ExactSizeIterator for OperandExprList {
+ fn len(&self) -> usize {
+ self.0.len()
+ }
+}
+
+pub struct OperandVariableList(OperandList);
+impl Iterator for OperandVariableList {
+ type Item = Variable;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.0.next().map(get_var)
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ (self.0.len(), Some(self.0.len()))
+ }
+}
+impl ExactSizeIterator for OperandVariableList {
+ fn len(&self) -> usize {
+ self.0.len()
+ }
+}
+
+pub struct OperandSSAVariableList(OperandDubleList);
+impl Iterator for OperandSSAVariableList {
+ type Item = SSAVariable;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.0.next().map(|(id, version)| {
+ let raw = unsafe { BNFromVariableIdentifier(id) };
+ let var = unsafe { Variable::from_raw(raw) };
+ SSAVariable::new(var, version as usize)
+ })
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ (self.len(), Some(self.len()))
+ }
+}
+impl ExactSizeIterator for OperandSSAVariableList {
+ fn len(&self) -> usize {
+ self.0.len()
+ }
+}
+
+fn get_float(value: u64, size: usize) -> f64 {
+ match size {
+ 4 => f32::from_bits(value as u32) as f64,
+ 8 => f64::from_bits(value),
+ // TODO how to handle this value?
+ size => todo!("float size {}", size),
+ }
+}
+
+fn get_instruction(function: &HighLevelILFunction, idx: usize) -> HighLevelILInstruction {
+ function.instruction_from_idx(idx)
+}
+
+fn get_instruction_list(function: &HighLevelILFunction, list: (usize, usize)) -> OperandExprList {
+ OperandList::new(function, list.1, list.0).map_expr()
+}
+
+fn get_int_list(function: &HighLevelILFunction, list: (usize, usize)) -> OperandList {
+ OperandList::new(function, list.1, list.0)
+}
+
+fn get_raw_operation(function: &HighLevelILFunction, idx: usize) -> BNHighLevelILInstruction {
+ unsafe { BNGetHighLevelILByIndex(function.handle, idx, function.full_ast) }
+}
+
+fn get_var(id: u64) -> Variable {
+ unsafe { Variable::from_raw(BNFromVariableIdentifier(id)) }
+}
+
+fn get_member_index(idx: u64) -> Option<usize> {
+ (idx as i64 > 0).then_some(idx as usize)
+}
+
+fn get_var_ssa(input: (u64, usize)) -> SSAVariable {
+ let raw = unsafe { BNFromVariableIdentifier(input.0) };
+ let var = unsafe { Variable::from_raw(raw) };
+ SSAVariable::new(var, input.1)
+}
+
+fn get_var_ssa_list(
+ function: &HighLevelILFunction,
+ list: (usize, usize),
+) -> OperandSSAVariableList {
+ OperandList::new(function, list.1, list.0).map_ssa_var()
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GotoLabel {
+ function: Ref<Function>,
+ target: u64,
+}
+
+impl GotoLabel {
+ pub fn name(&self) -> &str {
+ let raw_str = unsafe { BNGetGotoLabelName(self.function.handle, self.target) };
+ let c_str = unsafe { core::ffi::CStr::from_ptr(raw_str) };
+ c_str.to_str().unwrap()
+ }
+}
+
+// ADC, SBB, RLC, RRC
+#[derive(Clone)]
+pub struct BinaryOpCarry {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ left: usize,
+ right: usize,
+ carry: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedBinaryOpCarry {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub left: Box<HighLevelILLiftedInstruction>,
+ pub right: Box<HighLevelILLiftedInstruction>,
+ pub carry: Box<HighLevelILLiftedInstruction>,
+}
+impl BinaryOpCarry {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ left: usize,
+ right: usize,
+ carry: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ left,
+ right,
+ carry,
+ }
+ }
+ pub fn left(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.left)
+ }
+ pub fn right(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.right)
+ }
+ pub fn carry(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.carry)
+ }
+ pub fn lift(&self) -> LiftedBinaryOpCarry {
+ LiftedBinaryOpCarry {
+ function: self.function.to_owned(),
+ address: self.address,
+ left: Box::new(self.left().lift()),
+ right: Box::new(self.right().lift()),
+ carry: Box::new(self.carry().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..3usize).map(move |i| match i {
+ 0usize => ("left", Expr(self.left())),
+ 1usize => ("right", Expr(self.right())),
+ 2usize => ("carry", Expr(self.carry())),
+ _ => unreachable!(),
+ })
+ }
+}
+// ADD, SUB, AND, OR, XOR, LSL, LSR, ASR, ROL, ROR, MUL, MULU_DP, MULS_DP, DIVU, DIVU_DP, DIVS, DIVS_DP, MODU, MODU_DP, MODS, MODS_DP, CMP_E, CMP_NE, CMP_SLT, CMP_ULT, CMP_SLE, CMP_ULE, CMP_SGE, CMP_UGE, CMP_SGT, CMP_UGT, TEST_BIT, ADD_OVERFLOW, FADD, FSUB, FMUL, FDIV, FCMP_E, FCMP_NE, FCMP_LT, FCMP_LE, FCMP_GE, FCMP_GT, FCMP_O, FCMP_UO
+#[derive(Clone)]
+pub struct BinaryOp {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ left: usize,
+ right: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedBinaryOp {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub left: Box<HighLevelILLiftedInstruction>,
+ pub right: Box<HighLevelILLiftedInstruction>,
+}
+impl BinaryOp {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ left: usize,
+ right: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ left,
+ right,
+ }
+ }
+ pub fn left(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.left)
+ }
+ pub fn right(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.right)
+ }
+ pub fn lift(&self) -> LiftedBinaryOp {
+ LiftedBinaryOp {
+ function: self.function.to_owned(),
+ address: self.address,
+ left: Box::new(self.left().lift()),
+ right: Box::new(self.right().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..2usize).map(move |i| match i {
+ 0usize => ("left", Expr(self.left())),
+ 1usize => ("right", Expr(self.right())),
+ _ => unreachable!(),
+ })
+ }
+}
+// ARRAY_INDEX
+#[derive(Clone)]
+pub struct ArrayIndex {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ src: usize,
+ index: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedArrayIndex {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub src: Box<HighLevelILLiftedInstruction>,
+ pub index: Box<HighLevelILLiftedInstruction>,
+}
+impl ArrayIndex {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ src: usize,
+ index: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ src,
+ index,
+ }
+ }
+ pub fn src(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.src)
+ }
+ pub fn index(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.index)
+ }
+ pub fn lift(&self) -> LiftedArrayIndex {
+ LiftedArrayIndex {
+ function: self.function.to_owned(),
+ address: self.address,
+ src: Box::new(self.src().lift()),
+ index: Box::new(self.index().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..2usize).map(move |i| match i {
+ 0usize => ("src", Expr(self.src())),
+ 1usize => ("index", Expr(self.index())),
+ _ => unreachable!(),
+ })
+ }
+}
+// ARRAY_INDEX_SSA
+#[derive(Clone)]
+pub struct ArrayIndexSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ src: usize,
+ src_memory: u64,
+ index: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedArrayIndexSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub src: Box<HighLevelILLiftedInstruction>,
+ pub src_memory: u64,
+ pub index: Box<HighLevelILLiftedInstruction>,
+}
+impl ArrayIndexSsa {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ src: usize,
+ src_memory: u64,
+ index: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ src,
+ src_memory,
+ index,
+ }
+ }
+ pub fn src(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.src)
+ }
+ pub fn src_memory(&self) -> u64 {
+ self.src_memory
+ }
+ pub fn index(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.index)
+ }
+ pub fn lift(&self) -> LiftedArrayIndexSsa {
+ LiftedArrayIndexSsa {
+ function: self.function.to_owned(),
+ address: self.address,
+ src: Box::new(self.src().lift()),
+ src_memory: self.src_memory,
+ index: Box::new(self.index().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..3usize).map(move |i| match i {
+ 0usize => ("src", Expr(self.src())),
+ 1usize => ("src_memory", Int(self.src_memory())),
+ 2usize => ("index", Expr(self.index())),
+ _ => unreachable!(),
+ })
+ }
+}
+// ASSIGN
+#[derive(Clone)]
+pub struct Assign {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ dest: usize,
+ src: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedAssign {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub dest: Box<HighLevelILLiftedInstruction>,
+ pub src: Box<HighLevelILLiftedInstruction>,
+}
+impl Assign {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ dest: usize,
+ src: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ dest,
+ src,
+ }
+ }
+ pub fn dest(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.dest)
+ }
+ pub fn src(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.src)
+ }
+ pub fn lift(&self) -> LiftedAssign {
+ LiftedAssign {
+ function: self.function.to_owned(),
+ address: self.address,
+ dest: Box::new(self.dest().lift()),
+ src: Box::new(self.src().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..2usize).map(move |i| match i {
+ 0usize => ("dest", Expr(self.dest())),
+ 1usize => ("src", Expr(self.src())),
+ _ => unreachable!(),
+ })
+ }
+}
+// ASSIGN_MEM_SSA
+#[derive(Clone)]
+pub struct AssignMemSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ dest: usize,
+ dest_memory: u64,
+ src: usize,
+ src_memory: u64,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedAssignMemSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub dest: Box<HighLevelILLiftedInstruction>,
+ pub dest_memory: u64,
+ pub src: Box<HighLevelILLiftedInstruction>,
+ pub src_memory: u64,
+}
+impl AssignMemSsa {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ dest: usize,
+ dest_memory: u64,
+ src: usize,
+ src_memory: u64,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ dest,
+ dest_memory,
+ src,
+ src_memory,
+ }
+ }
+ pub fn dest(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.dest)
+ }
+ pub fn dest_memory(&self) -> u64 {
+ self.dest_memory
+ }
+ pub fn src(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.src)
+ }
+ pub fn src_memory(&self) -> u64 {
+ self.src_memory
+ }
+ pub fn lift(&self) -> LiftedAssignMemSsa {
+ LiftedAssignMemSsa {
+ function: self.function.to_owned(),
+ address: self.address,
+ dest: Box::new(self.dest().lift()),
+ dest_memory: self.dest_memory,
+ src: Box::new(self.src().lift()),
+ src_memory: self.src_memory,
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..4usize).map(move |i| match i {
+ 0usize => ("dest", Expr(self.dest())),
+ 1usize => ("dest_memory", Int(self.dest_memory())),
+ 2usize => ("src", Expr(self.src())),
+ 3usize => ("src_memory", Int(self.src_memory())),
+ _ => unreachable!(),
+ })
+ }
+}
+// ASSIGN_UNPACK
+#[derive(Clone)]
+pub struct AssignUnpack {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ dest: (usize, usize),
+ src: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedAssignUnpack {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub dest: Vec<HighLevelILLiftedInstruction>,
+ pub src: Box<HighLevelILLiftedInstruction>,
+}
+impl AssignUnpack {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ dest: (usize, usize),
+ src: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ dest,
+ src,
+ }
+ }
+ pub fn dest(&self) -> OperandExprList {
+ get_instruction_list(&self.function, self.dest)
+ }
+ pub fn src(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.src)
+ }
+ pub fn lift(&self) -> LiftedAssignUnpack {
+ LiftedAssignUnpack {
+ function: self.function.to_owned(),
+ address: self.address,
+ dest: self.dest().map(|x| x.lift()).collect(),
+ src: Box::new(self.src().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..2usize).map(move |i| match i {
+ 0usize => ("dest", ExprList(self.dest())),
+ 1usize => ("src", Expr(self.src())),
+ _ => unreachable!(),
+ })
+ }
+}
+// ASSIGN_UNPACK_MEM_SSA
+#[derive(Clone)]
+pub struct AssignUnpackMemSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ dest: (usize, usize),
+ dest_memory: u64,
+ src: usize,
+ src_memory: u64,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedAssignUnpackMemSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub dest: Vec<HighLevelILLiftedInstruction>,
+ pub dest_memory: u64,
+ pub src: Box<HighLevelILLiftedInstruction>,
+ pub src_memory: u64,
+}
+impl AssignUnpackMemSsa {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ dest: (usize, usize),
+ dest_memory: u64,
+ src: usize,
+ src_memory: u64,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ dest,
+ dest_memory,
+ src,
+ src_memory,
+ }
+ }
+ pub fn dest(&self) -> OperandExprList {
+ get_instruction_list(&self.function, self.dest)
+ }
+ pub fn dest_memory(&self) -> u64 {
+ self.dest_memory
+ }
+ pub fn src(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.src)
+ }
+ pub fn src_memory(&self) -> u64 {
+ self.src_memory
+ }
+ pub fn lift(&self) -> LiftedAssignUnpackMemSsa {
+ LiftedAssignUnpackMemSsa {
+ function: self.function.to_owned(),
+ address: self.address,
+ dest: self.dest().map(|x| x.lift()).collect(),
+ dest_memory: self.dest_memory,
+ src: Box::new(self.src().lift()),
+ src_memory: self.src_memory,
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..4usize).map(move |i| match i {
+ 0usize => ("dest", ExprList(self.dest())),
+ 1usize => ("dest_memory", Int(self.dest_memory())),
+ 2usize => ("src", Expr(self.src())),
+ 3usize => ("src_memory", Int(self.src_memory())),
+ _ => unreachable!(),
+ })
+ }
+}
+// BLOCK
+#[derive(Clone)]
+pub struct Block {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ body: (usize, usize),
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedBlock {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub body: Vec<HighLevelILLiftedInstruction>,
+}
+impl Block {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ body: (usize, usize),
+ ) -> Self {
+ Self {
+ function,
+ address,
+ body,
+ }
+ }
+ pub fn body(&self) -> OperandExprList {
+ get_instruction_list(&self.function, self.body)
+ }
+ pub fn lift(&self) -> LiftedBlock {
+ LiftedBlock {
+ function: self.function.to_owned(),
+ address: self.address,
+ body: self.body().map(|x| x.lift()).collect(),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..1usize).map(move |i| match i {
+ 0usize => ("body", ExprList(self.body())),
+ _ => unreachable!(),
+ })
+ }
+}
+// CALL, TAILCALL
+#[derive(Clone)]
+pub struct Call {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ dest: usize,
+ params: (usize, usize),
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedCall {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub dest: Box<HighLevelILLiftedInstruction>,
+ pub params: Vec<HighLevelILLiftedInstruction>,
+}
+impl Call {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ dest: usize,
+ params: (usize, usize),
+ ) -> Self {
+ Self {
+ function,
+ address,
+ dest,
+ params,
+ }
+ }
+ pub fn dest(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.dest)
+ }
+ pub fn params(&self) -> OperandExprList {
+ get_instruction_list(&self.function, self.params)
+ }
+ pub fn lift(&self) -> LiftedCall {
+ LiftedCall {
+ function: self.function.to_owned(),
+ address: self.address,
+ dest: Box::new(self.dest().lift()),
+ params: self.params().map(|x| x.lift()).collect(),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..2usize).map(move |i| match i {
+ 0usize => ("dest", Expr(self.dest())),
+ 1usize => ("params", ExprList(self.params())),
+ _ => unreachable!(),
+ })
+ }
+}
+// CALL_SSA
+#[derive(Clone)]
+pub struct CallSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ dest: usize,
+ params: (usize, usize),
+ dest_memory: u64,
+ src_memory: u64,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedCallSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub dest: Box<HighLevelILLiftedInstruction>,
+ pub params: Vec<HighLevelILLiftedInstruction>,
+ pub dest_memory: u64,
+ pub src_memory: u64,
+}
+impl CallSsa {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ dest: usize,
+ params: (usize, usize),
+ dest_memory: u64,
+ src_memory: u64,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ dest,
+ params,
+ dest_memory,
+ src_memory,
+ }
+ }
+ pub fn dest(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.dest)
+ }
+ pub fn params(&self) -> OperandExprList {
+ get_instruction_list(&self.function, self.params)
+ }
+ pub fn dest_memory(&self) -> u64 {
+ self.dest_memory
+ }
+ pub fn src_memory(&self) -> u64 {
+ self.src_memory
+ }
+ pub fn lift(&self) -> LiftedCallSsa {
+ LiftedCallSsa {
+ function: self.function.to_owned(),
+ address: self.address,
+ dest: Box::new(self.dest().lift()),
+ params: self.params().map(|x| x.lift()).collect(),
+ dest_memory: self.dest_memory,
+ src_memory: self.src_memory,
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..4usize).map(move |i| match i {
+ 0usize => ("dest", Expr(self.dest())),
+ 1usize => ("params", ExprList(self.params())),
+ 2usize => ("dest_memory", Int(self.dest_memory())),
+ 3usize => ("src_memory", Int(self.src_memory())),
+ _ => unreachable!(),
+ })
+ }
+}
+// CASE
+#[derive(Clone)]
+pub struct Case {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ values: (usize, usize),
+ body: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedCase {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub values: Vec<HighLevelILLiftedInstruction>,
+ pub body: Box<HighLevelILLiftedInstruction>,
+}
+impl Case {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ values: (usize, usize),
+ body: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ values,
+ body,
+ }
+ }
+ pub fn values(&self) -> OperandExprList {
+ get_instruction_list(&self.function, self.values)
+ }
+ pub fn body(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.body)
+ }
+ pub fn lift(&self) -> LiftedCase {
+ LiftedCase {
+ function: self.function.to_owned(),
+ address: self.address,
+ values: self.values().map(|x| x.lift()).collect(),
+ body: Box::new(self.body().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..2usize).map(move |i| match i {
+ 0usize => ("values", ExprList(self.values())),
+ 1usize => ("body", Expr(self.body())),
+ _ => unreachable!(),
+ })
+ }
+}
+// CONST, CONST_PTR, IMPORT
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct Const {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub constant: u64,
+}
+impl Const {
+ pub(crate) fn new(function: Ref<HighLevelILFunction>, address: u64, constant: u64) -> Self {
+ Self {
+ function,
+ address,
+ constant,
+ }
+ }
+ pub fn constant(&self) -> u64 {
+ self.constant
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..1usize).map(move |i| match i {
+ 0usize => ("constant", Int(self.constant())),
+ _ => unreachable!(),
+ })
+ }
+}
+// CONST_DATA
+#[derive(Clone)]
+pub struct ConstData {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ constant_data: (u32, u64, usize),
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedConstantData {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub constant_data: ConstantData,
+}
+impl ConstData {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ constant_data: (u32, u64, usize),
+ ) -> Self {
+ Self {
+ function,
+ address,
+ constant_data,
+ }
+ }
+ pub fn constant_data(&self) -> ConstantData {
+ let register_value = RegisterValue {
+ state: RegisterValueType::from_raw_value(self.constant_data.0).unwrap(),
+ value: self.constant_data.1 as i64,
+ offset: 0,
+ size: self.constant_data.2,
+ };
+ ConstantData::new(self.function.get_function(), register_value)
+ }
+ pub fn lift(&self) -> LiftedConstantData {
+ LiftedConstantData {
+ function: self.function.to_owned(),
+ address: self.address,
+ constant_data: self.constant_data(),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..1usize).map(move |i| match i {
+ 0usize => ("constant_data", ConstantData(self.constant_data())),
+ _ => unreachable!(),
+ })
+ }
+}
+// DEREF, ADDRESS_OF, NEG, NOT, SX, ZX, LOW_PART, BOOL_TO_INT, UNIMPL_MEM, FSQRT, FNEG, FABS, FLOAT_TO_INT, INT_TO_FLOAT, FLOAT_CONV, ROUND_TO_INT, FLOOR, CEIL, FTRUNC
+#[derive(Clone)]
+pub struct UnaryOp {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ src: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedUnaryOp {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub src: Box<HighLevelILLiftedInstruction>,
+}
+impl UnaryOp {
+ pub(crate) fn new(function: Ref<HighLevelILFunction>, address: u64, src: usize) -> Self {
+ Self {
+ function,
+ address,
+ src,
+ }
+ }
+ pub fn src(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.src)
+ }
+ pub fn lift(&self) -> LiftedUnaryOp {
+ LiftedUnaryOp {
+ function: self.function.to_owned(),
+ address: self.address,
+ src: Box::new(self.src().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..1usize).map(move |i| match i {
+ 0usize => ("src", Expr(self.src())),
+ _ => unreachable!(),
+ })
+ }
+}
+// DEREF_FIELD_SSA
+#[derive(Clone)]
+pub struct DerefFieldSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ src: usize,
+ src_memory: u64,
+ offset: u64,
+ member_index: Option<usize>,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedDerefFieldSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub src: Box<HighLevelILLiftedInstruction>,
+ pub src_memory: u64,
+ pub offset: u64,
+ pub member_index: Option<usize>,
+}
+impl DerefFieldSsa {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ src: usize,
+ src_memory: u64,
+ offset: u64,
+ member_index: u64,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ src,
+ src_memory,
+ offset,
+ member_index: get_member_index(member_index),
+ }
+ }
+ pub fn src(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.src)
+ }
+ pub fn src_memory(&self) -> u64 {
+ self.src_memory
+ }
+ pub fn offset(&self) -> u64 {
+ self.offset
+ }
+ pub fn member_index(&self) -> Option<usize> {
+ self.member_index
+ }
+ pub fn lift(&self) -> LiftedDerefFieldSsa {
+ LiftedDerefFieldSsa {
+ function: self.function.to_owned(),
+ address: self.address,
+ src: Box::new(self.src().lift()),
+ src_memory: self.src_memory,
+ offset: self.offset,
+ member_index: self.member_index,
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..4usize).map(move |i| match i {
+ 0usize => ("src", Expr(self.src())),
+ 1usize => ("src_memory", Int(self.src_memory())),
+ 2usize => ("offset", Int(self.offset())),
+ 3usize => ("member_index", MemberIndex(self.member_index())),
+ _ => unreachable!(),
+ })
+ }
+}
+// DEREF_SSA
+#[derive(Clone)]
+pub struct DerefSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ src: usize,
+ src_memory: u64,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedDerefSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub src: Box<HighLevelILLiftedInstruction>,
+ pub src_memory: u64,
+}
+impl DerefSsa {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ src: usize,
+ src_memory: u64,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ src,
+ src_memory,
+ }
+ }
+ pub fn src(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.src)
+ }
+ pub fn src_memory(&self) -> u64 {
+ self.src_memory
+ }
+ pub fn lift(&self) -> LiftedDerefSsa {
+ LiftedDerefSsa {
+ function: self.function.to_owned(),
+ address: self.address,
+ src: Box::new(self.src().lift()),
+ src_memory: self.src_memory,
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..2usize).map(move |i| match i {
+ 0usize => ("src", Expr(self.src())),
+ 1usize => ("src_memory", Int(self.src_memory())),
+ _ => unreachable!(),
+ })
+ }
+}
+// EXTERN_PTR
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct ExternPtr {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub constant: u64,
+ pub offset: u64,
+}
+impl ExternPtr {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ constant: u64,
+ offset: u64,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ constant,
+ offset,
+ }
+ }
+ pub fn constant(&self) -> u64 {
+ self.constant
+ }
+ pub fn offset(&self) -> u64 {
+ self.offset
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..2usize).map(move |i| match i {
+ 0usize => ("constant", Int(self.constant())),
+ 1usize => ("offset", Int(self.offset())),
+ _ => unreachable!(),
+ })
+ }
+}
+// FLOAT_CONST
+#[derive(Clone, Debug, PartialEq)]
+pub struct FloatConst {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub constant: f64,
+}
+impl FloatConst {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ constant: u64,
+ size: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ constant: get_float(constant, size),
+ }
+ }
+ pub fn constant(&self) -> f64 {
+ self.constant
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..1usize).map(move |i| match i {
+ 0usize => ("constant", Float(self.constant())),
+ _ => unreachable!(),
+ })
+ }
+}
+// FOR
+#[derive(Clone)]
+pub struct ForLoop {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ init: usize,
+ condition: usize,
+ update: usize,
+ body: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedForLoop {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub init: Box<HighLevelILLiftedInstruction>,
+ pub condition: Box<HighLevelILLiftedInstruction>,
+ pub update: Box<HighLevelILLiftedInstruction>,
+ pub body: Box<HighLevelILLiftedInstruction>,
+}
+impl ForLoop {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ init: usize,
+ condition: usize,
+ update: usize,
+ body: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ init,
+ condition,
+ update,
+ body,
+ }
+ }
+ pub fn init(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.init)
+ }
+ pub fn condition(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.condition)
+ }
+ pub fn update(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.update)
+ }
+ pub fn body(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.body)
+ }
+ pub fn lift(&self) -> LiftedForLoop {
+ LiftedForLoop {
+ function: self.function.to_owned(),
+ address: self.address,
+ init: Box::new(self.init().lift()),
+ condition: Box::new(self.condition().lift()),
+ update: Box::new(self.update().lift()),
+ body: Box::new(self.body().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..4usize).map(move |i| match i {
+ 0usize => ("init", Expr(self.init())),
+ 1usize => ("condition", Expr(self.condition())),
+ 2usize => ("update", Expr(self.update())),
+ 3usize => ("body", Expr(self.body())),
+ _ => unreachable!(),
+ })
+ }
+}
+// FOR_SSA
+#[derive(Clone)]
+pub struct ForLoopSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ init: usize,
+ condition_phi: usize,
+ condition: usize,
+ update: usize,
+ body: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedForLoopSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub init: Box<HighLevelILLiftedInstruction>,
+ pub condition_phi: Box<HighLevelILLiftedInstruction>,
+ pub condition: Box<HighLevelILLiftedInstruction>,
+ pub update: Box<HighLevelILLiftedInstruction>,
+ pub body: Box<HighLevelILLiftedInstruction>,
+}
+impl ForLoopSsa {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ init: usize,
+ condition_phi: usize,
+ condition: usize,
+ update: usize,
+ body: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ init,
+ condition_phi,
+ condition,
+ update,
+ body,
+ }
+ }
+ pub fn init(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.init)
+ }
+ pub fn condition_phi(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.condition_phi)
+ }
+ pub fn condition(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.condition)
+ }
+ pub fn update(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.update)
+ }
+ pub fn body(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.body)
+ }
+ pub fn lift(&self) -> LiftedForLoopSsa {
+ LiftedForLoopSsa {
+ function: self.function.to_owned(),
+ address: self.address,
+ init: Box::new(self.init().lift()),
+ condition_phi: Box::new(self.condition_phi().lift()),
+ condition: Box::new(self.condition().lift()),
+ update: Box::new(self.update().lift()),
+ body: Box::new(self.body().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..5usize).map(move |i| match i {
+ 0usize => ("init", Expr(self.init())),
+ 1usize => ("condition_phi", Expr(self.condition_phi())),
+ 2usize => ("condition", Expr(self.condition())),
+ 3usize => ("update", Expr(self.update())),
+ 4usize => ("body", Expr(self.body())),
+ _ => unreachable!(),
+ })
+ }
+}
+// GOTO, LABEL
+#[derive(Clone, Debug, PartialEq)]
+pub struct Label {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub target: u64,
+}
+impl Label {
+ pub(crate) fn new(function: Ref<HighLevelILFunction>, address: u64, target: u64) -> Self {
+ Self {
+ function,
+ address,
+ target,
+ }
+ }
+ pub fn target(&self) -> GotoLabel {
+ GotoLabel {
+ function: self.function.get_function(),
+ target: self.target,
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..1usize).map(move |i| match i {
+ 0usize => ("target", Label(self.target())),
+ _ => unreachable!(),
+ })
+ }
+}
+// IF
+#[derive(Clone)]
+pub struct If {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ condition: usize,
+ cond_true: usize,
+ cond_false: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedIf {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub condition: Box<HighLevelILLiftedInstruction>,
+ pub cond_true: Box<HighLevelILLiftedInstruction>,
+ pub cond_false: Box<HighLevelILLiftedInstruction>,
+}
+impl If {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ condition: usize,
+ cond_true: usize,
+ cond_false: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ condition,
+ cond_true,
+ cond_false,
+ }
+ }
+ pub fn condition(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.condition)
+ }
+ pub fn cond_true(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.cond_true)
+ }
+ pub fn cond_false(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.cond_false)
+ }
+ pub fn lift(&self) -> LiftedIf {
+ LiftedIf {
+ function: self.function.to_owned(),
+ address: self.address,
+ condition: Box::new(self.condition().lift()),
+ cond_true: Box::new(self.cond_true().lift()),
+ cond_false: Box::new(self.cond_false().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..3usize).map(move |i| match i {
+ 0usize => ("condition", Expr(self.condition())),
+ 1usize => ("cond_true", Expr(self.cond_true())),
+ 2usize => ("cond_false", Expr(self.cond_false())),
+ _ => unreachable!(),
+ })
+ }
+}
+// INTRINSIC
+#[derive(Clone)]
+pub struct Intrinsic {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ intrinsic: u32,
+ params: (usize, usize),
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedIntrinsic {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub intrinsic: ILIntrinsic,
+ pub params: Vec<HighLevelILLiftedInstruction>,
+}
+impl Intrinsic {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ intrinsic: u32,
+ params: (usize, usize),
+ ) -> Self {
+ Self {
+ function,
+ address,
+ intrinsic,
+ params,
+ }
+ }
+ pub fn intrinsic(&self) -> ILIntrinsic {
+ ILIntrinsic::new(self.function.get_function().arch(), self.intrinsic)
+ }
+ pub fn params(&self) -> OperandExprList {
+ get_instruction_list(&self.function, self.params)
+ }
+ pub fn lift(&self) -> LiftedIntrinsic {
+ LiftedIntrinsic {
+ function: self.function.to_owned(),
+ address: self.address,
+ intrinsic: self.intrinsic(),
+ params: self.params().map(|x| x.lift()).collect(),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..2usize).map(move |i| match i {
+ 0usize => ("intrinsic", Intrinsic(self.intrinsic())),
+ 1usize => ("params", ExprList(self.params())),
+ _ => unreachable!(),
+ })
+ }
+}
+// INTRINSIC_SSA
+#[derive(Clone)]
+pub struct IntrinsicSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ intrinsic: u32,
+ params: (usize, usize),
+ dest_memory: u64,
+ src_memory: u64,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedIntrinsicSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub intrinsic: ILIntrinsic,
+ pub params: Vec<HighLevelILLiftedInstruction>,
+ pub dest_memory: u64,
+ pub src_memory: u64,
+}
+impl IntrinsicSsa {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ intrinsic: u32,
+ params: (usize, usize),
+ dest_memory: u64,
+ src_memory: u64,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ intrinsic,
+ params,
+ dest_memory,
+ src_memory,
+ }
+ }
+ pub fn intrinsic(&self) -> ILIntrinsic {
+ ILIntrinsic::new(self.function.get_function().arch(), self.intrinsic)
+ }
+ pub fn params(&self) -> OperandExprList {
+ get_instruction_list(&self.function, self.params)
+ }
+ pub fn dest_memory(&self) -> u64 {
+ self.dest_memory
+ }
+ pub fn src_memory(&self) -> u64 {
+ self.src_memory
+ }
+ pub fn lift(&self) -> LiftedIntrinsicSsa {
+ LiftedIntrinsicSsa {
+ function: self.function.to_owned(),
+ address: self.address,
+ intrinsic: self.intrinsic(),
+ params: self.params().map(|x| x.lift()).collect(),
+ dest_memory: self.dest_memory,
+ src_memory: self.src_memory,
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..4usize).map(move |i| match i {
+ 0usize => ("intrinsic", Intrinsic(self.intrinsic())),
+ 1usize => ("params", ExprList(self.params())),
+ 2usize => ("dest_memory", Int(self.dest_memory())),
+ 3usize => ("src_memory", Int(self.src_memory())),
+ _ => unreachable!(),
+ })
+ }
+}
+// JUMP
+#[derive(Clone, Debug, PartialEq)]
+pub struct Jump {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub dest: usize,
+}
+impl Jump {
+ pub(crate) fn new(function: Ref<HighLevelILFunction>, address: u64, dest: usize) -> Self {
+ Self {
+ function,
+ address,
+ dest,
+ }
+ }
+ pub fn dest(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.dest)
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..1usize).map(move |i| match i {
+ 0usize => ("dest", Expr(self.dest())),
+ _ => unreachable!(),
+ })
+ }
+}
+// MEM_PHI
+#[derive(Clone)]
+pub struct MemPhi {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ dest: u64,
+ src: (usize, usize),
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedMemPhi {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub dest: u64,
+ pub src: Vec<u64>,
+}
+impl MemPhi {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ dest: u64,
+ src: (usize, usize),
+ ) -> Self {
+ Self {
+ function,
+ address,
+ dest,
+ src,
+ }
+ }
+ pub fn dest(&self) -> u64 {
+ self.dest
+ }
+ pub fn src(&self) -> OperandList {
+ get_int_list(&self.function, self.src)
+ }
+ pub fn lift(&self) -> LiftedMemPhi {
+ LiftedMemPhi {
+ function: self.function.to_owned(),
+ address: self.address,
+ dest: self.dest,
+ src: self.src().collect(),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..2usize).map(move |i| match i {
+ 0usize => ("dest", Int(self.dest())),
+ 1usize => ("src", IntList(self.src())),
+ _ => unreachable!(),
+ })
+ }
+}
+// NOP, BREAK, CONTINUE, NORET, UNREACHABLE, BP, UNDEF, UNIMPL
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct NoArgs {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+}
+impl NoArgs {
+ pub(crate) fn new(function: Ref<HighLevelILFunction>, address: u64) -> Self {
+ Self { function, address }
+ }
+ // NOTE self is not required, it's present just in case data is added to
+ // the struct in the future
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ [].into_iter()
+ }
+}
+// RET
+#[derive(Clone)]
+pub struct Ret {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ src: (usize, usize),
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedRet {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub src: Vec<HighLevelILLiftedInstruction>,
+}
+impl Ret {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ src: (usize, usize),
+ ) -> Self {
+ Self {
+ function,
+ address,
+ src,
+ }
+ }
+ pub fn src(&self) -> OperandExprList {
+ get_instruction_list(&self.function, self.src)
+ }
+ pub fn lift(&self) -> LiftedRet {
+ LiftedRet {
+ function: self.function.to_owned(),
+ address: self.address,
+ src: self.src().map(|x| x.lift()).collect(),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..1usize).map(move |i| match i {
+ 0usize => ("src", ExprList(self.src())),
+ _ => unreachable!(),
+ })
+ }
+}
+// SPLIT
+#[derive(Clone)]
+pub struct Split {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ high: usize,
+ low: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedSplit {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub high: Box<HighLevelILLiftedInstruction>,
+ pub low: Box<HighLevelILLiftedInstruction>,
+}
+impl Split {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ high: usize,
+ low: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ high,
+ low,
+ }
+ }
+ pub fn high(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.high)
+ }
+ pub fn low(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.low)
+ }
+ pub fn lift(&self) -> LiftedSplit {
+ LiftedSplit {
+ function: self.function.to_owned(),
+ address: self.address,
+ high: Box::new(self.high().lift()),
+ low: Box::new(self.low().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..2usize).map(move |i| match i {
+ 0usize => ("high", Expr(self.high())),
+ 1usize => ("low", Expr(self.low())),
+ _ => unreachable!(),
+ })
+ }
+}
+// STRUCT_FIELD, DEREF_FIELD
+#[derive(Clone)]
+pub struct StructField {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ src: usize,
+ offset: u64,
+ member_index: Option<usize>,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedStructField {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub src: Box<HighLevelILLiftedInstruction>,
+ pub offset: u64,
+ pub member_index: Option<usize>,
+}
+impl StructField {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ src: usize,
+ offset: u64,
+ member_index: u64,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ src,
+ offset,
+ member_index: get_member_index(member_index),
+ }
+ }
+ pub fn src(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.src)
+ }
+ pub fn offset(&self) -> u64 {
+ self.offset
+ }
+ pub fn member_index(&self) -> Option<usize> {
+ self.member_index
+ }
+ pub fn lift(&self) -> LiftedStructField {
+ LiftedStructField {
+ function: self.function.to_owned(),
+ address: self.address,
+ src: Box::new(self.src().lift()),
+ offset: self.offset,
+ member_index: self.member_index,
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..3usize).map(move |i| match i {
+ 0usize => ("src", Expr(self.src())),
+ 1usize => ("offset", Int(self.offset())),
+ 2usize => ("member_index", MemberIndex(self.member_index())),
+ _ => unreachable!(),
+ })
+ }
+}
+// SWITCH
+#[derive(Clone)]
+pub struct Switch {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ condition: usize,
+ default: usize,
+ cases: (usize, usize),
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedSwitch {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub condition: Box<HighLevelILLiftedInstruction>,
+ pub default: Box<HighLevelILLiftedInstruction>,
+ pub cases: Vec<HighLevelILLiftedInstruction>,
+}
+impl Switch {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ condition: usize,
+ default: usize,
+ cases: (usize, usize),
+ ) -> Self {
+ Self {
+ function,
+ address,
+ condition,
+ default,
+ cases,
+ }
+ }
+ pub fn condition(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.condition)
+ }
+ pub fn default(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.default)
+ }
+ pub fn cases(&self) -> OperandExprList {
+ get_instruction_list(&self.function, self.cases)
+ }
+ pub fn lift(&self) -> LiftedSwitch {
+ LiftedSwitch {
+ function: self.function.to_owned(),
+ address: self.address,
+ condition: Box::new(self.condition().lift()),
+ default: Box::new(self.default().lift()),
+ cases: self.cases().map(|x| x.lift()).collect(),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..3usize).map(move |i| match i {
+ 0usize => ("condition", Expr(self.condition())),
+ 1usize => ("default", Expr(self.default())),
+ 2usize => ("cases", ExprList(self.cases())),
+ _ => unreachable!(),
+ })
+ }
+}
+// SYSCALL
+#[derive(Clone)]
+pub struct Syscall {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ params: (usize, usize),
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedSyscall {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub params: Vec<HighLevelILLiftedInstruction>,
+}
+impl Syscall {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ params: (usize, usize),
+ ) -> Self {
+ Self {
+ function,
+ address,
+ params,
+ }
+ }
+ pub fn params(&self) -> OperandExprList {
+ get_instruction_list(&self.function, self.params)
+ }
+ pub fn lift(&self) -> LiftedSyscall {
+ LiftedSyscall {
+ function: self.function.to_owned(),
+ address: self.address,
+ params: self.params().map(|x| x.lift()).collect(),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..1usize).map(move |i| match i {
+ 0usize => ("params", ExprList(self.params())),
+ _ => unreachable!(),
+ })
+ }
+}
+// SYSCALL_SSA
+#[derive(Clone)]
+pub struct SyscallSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ params: (usize, usize),
+ dest_memory: u64,
+ src_memory: u64,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedSyscallSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub params: Vec<HighLevelILLiftedInstruction>,
+ pub dest_memory: u64,
+ pub src_memory: u64,
+}
+impl SyscallSsa {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ params: (usize, usize),
+ dest_memory: u64,
+ src_memory: u64,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ params,
+ dest_memory,
+ src_memory,
+ }
+ }
+ pub fn params(&self) -> OperandExprList {
+ get_instruction_list(&self.function, self.params)
+ }
+ pub fn dest_memory(&self) -> u64 {
+ self.dest_memory
+ }
+ pub fn src_memory(&self) -> u64 {
+ self.src_memory
+ }
+ pub fn lift(&self) -> LiftedSyscallSsa {
+ LiftedSyscallSsa {
+ function: self.function.to_owned(),
+ address: self.address,
+ params: self.params().map(|x| x.lift()).collect(),
+ dest_memory: self.dest_memory,
+ src_memory: self.src_memory,
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..3usize).map(move |i| match i {
+ 0usize => ("params", ExprList(self.params())),
+ 1usize => ("dest_memory", Int(self.dest_memory())),
+ 2usize => ("src_memory", Int(self.src_memory())),
+ _ => unreachable!(),
+ })
+ }
+}
+// TRAP
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct Trap {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub vector: u64,
+}
+impl Trap {
+ pub(crate) fn new(function: Ref<HighLevelILFunction>, address: u64, vector: u64) -> Self {
+ Self {
+ function,
+ address,
+ vector,
+ }
+ }
+ pub fn vector(&self) -> u64 {
+ self.vector
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..1usize).map(move |i| match i {
+ 0usize => ("vector", Int(self.vector())),
+ _ => unreachable!(),
+ })
+ }
+}
+// VAR_DECLARE, VAR
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct Var {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub var: Variable,
+}
+impl Var {
+ pub(crate) fn new(function: Ref<HighLevelILFunction>, address: u64, var: u64) -> Self {
+ Self {
+ function,
+ address,
+ var: get_var(var),
+ }
+ }
+ pub fn var(&self) -> Variable {
+ self.var
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..1usize).map(move |i| match i {
+ 0usize => ("var", Var(self.var())),
+ _ => unreachable!(),
+ })
+ }
+}
+// VAR_INIT
+#[derive(Clone)]
+pub struct VarInit {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ dest: Variable,
+ src: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedVarInit {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub dest: Variable,
+ pub src: Box<HighLevelILLiftedInstruction>,
+}
+impl VarInit {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ dest: u64,
+ src: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ dest: get_var(dest),
+ src,
+ }
+ }
+ pub fn dest(&self) -> Variable {
+ self.dest
+ }
+ pub fn src(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.src)
+ }
+ pub fn lift(&self) -> LiftedVarInit {
+ LiftedVarInit {
+ function: self.function.to_owned(),
+ address: self.address,
+ dest: self.dest,
+ src: Box::new(self.src().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..2usize).map(move |i| match i {
+ 0usize => ("dest", Var(self.dest())),
+ 1usize => ("src", Expr(self.src())),
+ _ => unreachable!(),
+ })
+ }
+}
+// VAR_INIT_SSA
+#[derive(Clone)]
+pub struct VarInitSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ dest: SSAVariable,
+ src: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedVarInitSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub dest: SSAVariable,
+ pub src: Box<HighLevelILLiftedInstruction>,
+}
+impl VarInitSsa {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ dest: (u64, usize),
+ src: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ dest: get_var_ssa(dest),
+ src,
+ }
+ }
+ pub fn dest(&self) -> SSAVariable {
+ self.dest
+ }
+ pub fn src(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.src)
+ }
+ pub fn lift(&self) -> LiftedVarInitSsa {
+ LiftedVarInitSsa {
+ function: self.function.to_owned(),
+ address: self.address,
+ dest: self.dest,
+ src: Box::new(self.src().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..2usize).map(move |i| match i {
+ 0usize => ("dest", VarSsa(self.dest())),
+ 1usize => ("src", Expr(self.src())),
+ _ => unreachable!(),
+ })
+ }
+}
+// VAR_PHI
+#[derive(Clone)]
+pub struct VarPhi {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ dest: SSAVariable,
+ src: (usize, usize),
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedVarPhi {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub dest: SSAVariable,
+ pub src: Vec<SSAVariable>,
+}
+impl VarPhi {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ dest: (u64, usize),
+ src: (usize, usize),
+ ) -> Self {
+ Self {
+ function,
+ address,
+ dest: get_var_ssa(dest),
+ src,
+ }
+ }
+ pub fn dest(&self) -> SSAVariable {
+ self.dest
+ }
+ pub fn src(&self) -> OperandSSAVariableList {
+ get_var_ssa_list(&self.function, self.src)
+ }
+ pub fn lift(&self) -> LiftedVarPhi {
+ LiftedVarPhi {
+ function: self.function.to_owned(),
+ address: self.address,
+ dest: self.dest,
+ src: self.src().collect(),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..2usize).map(move |i| match i {
+ 0usize => ("dest", VarSsa(self.dest())),
+ 1usize => ("src", VarSsaList(self.src())),
+ _ => unreachable!(),
+ })
+ }
+}
+// VAR_SSA
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct VarSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub var: SSAVariable,
+}
+impl VarSsa {
+ pub(crate) fn new(function: Ref<HighLevelILFunction>, address: u64, var: (u64, usize)) -> Self {
+ Self {
+ function,
+ address,
+ var: get_var_ssa(var),
+ }
+ }
+ pub fn var(&self) -> SSAVariable {
+ self.var
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..1usize).map(move |i| match i {
+ 0usize => ("var", VarSsa(self.var())),
+ _ => unreachable!(),
+ })
+ }
+}
+// WHILE, DO_WHILE
+#[derive(Clone)]
+pub struct While {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ condition: usize,
+ body: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedWhile {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub condition: Box<HighLevelILLiftedInstruction>,
+ pub body: Box<HighLevelILLiftedInstruction>,
+}
+impl While {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ condition: usize,
+ body: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ condition,
+ body,
+ }
+ }
+ pub fn condition(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.condition)
+ }
+ pub fn body(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.body)
+ }
+ pub fn lift(&self) -> LiftedWhile {
+ LiftedWhile {
+ function: self.function.to_owned(),
+ address: self.address,
+ condition: Box::new(self.condition().lift()),
+ body: Box::new(self.body().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..2usize).map(move |i| match i {
+ 0usize => ("condition", Expr(self.condition())),
+ 1usize => ("body", Expr(self.body())),
+ _ => unreachable!(),
+ })
+ }
+}
+// WHILE_SSA, DO_WHILE_SSA
+#[derive(Clone)]
+pub struct WhileSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ condition_phi: usize,
+ condition: usize,
+ body: usize,
+}
+#[derive(Clone, Debug, PartialEq)]
+pub struct LiftedWhileSsa {
+ pub function: Ref<HighLevelILFunction>,
+ pub address: u64,
+ pub condition_phi: Box<HighLevelILLiftedInstruction>,
+ pub condition: Box<HighLevelILLiftedInstruction>,
+ pub body: Box<HighLevelILLiftedInstruction>,
+}
+impl WhileSsa {
+ pub(crate) fn new(
+ function: Ref<HighLevelILFunction>,
+ address: u64,
+ condition_phi: usize,
+ condition: usize,
+ body: usize,
+ ) -> Self {
+ Self {
+ function,
+ address,
+ condition_phi,
+ condition,
+ body,
+ }
+ }
+ pub fn condition_phi(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.condition_phi)
+ }
+ pub fn condition(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.condition)
+ }
+ pub fn body(&self) -> HighLevelILInstruction {
+ get_instruction(&self.function, self.body)
+ }
+ pub fn lift(&self) -> LiftedWhileSsa {
+ LiftedWhileSsa {
+ function: self.function.to_owned(),
+ address: self.address,
+ condition_phi: Box::new(self.condition_phi().lift()),
+ condition: Box::new(self.condition().lift()),
+ body: Box::new(self.body().lift()),
+ }
+ }
+ pub fn operands(&self) -> impl Iterator<Item = (&'static str, HighLevelILOperand)> + '_ {
+ use HighLevelILOperand::*;
+ (0..3usize).map(move |i| match i {
+ 0usize => ("condition_phi", Expr(self.condition_phi())),
+ 1usize => ("condition", Expr(self.condition())),
+ 2usize => ("body", Expr(self.body())),
+ _ => unreachable!(),
+ })
+ }
+}