Rename LowLevelILInstruction to Instruction in Rust API

emesare · emesare · commit 4c03aca0c214 · 2025-05-03T22:14:58.000-04:00
diff --git a/arch/riscv/src/lib.rs b/arch/riscv/src/lib.rs
@@ -38,7 +38,7 @@ use binaryninja::architecture::{BranchKind, IntrinsicId, RegisterId};
 use binaryninja::confidence::{Conf, MAX_CONFIDENCE, MIN_CONFIDENCE};
 use binaryninja::logger::Logger;
 use binaryninja::low_level_il::expression::{LowLevelILExpressionKind, ValueExpr};
-use binaryninja::low_level_il::instruction::LowLevelILInstructionKind;
+use binaryninja::low_level_il::instruction::InstructionKind;
 use binaryninja::low_level_il::lifting::{
     LiftableLowLevelIL, LiftableLowLevelILWithSize, LowLevelILLabel,
 };
@@ -2866,7 +2866,7 @@ impl FunctionRecognizer for RiscVELFPLTRecognizer {
         // Match instruction that fetches PC-relative PLT address range
         let auipc = next_llil_instr.next().unwrap().kind();
         let (auipc_dest, plt_base) = match auipc {
-            LowLevelILInstructionKind::SetReg(r) => {
+            InstructionKind::SetReg(r) => {
                 let value = match r.source_expr().kind() {
                     LowLevelILExpressionKind::Const(v) | LowLevelILExpressionKind::ConstPtr(v) => {
                         v.value()
@@ -2881,7 +2881,7 @@ impl FunctionRecognizer for RiscVELFPLTRecognizer {
         // Match load instruction that loads the imported address
         let load = next_llil_instr.next().unwrap().kind();
         let (mut entry, mut target_reg) = match load {
-            LowLevelILInstructionKind::SetReg(r) => match r.source_expr().kind() {
+            InstructionKind::SetReg(r) => match r.source_expr().kind() {
                 LowLevelILExpressionKind::Load(l) => {
                     let target_reg = r.dest_reg();
                     let entry = match l.source_mem_expr().kind() {
@@ -2943,7 +2943,7 @@ impl FunctionRecognizer for RiscVELFPLTRecognizer {
         // (OPTIONAL) Check if we are storing in temp0, adjust target reg if so
         let mut temp_reg_inst = next_llil_instr.next().unwrap().kind();
         match &temp_reg_inst {
-            LowLevelILInstructionKind::SetReg(r) if llil.instruction_count() >= 5 => {
+            InstructionKind::SetReg(r) if llil.instruction_count() >= 5 => {
                 match r.source_expr().kind() {
                     LowLevelILExpressionKind::Reg(op) if target_reg == op.source_reg() => {
                         // Update the target_reg to the temp reg.
@@ -2959,7 +2959,7 @@ impl FunctionRecognizer for RiscVELFPLTRecognizer {
         // Match instruction that stores the next instruction address into a register
         let next_pc_inst = temp_reg_inst;
         let (next_pc_dest, next_pc, cur_pc) = match next_pc_inst {
-            LowLevelILInstructionKind::SetReg(r) => {
+            InstructionKind::SetReg(r) => {
                 let value = match r.source_expr().kind() {
                     LowLevelILExpressionKind::Const(v) | LowLevelILExpressionKind::ConstPtr(v) => {
                         v.value()
@@ -2977,13 +2977,13 @@ impl FunctionRecognizer for RiscVELFPLTRecognizer {
         // Match tail call at the end and make sure it is going to the import
         let jump = next_llil_instr.next().unwrap().kind();
         match jump {
-            LowLevelILInstructionKind::TailCall(j) => {
+            InstructionKind::TailCall(j) => {
                 match j.target().kind() {
                     LowLevelILExpressionKind::Reg(r) if r.source_reg() == target_reg => (),
                     _ => return false,
                 };
             }
-            LowLevelILInstructionKind::Jump(j) => {
+            InstructionKind::Jump(j) => {
                 match j.target().kind() {
                     LowLevelILExpressionKind::Reg(r) if r.source_reg() == target_reg => (),
                     _ => return false,
diff --git a/plugins/warp/src/lib.rs b/plugins/warp/src/lib.rs
@@ -13,9 +13,7 @@ use binaryninja::low_level_il::expression::{ExpressionHandler, LowLevelILExpress
 use binaryninja::low_level_il::function::{
     FunctionMutability, LowLevelILFunction, NonSSA, RegularNonSSA,
 };
-use binaryninja::low_level_il::instruction::{
-    InstructionHandler, LowLevelILInstruction, LowLevelILInstructionKind,
-};
+use binaryninja::low_level_il::instruction::{Instruction, InstructionHandler, InstructionKind};
 use binaryninja::low_level_il::{LowLevelILRegisterKind, VisitorAction};
 use binaryninja::rc::Ref as BNRef;
 use std::path::PathBuf;
@@ -98,10 +96,10 @@ pub fn basic_block_guid<M: FunctionMutability>(
     let max_instr_len = arch.max_instr_len();
 
     // NOPs and useless moves are blacklisted to allow for hot-patchable functions.
-    let is_blacklisted_instr = |instr: &LowLevelILInstruction<M, NonSSA<RegularNonSSA>>| {
+    let is_blacklisted_instr = |instr: &Instruction<M, NonSSA<RegularNonSSA>>| {
         match instr.kind() {
-            LowLevelILInstructionKind::Nop(_) => true,
-            LowLevelILInstructionKind::SetReg(op) => {
+            InstructionKind::Nop(_) => true,
+            InstructionKind::SetReg(op) => {
                 match op.source_expr().kind() {
                     LowLevelILExpressionKind::Reg(source_op)
                         if op.dest_reg() == source_op.source_reg() =>
@@ -126,7 +124,7 @@ pub fn basic_block_guid<M: FunctionMutability>(
         }
     };
 
-    let is_variant_instr = |instr: &LowLevelILInstruction<M, NonSSA<RegularNonSSA>>| {
+    let is_variant_instr = |instr: &Instruction<M, NonSSA<RegularNonSSA>>| {
         let is_variant_expr = |expr: &LowLevelILExpressionKind<M, NonSSA<RegularNonSSA>>| {
             // TODO: Checking the section here is slow, we should gather all section ranges outside of this.
             match expr {
diff --git a/rust/src/low_level_il.rs b/rust/src/low_level_il.rs
@@ -40,10 +40,9 @@ pub type LiftedILFunction = LowLevelILFunction<Finalized, NonSSA<LiftedNonSSA>>;
 pub type MutableLiftedILExpr<'a, ReturnType> =
     LowLevelILExpression<'a, Mutable, NonSSA<LiftedNonSSA>, ReturnType>;
 pub type RegularLowLevelILFunction = LowLevelILFunction<Finalized, NonSSA<RegularNonSSA>>;
-pub type RegularLowLevelILInstruction<'a> =
-    LowLevelILInstruction<'a, Finalized, NonSSA<RegularNonSSA>>;
+pub type RegularLowLevelILInstruction<'a> = Instruction<'a, Finalized, NonSSA<RegularNonSSA>>;
 pub type RegularLowLevelILInstructionKind<'a> =
-    LowLevelILInstructionKind<'a, Finalized, NonSSA<RegularNonSSA>>;
+    InstructionKind<'a, Finalized, NonSSA<RegularNonSSA>>;
 pub type RegularLowLevelILExpression<'a, ReturnType> =
     LowLevelILExpression<'a, Finalized, NonSSA<RegularNonSSA>, ReturnType>;
 pub type RegularLowLevelILExpressionKind<'a> =
diff --git a/rust/src/low_level_il/block.rs b/rust/src/low_level_il/block.rs
@@ -33,11 +33,11 @@ where
     M: FunctionMutability,
     F: FunctionForm,
 {
-    type Instruction = LowLevelILInstruction<'func, M, F>;
+    type Instruction = Instruction<'func, M, F>;
     type InstructionIndex = LowLevelInstructionIndex;
     type Iter = LowLevelILBlockIter<'func, M, F>;
 
-    fn start(&self, block: &BasicBlock<Self>) -> LowLevelILInstruction<'func, M, F> {
+    fn start(&self, block: &BasicBlock<Self>) -> Instruction<'func, M, F> {
         self.function
             .instruction_from_index(block.start_index())
             .unwrap()
@@ -90,7 +90,7 @@ where
     M: FunctionMutability,
     F: FunctionForm,
 {
-    type Item = LowLevelILInstruction<'func, M, F>;
+    type Item = Instruction<'func, M, F>;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.range
diff --git a/rust/src/low_level_il/function.rs b/rust/src/low_level_il/function.rs
@@ -105,11 +105,8 @@ where
         }
     }
 
-    pub fn instruction_at<L: Into<Location>>(&self, loc: L) -> Option<LowLevelILInstruction<M, F>> {
-        Some(LowLevelILInstruction::new(
-            self,
-            self.instruction_index_at(loc)?,
-        ))
+    pub fn instruction_at<L: Into<Location>>(&self, loc: L) -> Option<Instruction<M, F>> {
+        Some(Instruction::new(self, self.instruction_index_at(loc)?))
     }
 
     pub fn instruction_index_at<L: Into<Location>>(
@@ -132,11 +129,11 @@ where
     pub fn instruction_from_index(
         &self,
         index: LowLevelInstructionIndex,
-    ) -> Option<LowLevelILInstruction<M, F>> {
+    ) -> Option<Instruction<M, F>> {
         if index.0 >= self.instruction_count() {
             None
         } else {
-            Some(LowLevelILInstruction::new(self, index))
+            Some(Instruction::new(self, index))
         }
     }
 
diff --git a/rust/src/low_level_il/instruction.rs b/rust/src/low_level_il/instruction.rs
@@ -49,13 +49,12 @@ impl Display for LowLevelInstructionIndex {
     }
 }
 
-// TODO: Probably want to rename this with a LowLevelIL prefix to avoid collisions when we add handlers for other ILs
 pub trait InstructionHandler<'func, M, F>
 where
     M: FunctionMutability,
     F: FunctionForm,
 {
-    fn kind(&self) -> LowLevelILInstructionKind<'func, M, F>;
+    fn kind(&self) -> InstructionKind<'func, M, F>;
 
     /// Visit the sub expressions of this instruction.
     ///
@@ -65,7 +64,7 @@ where
         T: FnMut(&LowLevelILExpression<'func, M, F, ValueExpr>) -> VisitorAction;
 }
 
-pub struct LowLevelILInstruction<'func, M, F>
+pub struct Instruction<'func, M, F>
 where
     M: FunctionMutability,
     F: FunctionForm,
@@ -74,7 +73,7 @@ where
     pub index: LowLevelInstructionIndex,
 }
 
-impl<'func, M, F> LowLevelILInstruction<'func, M, F>
+impl<'func, M, F> Instruction<'func, M, F>
 where
     M: FunctionMutability,
     F: FunctionForm,
@@ -100,7 +99,7 @@ where
     }
 }
 
-impl<'func, M, F> Debug for LowLevelILInstruction<'func, M, F>
+impl<'func, M, F> Debug for Instruction<'func, M, F>
 where
     M: FunctionMutability,
     F: FunctionForm,
@@ -114,21 +113,19 @@ where
     }
 }
 
-impl<'func, M> InstructionHandler<'func, M, SSA> for LowLevelILInstruction<'func, M, SSA>
+impl<'func, M> InstructionHandler<'func, M, SSA> for Instruction<'func, M, SSA>
 where
     M: FunctionMutability,
 {
-    fn kind(&self) -> LowLevelILInstructionKind<'func, M, SSA> {
+    fn kind(&self) -> InstructionKind<'func, M, SSA> {
         #[allow(unused_imports)]
         use binaryninjacore_sys::BNLowLevelILOperation::*;
         let raw_op = self.into_raw();
         #[allow(clippy::match_single_binding)]
         match raw_op.operation {
             // Any invalid ops for Non-Lifted IL will be checked here.
             // SAFETY: We have checked for illegal operations.
-            _ => unsafe {
-                LowLevelILInstructionKind::from_raw(self.function, self.expr_idx(), raw_op)
-            },
+            _ => unsafe { InstructionKind::from_raw(self.function, self.expr_idx(), raw_op) },
         }
     }
 
@@ -142,21 +139,19 @@ where
 }
 
 impl<'func, M> InstructionHandler<'func, M, NonSSA<LiftedNonSSA>>
-    for LowLevelILInstruction<'func, M, NonSSA<LiftedNonSSA>>
+    for Instruction<'func, M, NonSSA<LiftedNonSSA>>
 where
     M: FunctionMutability,
 {
-    fn kind(&self) -> LowLevelILInstructionKind<'func, M, NonSSA<LiftedNonSSA>> {
+    fn kind(&self) -> InstructionKind<'func, M, NonSSA<LiftedNonSSA>> {
         #[allow(unused_imports)]
         use binaryninjacore_sys::BNLowLevelILOperation::*;
         let raw_op = self.into_raw();
         #[allow(clippy::match_single_binding)]
         match raw_op.operation {
             // Any invalid ops for Non-Lifted IL will be checked here.
             // SAFETY: We have checked for illegal operations.
-            _ => unsafe {
-                LowLevelILInstructionKind::from_raw(self.function, self.expr_idx(), raw_op)
-            },
+            _ => unsafe { InstructionKind::from_raw(self.function, self.expr_idx(), raw_op) },
         }
     }
 
@@ -170,21 +165,19 @@ where
 }
 
 impl<'func, M> InstructionHandler<'func, M, NonSSA<RegularNonSSA>>
-    for LowLevelILInstruction<'func, M, NonSSA<RegularNonSSA>>
+    for Instruction<'func, M, NonSSA<RegularNonSSA>>
 where
     M: FunctionMutability,
 {
-    fn kind(&self) -> LowLevelILInstructionKind<'func, M, NonSSA<RegularNonSSA>> {
+    fn kind(&self) -> InstructionKind<'func, M, NonSSA<RegularNonSSA>> {
         #[allow(unused_imports)]
         use binaryninjacore_sys::BNLowLevelILOperation::*;
         let raw_op = self.into_raw();
         #[allow(clippy::match_single_binding)]
         match raw_op.operation {
             // Any invalid ops for Non-Lifted IL will be checked here.
             // SAFETY: We have checked for illegal operations.
-            _ => unsafe {
-                LowLevelILInstructionKind::from_raw(self.function, self.expr_idx(), raw_op)
-            },
+            _ => unsafe { InstructionKind::from_raw(self.function, self.expr_idx(), raw_op) },
         }
     }
 
@@ -200,7 +193,7 @@ where
 }
 
 #[derive(Debug)]
-pub enum LowLevelILInstructionKind<'func, M, F>
+pub enum InstructionKind<'func, M, F>
 where
     M: FunctionMutability,
     F: FunctionForm,
@@ -237,7 +230,7 @@ where
     Value(LowLevelILExpression<'func, M, F, ValueExpr>),
 }
 
-impl<'func, M, F> LowLevelILInstructionKind<'func, M, F>
+impl<'func, M, F> InstructionKind<'func, M, F>
 where
     M: FunctionMutability,
     F: FunctionForm,
@@ -250,59 +243,55 @@ where
         use binaryninjacore_sys::BNLowLevelILOperation::*;
 
         match op.operation {
-            LLIL_NOP => LowLevelILInstructionKind::Nop(Operation::new(function, op)),
+            LLIL_NOP => InstructionKind::Nop(Operation::new(function, op)),
             LLIL_SET_REG | LLIL_SET_REG_SSA => {
-                LowLevelILInstructionKind::SetReg(Operation::new(function, op))
+                InstructionKind::SetReg(Operation::new(function, op))
             }
             LLIL_SET_REG_SPLIT | LLIL_SET_REG_SPLIT_SSA => {
-                LowLevelILInstructionKind::SetRegSplit(Operation::new(function, op))
+                InstructionKind::SetRegSplit(Operation::new(function, op))
             }
             LLIL_SET_FLAG | LLIL_SET_FLAG_SSA => {
-                LowLevelILInstructionKind::SetFlag(Operation::new(function, op))
+                InstructionKind::SetFlag(Operation::new(function, op))
             }
-            LLIL_STORE | LLIL_STORE_SSA => {
-                LowLevelILInstructionKind::Store(Operation::new(function, op))
-            }
-            LLIL_PUSH => LowLevelILInstructionKind::Push(Operation::new(function, op)),
+            LLIL_STORE | LLIL_STORE_SSA => InstructionKind::Store(Operation::new(function, op)),
+            LLIL_PUSH => InstructionKind::Push(Operation::new(function, op)),
 
-            LLIL_REG_STACK_PUSH => {
-                LowLevelILInstructionKind::RegStackPush(Operation::new(function, op))
-            }
+            LLIL_REG_STACK_PUSH => InstructionKind::RegStackPush(Operation::new(function, op)),
 
-            LLIL_JUMP => LowLevelILInstructionKind::Jump(Operation::new(function, op)),
-            LLIL_JUMP_TO => LowLevelILInstructionKind::JumpTo(Operation::new(function, op)),
+            LLIL_JUMP => InstructionKind::Jump(Operation::new(function, op)),
+            LLIL_JUMP_TO => InstructionKind::JumpTo(Operation::new(function, op)),
 
             LLIL_CALL | LLIL_CALL_STACK_ADJUST | LLIL_CALL_SSA => {
-                LowLevelILInstructionKind::Call(Operation::new(function, op))
+                InstructionKind::Call(Operation::new(function, op))
             }
             LLIL_TAILCALL | LLIL_TAILCALL_SSA => {
-                LowLevelILInstructionKind::TailCall(Operation::new(function, op))
+                InstructionKind::TailCall(Operation::new(function, op))
             }
 
-            LLIL_RET => LowLevelILInstructionKind::Ret(Operation::new(function, op)),
-            LLIL_NORET => LowLevelILInstructionKind::NoRet(Operation::new(function, op)),
+            LLIL_RET => InstructionKind::Ret(Operation::new(function, op)),
+            LLIL_NORET => InstructionKind::NoRet(Operation::new(function, op)),
 
-            LLIL_IF => LowLevelILInstructionKind::If(Operation::new(function, op)),
-            LLIL_GOTO => LowLevelILInstructionKind::Goto(Operation::new(function, op)),
+            LLIL_IF => InstructionKind::If(Operation::new(function, op)),
+            LLIL_GOTO => InstructionKind::Goto(Operation::new(function, op)),
 
             LLIL_SYSCALL | LLIL_SYSCALL_SSA => {
-                LowLevelILInstructionKind::Syscall(Operation::new(function, op))
+                InstructionKind::Syscall(Operation::new(function, op))
             }
             LLIL_INTRINSIC | LLIL_INTRINSIC_SSA => {
-                LowLevelILInstructionKind::Intrinsic(Operation::new(function, op))
+                InstructionKind::Intrinsic(Operation::new(function, op))
             }
-            LLIL_BP => LowLevelILInstructionKind::Bp(Operation::new(function, op)),
-            LLIL_TRAP => LowLevelILInstructionKind::Trap(Operation::new(function, op)),
-            LLIL_UNDEF => LowLevelILInstructionKind::Undef(Operation::new(function, op)),
-            _ => LowLevelILInstructionKind::Value(LowLevelILExpression::new(function, expr_index)),
+            LLIL_BP => InstructionKind::Bp(Operation::new(function, op)),
+            LLIL_TRAP => InstructionKind::Trap(Operation::new(function, op)),
+            LLIL_UNDEF => InstructionKind::Undef(Operation::new(function, op)),
+            _ => InstructionKind::Value(LowLevelILExpression::new(function, expr_index)),
         }
     }
 
     fn visit_sub_expressions<T>(&self, mut visitor: T) -> VisitorAction
     where
         T: FnMut(&LowLevelILExpression<'func, M, F, ValueExpr>) -> VisitorAction,
     {
-        use LowLevelILInstructionKind::*;
+        use InstructionKind::*;
 
         macro_rules! visit {
             ($expr:expr) => {
diff --git a/rust/src/low_level_il/operation.rs b/rust/src/low_level_il/operation.rs
diff --git a/rust/tests/low_level_il.rs b/rust/tests/low_level_il.rs

Original file line number	Diff line number	Diff line change
`@@ -105,11 +105,8 @@ where`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`
`108`		`- pub fn instruction_at<L: Into<Location>>(&self, loc: L) -> Option<LowLevelILInstruction<M, F>> {`
`109`		`- Some(LowLevelILInstruction::new(`
`110`		`- self,`
`111`		`- self.instruction_index_at(loc)?,`
`112`		`- ))`
	`108`	`+ pub fn instruction_at<L: Into<Location>>(&self, loc: L) -> Option<Instruction<M, F>> {`
	`109`	`+ Some(Instruction::new(self, self.instruction_index_at(loc)?))`
`113`	`110`	`}`
`114`	`111`
`115`	`112`	`pub fn instruction_index_at<L: Into<Location>>(`
`@@ -132,11 +129,11 @@ where`
`132`	`129`	`pub fn instruction_from_index(`
`133`	`130`	`&self,`
`134`	`131`	`index: LowLevelInstructionIndex,`
`135`		`- ) -> Option<LowLevelILInstruction<M, F>> {`
	`132`	`+ ) -> Option<Instruction<M, F>> {`
`136`	`133`	`if index.0 >= self.instruction_count() {`
`137`	`134`	`None`
`138`	`135`	`} else {`
`139`		`- Some(LowLevelILInstruction::new(self, index))`
	`136`	`+ Some(Instruction::new(self, index))`
`140`	`137`	`}`
`141`	`138`	`}`
`142`	`139`