Rename MediumLevelILInstruction to Instruction in Rust API

Author: emesare

rust/src/function.rs

@@ -2128,7 +2128,7 @@ impl Function {
 
     /// Splits a variable at the definition site. The given `var` must be the
     /// variable unique to the definition and should be obtained by using
-    /// [crate::medium_level_il::MediumLevelILInstruction::get_split_var_for_definition] at the definition site.
+    /// [crate::medium_level_il::Instruction::get_split_var_for_definition] at the definition site.
     ///
     /// This function is not meant to split variables that have been previously merged. Use
     /// [Function::unmerge_variables] to split previously merged variables.
@@ -2151,7 +2151,7 @@ impl Function {
 
     /// Undoes variable splitting performed with [Function::split_variable]. The given `var`
     /// must be the variable unique to the definition and should be obtained by using
-    /// [crate::medium_level_il::MediumLevelILInstruction::get_split_var_for_definition] at the definition site.
+    /// [crate::medium_level_il::Instruction::get_split_var_for_definition] at the definition site.
     ///
     /// * `var` - variable to unsplit
     pub fn unsplit_variable(&self, var: &Variable) {

rust/src/medium_level_il/block.rs

@@ -2,18 +2,18 @@ use crate::basic_block::{BasicBlock, BlockContext};
 use crate::rc::Ref;
 use std::ops::Range;
 
-use super::{MediumLevelILFunction, MediumLevelILInstruction, MediumLevelInstructionIndex};
+use super::{Instruction, MediumLevelILFunction, MediumLevelInstructionIndex};
 
 pub struct MediumLevelILBlock {
     pub(crate) function: Ref<MediumLevelILFunction>,
 }
 
 impl BlockContext for MediumLevelILBlock {
-    type Instruction = MediumLevelILInstruction;
+    type Instruction = Instruction;
     type InstructionIndex = MediumLevelInstructionIndex;
     type Iter = MediumLevelILBlockIter;
 
-    fn start(&self, block: &BasicBlock<Self>) -> MediumLevelILInstruction {
+    fn start(&self, block: &BasicBlock<Self>) -> Instruction {
         // TODO: instruction_from_index says that it is not mapped and will do the call
         // TODO: What if this IS already MAPPED!?!?!?
         self.function
@@ -51,7 +51,7 @@ pub struct MediumLevelILBlockIter {
 }
 
 impl Iterator for MediumLevelILBlockIter {
-    type Item = MediumLevelILInstruction;
+    type Item = Instruction;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.range

rust/src/medium_level_il/function.rs

@@ -3,7 +3,7 @@ use std::ffi::c_char;
 use std::fmt::{Debug, Formatter};
 use std::hash::{Hash, Hasher};
 
-use super::{MediumLevelILBlock, MediumLevelILInstruction, MediumLevelInstructionIndex};
+use super::{Instruction, MediumLevelILBlock, MediumLevelInstructionIndex};
 use crate::architecture::CoreArchitecture;
 use crate::basic_block::BasicBlock;
 use crate::confidence::Conf;
@@ -33,8 +33,8 @@ impl MediumLevelILFunction {
         Ref::new(Self::from_raw(handle))
     }
 
-    pub fn instruction_at<L: Into<Location>>(&self, loc: L) -> Option<MediumLevelILInstruction> {
-        Some(MediumLevelILInstruction::new(
+    pub fn instruction_at<L: Into<Location>>(&self, loc: L) -> Option<Instruction> {
+        Some(Instruction::new(
             self.to_owned(),
             self.instruction_index_at(loc)?,
         ))
@@ -61,25 +61,22 @@ impl MediumLevelILFunction {
     pub fn instruction_from_index(
         &self,
         index: MediumLevelInstructionIndex,
-    ) -> Option<MediumLevelILInstruction> {
+    ) -> Option<Instruction> {
         if index.0 >= self.instruction_count() {
             None
         } else {
-            Some(MediumLevelILInstruction::new(self.to_owned(), index))
+            Some(Instruction::new(self.to_owned(), index))
         }
     }
 
     pub fn instruction_from_expr_index(
         &self,
         expr_index: MediumLevelInstructionIndex,
-    ) -> Option<MediumLevelILInstruction> {
+    ) -> Option<Instruction> {
         if expr_index.0 >= self.expression_count() {
             None
         } else {
-            Some(MediumLevelILInstruction::new_expr(
-                self.to_owned(),
-                expr_index,
-            ))
+            Some(Instruction::new_expr(self.to_owned(), expr_index))
         }
     }
 
@@ -113,7 +110,7 @@ impl MediumLevelILFunction {
         unsafe { Array::new(blocks, count, context) }
     }
 
-    pub fn var_definitions(&self, var: &Variable) -> Array<MediumLevelILInstruction> {
+    pub fn var_definitions(&self, var: &Variable) -> Array<Instruction> {
         let mut count = 0;
         let raw_var = BNVariable::from(var);
         let raw_instr_idxs =
@@ -407,7 +404,7 @@ impl MediumLevelILFunction {
 
     /// Returns the [`BasicBlock`] at the given instruction `index`.
     ///
-    /// You can also retrieve this using [`MediumLevelILInstruction::basic_block`].
+    /// You can also retrieve this using [`Instruction::basic_block`].
     pub fn basic_block_containing_index(
         &self,
         index: MediumLevelInstructionIndex,
@@ -466,10 +463,7 @@ impl MediumLevelILFunction {
     ///
     /// Since SSA variables can only be defined once, this will return the single instruction where that occurs.
     /// For SSA variable version 0s, which don't have definitions, this will return `None` instead.
-    pub fn ssa_variable_definition(
-        &self,
-        ssa_variable: &SSAVariable,
-    ) -> Option<MediumLevelILInstruction> {
+    pub fn ssa_variable_definition(&self, ssa_variable: &SSAVariable) -> Option<Instruction> {
         let raw_var = BNVariable::from(ssa_variable.variable);
         let result = unsafe {
             BNGetMediumLevelILSSAVarDefinition(self.handle, &raw_var, ssa_variable.version)
@@ -478,14 +472,14 @@ impl MediumLevelILFunction {
         self.instruction_from_index(MediumLevelInstructionIndex(result))
     }
 
-    pub fn ssa_memory_definition(&self, version: usize) -> Option<MediumLevelILInstruction> {
+    pub fn ssa_memory_definition(&self, version: usize) -> Option<Instruction> {
         let result = unsafe { BNGetMediumLevelILSSAMemoryDefinition(self.handle, version) };
         // TODO: Does this return the expression or instruction index? Also we dont diff and this prob doesnt work.
         self.instruction_from_index(MediumLevelInstructionIndex(result))
     }
 
     /// Gets all the instructions that use the given SSA variable.
-    pub fn ssa_variable_uses(&self, ssa_variable: &SSAVariable) -> Array<MediumLevelILInstruction> {
+    pub fn ssa_variable_uses(&self, ssa_variable: &SSAVariable) -> Array<Instruction> {
         let mut count = 0;
         let raw_var = BNVariable::from(ssa_variable.variable);
         let uses = unsafe {
@@ -495,7 +489,7 @@ impl MediumLevelILFunction {
         unsafe { Array::new(uses, count, self.to_owned()) }
     }
 
-    pub fn ssa_memory_uses(&self, version: usize) -> Array<MediumLevelILInstruction> {
+    pub fn ssa_memory_uses(&self, version: usize) -> Array<Instruction> {
         let mut count = 0;
         let uses = unsafe { BNGetMediumLevelILSSAMemoryUses(self.handle, version, &mut count) };
         assert!(!uses.is_null());
@@ -508,15 +502,15 @@ impl MediumLevelILFunction {
         unsafe { BNIsMediumLevelILSSAVarLive(self.handle, &raw_var, ssa_variable.version) }
     }
 
-    pub fn variable_definitions(&self, variable: &Variable) -> Array<MediumLevelILInstruction> {
+    pub fn variable_definitions(&self, variable: &Variable) -> Array<Instruction> {
         let mut count = 0;
         let raw_var = BNVariable::from(variable);
         let defs =
             unsafe { BNGetMediumLevelILVariableDefinitions(self.handle, &raw_var, &mut count) };
         unsafe { Array::new(defs, count, self.to_owned()) }
     }
 
-    pub fn variable_uses(&self, variable: &Variable) -> Array<MediumLevelILInstruction> {
+    pub fn variable_uses(&self, variable: &Variable) -> Array<Instruction> {
         let mut count = 0;
         let raw_var = BNVariable::from(variable);
         let uses = unsafe { BNGetMediumLevelILVariableUses(self.handle, &raw_var, &mut count) };
@@ -534,7 +528,7 @@ impl MediumLevelILFunction {
         &self,
         variable: &Variable,
         include_last_user: bool,
-    ) -> Array<MediumLevelILInstruction> {
+    ) -> Array<Instruction> {
         let mut count = 0;
         let raw_var = BNVariable::from(variable);
         let uses = unsafe {

rust/src/medium_level_il/instruction.rs

@@ -42,16 +42,16 @@ impl Display for MediumLevelInstructionIndex {
 }
 
 #[derive(Clone)]
-pub struct MediumLevelILInstruction {
+pub struct Instruction {
     pub function: Ref<MediumLevelILFunction>,
     pub address: u64,
     // TODO; Because this structure is incorrectly named instruction, we want to make it clear that we actually have the expression index.
     pub expr_index: MediumLevelInstructionIndex,
     pub size: usize,
-    pub kind: MediumLevelILInstructionKind,
+    pub kind: InstructionKind,
 }
 
-impl MediumLevelILInstruction {
+impl Instruction {
     pub(crate) fn new(
         function: Ref<MediumLevelILFunction>,
         index: MediumLevelInstructionIndex,
@@ -69,7 +69,7 @@ impl MediumLevelILInstruction {
         // TODO: If op.sourceOperation == BN_INVALID_OPERAND && op.operation == MLIL_NOP return None
         let op = unsafe { BNGetMediumLevelILByIndex(function.handle, expr_index.0) };
         use BNMediumLevelILOperation::*;
-        use MediumLevelILInstructionKind as Op;
+        use InstructionKind as Op;
         let kind = match op.operation {
             MLIL_NOP => Op::Nop,
             MLIL_NORET => Op::Noret,
@@ -624,7 +624,7 @@ impl MediumLevelILInstruction {
     }
 
     pub fn lift(&self) -> MediumLevelILLiftedInstruction {
-        use MediumLevelILInstructionKind::*;
+        use InstructionKind::*;
         use MediumLevelILLiftedInstructionKind as Lifted;
 
         let kind = match self.kind {
@@ -970,7 +970,7 @@ impl MediumLevelILInstruction {
         unsafe { BNGetMediumLevelILExprValue(self.function.handle, self.expr_index.0) }.into()
     }
 
-    /// Returns the [`BasicBlock`] containing the given [`MediumLevelILInstruction`].
+    /// Returns the [`BasicBlock`] containing the given [`Instruction`].
     pub fn basic_block(&self) -> Option<Ref<BasicBlock<MediumLevelILBlock>>> {
         // TODO: We might be able to .expect this if we guarantee that self.index is valid.
         self.function.basic_block_containing_index(self.expr_index)
@@ -1057,7 +1057,7 @@ impl MediumLevelILInstruction {
         unsafe { Array::new(deps, count, self.function.clone()) }
     }
 
-    pub fn branch_dependence_at(&self, instruction: MediumLevelILInstruction) -> BranchDependence {
+    pub fn branch_dependence_at(&self, instruction: Instruction) -> BranchDependence {
         let deps = unsafe {
             BNGetMediumLevelILBranchDependence(
                 self.function.handle,
@@ -1377,7 +1377,7 @@ impl MediumLevelILInstruction {
         Variable::new(var.ty, index, var.storage)
     }
 
-    /// alias for [MediumLevelILInstruction::split_var_for_definition]
+    /// alias for [Instruction::split_var_for_definition]
     #[inline]
     pub fn get_split_var_for_definition(&self, var: &Variable) -> Variable {
         self.split_var_for_definition(var)
@@ -1466,7 +1466,7 @@ impl MediumLevelILInstruction {
     }
 }
 
-impl Debug for MediumLevelILInstruction {
+impl Debug for Instruction {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.debug_struct("MediumLevelILInstruction")
             .field("address", &self.address)
@@ -1477,13 +1477,13 @@ impl Debug for MediumLevelILInstruction {
     }
 }
 
-impl CoreArrayProvider for MediumLevelILInstruction {
+impl CoreArrayProvider for Instruction {
     type Raw = usize;
     type Context = Ref<MediumLevelILFunction>;
     type Wrapped<'a> = Self;
 }
 
-unsafe impl CoreArrayProviderInner for MediumLevelILInstruction {
+unsafe impl CoreArrayProviderInner for Instruction {
     unsafe fn free(raw: *mut Self::Raw, _count: usize, _context: &Self::Context) {
         BNFreeILInstructionList(raw)
     }
@@ -1498,7 +1498,7 @@ unsafe impl CoreArrayProviderInner for MediumLevelILInstruction {
 }
 
 #[derive(Debug, Copy, Clone)]
-pub enum MediumLevelILInstructionKind {
+pub enum InstructionKind {
     Nop,
     Noret,
     Bp,
@@ -1661,7 +1661,7 @@ fn get_call_output(function: &MediumLevelILFunction, idx: usize) -> impl Iterato
 fn get_call_params(
     function: &MediumLevelILFunction,
     idx: usize,
-) -> impl Iterator<Item = MediumLevelILInstruction> {
+) -> impl Iterator<Item = Instruction> {
     let op = get_raw_operation(function, idx);
     assert_eq!(op.operation, BNMediumLevelILOperation::MLIL_CALL_PARAM);
     OperandIter::new(function, op.operands[1] as usize, op.operands[0] as usize).exprs()
@@ -1679,15 +1679,15 @@ fn get_call_output_ssa(
 fn get_call_params_ssa(
     function: &MediumLevelILFunction,
     idx: usize,
-) -> impl Iterator<Item = MediumLevelILInstruction> {
+) -> impl Iterator<Item = Instruction> {
     let op = get_raw_operation(function, idx);
     assert_eq!(op.operation, BNMediumLevelILOperation::MLIL_CALL_PARAM_SSA);
     OperandIter::new(function, op.operands[2] as usize, op.operands[1] as usize).exprs()
 }
 
 /// Conditional branching instruction and an expected conditional result
 pub struct BranchDependence {
-    pub instruction: MediumLevelILInstruction,
+    pub instruction: Instruction,
     pub dependence: ILBranchDependence,
 }
 
@@ -1704,10 +1704,7 @@ unsafe impl CoreArrayProviderInner for BranchDependence {
 
     unsafe fn wrap_raw<'a>(raw: &'a Self::Raw, context: &'a Self::Context) -> Self::Wrapped<'a> {
         Self {
-            instruction: MediumLevelILInstruction::new(
-                context.clone(),
-                MediumLevelInstructionIndex(raw.branch),
-            ),
+            instruction: Instruction::new(context.clone(), MediumLevelInstructionIndex(raw.branch)),
             dependence: raw.dependence,
         }
     }

rust/src/operand_iter.rs

@@ -7,7 +7,7 @@ use crate::high_level_il::{
     HighLevelILFunction, HighLevelInstructionIndex, Instruction as HighLevelILInstruction,
 };
 use crate::medium_level_il::{
-    MediumLevelILFunction, MediumLevelILInstruction, MediumLevelInstructionIndex,
+    Instruction as MediumLevelILInstruction, MediumLevelILFunction, MediumLevelInstructionIndex,
 };
 use crate::rc::{Ref, RefCountable};
 use crate::variable::{SSAVariable, Variable};

rust/tests/medium_level_il.rs

@@ -1,6 +1,6 @@
 use binaryninja::binary_view::BinaryViewExt;
 use binaryninja::headless::Session;
-use binaryninja::medium_level_il::{MediumLevelILInstructionKind, MediumLevelInstructionIndex};
+use binaryninja::medium_level_il::{InstructionKind, MediumLevelInstructionIndex};
 use std::path::PathBuf;
 
 #[test]
@@ -23,7 +23,7 @@ fn test_mlil_info() {
     assert_eq!(instr_0.address, image_base + 0x00025f10);
     println!("{:?}", instr_0.kind);
     match instr_0.kind {
-        MediumLevelILInstructionKind::SetVar(op) => {
+        InstructionKind::SetVar(op) => {
             assert_eq!(op.dest.index, 524288);
             assert_eq!(op.src, 0);
         }
@@ -35,7 +35,7 @@ fn test_mlil_info() {
     assert_eq!(instr_1.address, image_base + 0x00025f15);
     println!("{:?}", instr_1.kind);
     match instr_1.kind {
-        MediumLevelILInstructionKind::SetVar(op) => {
+        InstructionKind::SetVar(op) => {
             assert_eq!(op.dest.index, 5);
             assert_eq!(op.src, 2);
         }
@@ -47,7 +47,7 @@ fn test_mlil_info() {
     assert_eq!(instr_2.address, image_base + 0x00025f18);
     println!("{:?}", instr_2.kind);
     match instr_2.kind {
-        MediumLevelILInstructionKind::SetVar(op) => {
+        InstructionKind::SetVar(op) => {
             assert_eq!(op.dest.index, 8);
             assert_eq!(op.src, 4);
         }
@@ -59,7 +59,7 @@ fn test_mlil_info() {
     assert_eq!(instr_3.address, image_base + 0x00025f19);
     println!("{:?}", instr_3.kind);
     match instr_3.kind {
-        MediumLevelILInstructionKind::Call(op) => {
+        InstructionKind::Call(op) => {
             assert_eq!(op.first_output, 8);
             assert_eq!(op.num_outputs, 1);
             assert_eq!(op.dest, 7);
@@ -74,7 +74,7 @@ fn test_mlil_info() {
     assert_eq!(instr_4.address, image_base + 0x00025f22);
     println!("{:?}", instr_4.kind);
     match instr_4.kind {
-        MediumLevelILInstructionKind::Ret(op) => {
+        InstructionKind::Ret(op) => {
             assert_eq!(op.first_operand, 12);
             assert_eq!(op.num_operands, 1);
         }