Add more HLIL related functions to rust

Author: rbran

rust/src/hlil/function.rs

@@ -1,18 +1,12 @@
 use std::hash::{Hash, Hasher};
 
-use binaryninjacore_sys::BNFreeHighLevelILFunction;
-use binaryninjacore_sys::BNGetHighLevelILBasicBlockList;
-use binaryninjacore_sys::BNGetHighLevelILIndexForInstruction;
-use binaryninjacore_sys::BNGetHighLevelILInstructionCount;
-use binaryninjacore_sys::BNGetHighLevelILOwnerFunction;
-use binaryninjacore_sys::BNGetHighLevelILRootExpr;
-use binaryninjacore_sys::BNGetHighLevelILSSAForm;
-use binaryninjacore_sys::BNHighLevelILFunction;
-use binaryninjacore_sys::BNNewHighLevelILFunctionReference;
+use binaryninjacore_sys::*;
 
+use crate::architecture::CoreArchitecture;
 use crate::basicblock::BasicBlock;
 use crate::function::Function;
 use crate::rc::{Array, Ref, RefCountable};
+use crate::types::{HighLevelILSSAVariable, SSAVariable, Variable};
 
 use super::{HighLevelILBlock, HighLevelILInstruction, HighLevelILLiftedInstruction};
 
@@ -73,6 +67,10 @@ impl HighLevelILFunction {
         })
     }
 
+    pub fn set_root(&self, new_root: &HighLevelILInstruction) {
+        unsafe { BNSetHighLevelILRootExpr(self.handle, new_root.index) }
+    }
+
     pub fn lifted_root(&self) -> HighLevelILLiftedInstruction {
         self.root().lift()
     }
@@ -122,6 +120,136 @@ impl HighLevelILFunction {
         }
         .to_owned()
     }
+
+    pub fn current_address(&self) -> u64 {
+        unsafe { BNHighLevelILGetCurrentAddress(self.handle) }
+    }
+
+    pub fn set_current_address(&self, address: u64, arch: Option<CoreArchitecture>) {
+        let arch = arch.unwrap_or_else(|| self.get_function().arch()).0;
+        unsafe { BNHighLevelILSetCurrentAddress(self.handle, arch, address) }
+    }
+
+    /// Gets the instruction that contains the given SSA variable's definition.
+    ///
+    /// 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, variable: SSAVariable) -> Option<HighLevelILInstruction> {
+        let index = unsafe {
+            BNGetHighLevelILSSAVarDefinition(
+                self.handle,
+                &variable.variable.raw(),
+                variable.version,
+            )
+        };
+        (index < self.instruction_count())
+            .then(|| HighLevelILInstruction::new(self.to_owned(), index))
+    }
+
+    pub fn ssa_memory_definition(&self, version: usize) -> Option<HighLevelILInstruction> {
+        let index = unsafe { BNGetHighLevelILSSAMemoryDefinition(self.handle, version) };
+        (index < self.instruction_count())
+            .then(|| HighLevelILInstruction::new(self.to_owned(), index))
+    }
+
+    /// Gets all the instructions that use the given SSA variable.
+    pub fn ssa_variable_uses(&self, variable: SSAVariable) -> Array<HighLevelILInstruction> {
+        let mut count = 0;
+        let instrs = unsafe {
+            BNGetHighLevelILSSAVarUses(
+                self.handle,
+                &variable.variable.raw(),
+                variable.version,
+                &mut count,
+            )
+        };
+        assert!(!instrs.is_null());
+        unsafe { Array::new(instrs, count, self.to_owned()) }
+    }
+
+    pub fn ssa_memory_uses(&self, version: usize) -> Array<HighLevelILInstruction> {
+        let mut count = 0;
+        let instrs = unsafe { BNGetHighLevelILSSAMemoryUses(self.handle, version, &mut count) };
+        assert!(!instrs.is_null());
+        unsafe { Array::new(instrs, count, self.to_owned()) }
+    }
+
+    /// Determines if `variable` is live at any point in the function
+    pub fn is_ssa_variable_live(&self, variable: SSAVariable) -> bool {
+        unsafe {
+            BNIsHighLevelILSSAVarLive(self.handle, &variable.variable.raw(), variable.version)
+        }
+    }
+
+    /// Determines if `variable` is live at a given point in the function
+    pub fn is_ssa_variable_live_at(
+        &self,
+        variable: SSAVariable,
+        instr: &HighLevelILInstruction,
+    ) -> bool {
+        unsafe {
+            BNIsHighLevelILSSAVarLiveAt(
+                self.handle,
+                &variable.variable.raw(),
+                variable.version,
+                instr.index,
+            )
+        }
+    }
+
+    pub fn variable_definitions(&self, variable: Variable) -> Array<HighLevelILInstruction> {
+        let mut count = 0;
+        let defs = unsafe {
+            BNGetHighLevelILVariableDefinitions(self.handle, &variable.raw(), &mut count)
+        };
+        assert!(!defs.is_null());
+        unsafe { Array::new(defs, count, self.to_owned()) }
+    }
+
+    pub fn variable_uses(&self, variable: Variable) -> Array<HighLevelILInstruction> {
+        let mut count = 0;
+        let instrs =
+            unsafe { BNGetHighLevelILVariableUses(self.handle, &variable.raw(), &mut count) };
+        assert!(!instrs.is_null());
+        unsafe { Array::new(instrs, count, self.to_owned()) }
+    }
+
+    /// Determines if `variable` is live at a given point in the function
+    pub fn is_variable_live_at(&self, variable: Variable, instr: &HighLevelILInstruction) -> bool {
+        unsafe { BNIsHighLevelILVarLiveAt(self.handle, &variable.raw(), instr.index) }
+    }
+
+    /// This gets just the HLIL variables - you may be interested in the union
+    /// of [crate::function::Function::parameter_variables] and
+    /// [crate::mlil::function::MediumLevelILFunction::aliased_variables] as well for all the
+    /// variables used in the function
+    pub fn variables(&self) -> Array<Variable> {
+        let mut count = 0;
+        let variables = unsafe { BNGetHighLevelILVariables(self.handle, &mut count) };
+        assert!(!variables.is_null());
+        unsafe { Array::new(variables, count, ()) }
+    }
+
+    /// This returns a list of Variables that are taken reference to and used
+    /// elsewhere. You may also wish to consider [HighLevelILFunction::variables]
+    /// and [crate::function::Function::parameter_variables]
+    pub fn aliased_variables(&self) -> Array<Variable> {
+        let mut count = 0;
+        let variables = unsafe { BNGetHighLevelILAliasedVariables(self.handle, &mut count) };
+        assert!(!variables.is_null());
+        unsafe { Array::new(variables, count, ()) }
+    }
+
+    /// This gets just the HLIL SSA variables - you may be interested in the union
+    /// of [crate::function::Function::parameter_variables] and
+    /// [crate::mlil::function::MediumLevelILFunction::aliased_variables] as well for all the
+    /// variables used in the function
+    pub fn ssa_variables(&self) -> Array<HighLevelILSSAVariable> {
+        let mut count = 0;
+        let variables = unsafe { BNGetHighLevelILVariables(self.handle, &mut count) };
+        assert!(!variables.is_null());
+        unsafe { Array::new(variables, count, self.to_owned()) }
+    }
 }
 
 impl ToOwned for HighLevelILFunction {

rust/src/hlil/instruction.rs

@@ -1,10 +1,12 @@
-use binaryninjacore_sys::BNGetHighLevelILByIndex;
-use binaryninjacore_sys::BNHighLevelILOperation;
+use binaryninjacore_sys::*;
 
 use crate::architecture::CoreIntrinsic;
+use crate::disassembly::DisassemblyTextLine;
 use crate::operand_iter::OperandIter;
-use crate::rc::Ref;
-use crate::types::{ConstantData, RegisterValue, RegisterValueType, SSAVariable, Variable};
+use crate::rc::{Array, CoreArrayProvider, CoreArrayProviderInner, Ref};
+use crate::types::{
+    Conf, ConstantData, RegisterValue, RegisterValueType, SSAVariable, Type, Variable,
+};
 
 use super::operation::*;
 use super::{HighLevelILFunction, HighLevelILLiftedInstruction, HighLevelILLiftedInstructionKind};
@@ -884,6 +886,48 @@ impl HighLevelILInstruction {
         }
     }
 
+    /// HLIL text lines
+    pub fn lines(&self) -> Array<DisassemblyTextLine> {
+        let mut count = 0;
+        let lines = unsafe {
+            BNGetHighLevelILExprText(
+                self.function.handle,
+                self.index,
+                self.function.full_ast,
+                &mut count,
+                core::ptr::null_mut(),
+            )
+        };
+        unsafe { Array::new(lines, count, ()) }
+    }
+
+    /// Type of expression
+    pub fn expr_type(&self) -> Option<Conf<Ref<Type>>> {
+        let result = unsafe { BNGetHighLevelILExprType(self.function.handle, self.index) };
+        (!result.type_.is_null()).then(|| {
+            Conf::new(
+                unsafe { Type::ref_from_raw(result.type_) },
+                result.confidence,
+            )
+        })
+    }
+
+    /// Version of active memory contents in SSA form for this instruction
+    pub fn ssa_memory_version(&self) -> usize {
+        unsafe { BNGetHighLevelILSSAMemoryVersionAtILInstruction(self.function.handle, self.index) }
+    }
+
+    pub fn ssa_variable_version(&self, variable: Variable) -> SSAVariable {
+        let version = unsafe {
+            BNGetHighLevelILSSAVarVersionAtILInstruction(
+                self.function.handle,
+                &variable.raw(),
+                self.index,
+            )
+        };
+        SSAVariable { variable, version }
+    }
+
     fn lift_operand(&self, expr_idx: usize) -> Box<HighLevelILLiftedInstruction> {
         Box::new(self.function.lifted_instruction_from_idx(expr_idx))
     }
@@ -963,6 +1007,22 @@ impl HighLevelILInstruction {
     }
 }
 
+impl CoreArrayProvider for HighLevelILInstruction {
+    type Raw = usize;
+    type Context = Ref<HighLevelILFunction>;
+    type Wrapped<'a> = Self;
+}
+
+unsafe impl CoreArrayProviderInner for HighLevelILInstruction {
+    unsafe fn free(raw: *mut Self::Raw, _count: usize, _context: &Self::Context) {
+        unsafe { BNFreeILInstructionList(raw) }
+    }
+
+    unsafe fn wrap_raw<'a>(raw: &'a Self::Raw, context: &'a Self::Context) -> Self::Wrapped<'a> {
+        Self::new(context.clone(), *raw)
+    }
+}
+
 impl core::fmt::Debug for HighLevelILInstruction {
     fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         write!(

rust/src/hlil/operation.rs

@@ -1,9 +1,11 @@
-use binaryninjacore_sys::BNGetGotoLabelName;
+use core::ffi;
+
+use binaryninjacore_sys::*;
 
 use crate::architecture::CoreIntrinsic;
 use crate::function::Function;
 use crate::rc::Ref;
-use crate::string::BnString;
+use crate::string::{BnStrCompatible, BnString};
 use crate::types::{ConstantData, SSAVariable, Variable};
 
 use super::HighLevelILLiftedInstruction;
@@ -18,6 +20,17 @@ impl GotoLabel {
     pub fn name(&self) -> BnString {
         unsafe { BnString::from_raw(BNGetGotoLabelName(self.function.handle, self.target)) }
     }
+
+    fn set_name<S: BnStrCompatible>(&self, name: S) {
+        let raw = name.into_bytes_with_nul();
+        unsafe {
+            BNSetUserGotoLabelName(
+                self.function.handle,
+                self.target,
+                raw.as_ref().as_ptr() as *const ffi::c_char,
+            )
+        }
+    }
 }
 
 // ADC, SBB, RLC, RRC
@@ -315,6 +328,16 @@ pub struct LiftedLabel {
     pub target: GotoLabel,
 }
 
+impl LiftedLabel {
+    pub fn name(&self) -> BnString {
+        self.target.name()
+    }
+
+    pub fn set_name<S: BnStrCompatible>(&self, name: S) {
+        self.target.set_name(name)
+    }
+}
+
 // IF
 #[derive(Copy, Clone)]
 pub struct If {

rust/src/mlil/function.rs

@@ -11,7 +11,8 @@ use crate::function::{Function, Location};
 use crate::rc::{Array, CoreArrayProvider, CoreArrayProviderInner, Ref, RefCountable};
 use crate::string::BnStrCompatible;
 use crate::types::{
-    Conf, PossibleValueSet, RegisterValue, SSAVariable, Type, UserVariableValues, Variable,
+    Conf, MediumLevelILSSAVariable, PossibleValueSet, RegisterValue, SSAVariable, Type,
+    UserVariableValues, Variable,
 };
 
 use super::{MediumLevelILBlock, MediumLevelILInstruction, MediumLevelILLiftedInstruction};
@@ -571,7 +572,7 @@ impl MediumLevelILFunction {
     /// union of [MediumLevelILFunction::aliased_variables] and
     /// [crate::function::Function::parameter_variables] for all the
     /// variables used in the function.
-    pub fn ssa_variables(&self) -> Array<Array<SSAVariable>> {
+    pub fn ssa_variables(&self) -> Array<MediumLevelILSSAVariable> {
         let mut count = 0;
         let vars = unsafe { BNGetMediumLevelILVariables(self.handle, &mut count) };
         unsafe { Array::new(vars, count, self.to_owned()) }

rust/src/types.rs

@@ -24,6 +24,7 @@ use crate::{
     callingconvention::CallingConvention,
     filemetadata::FileMetadata,
     function::Function,
+    hlil::HighLevelILFunction,
     mlil::MediumLevelILFunction,
     rc::*,
     string::{raw_to_string, BnStrCompatible, BnString},
@@ -1491,13 +1492,14 @@ unsafe impl CoreArrayProviderInner for SSAVariable {
     }
 }
 
-impl CoreArrayProvider for Array<SSAVariable> {
+pub struct MediumLevelILSSAVariable;
+impl CoreArrayProvider for MediumLevelILSSAVariable {
     type Raw = BNVariable;
     type Context = Ref<MediumLevelILFunction>;
-    type Wrapped<'a> = Self;
+    type Wrapped<'a> = Array<SSAVariable>;
 }
 
-unsafe impl CoreArrayProviderInner for Array<SSAVariable> {
+unsafe impl CoreArrayProviderInner for MediumLevelILSSAVariable {
     unsafe fn free(raw: *mut Self::Raw, _count: usize, _context: &Self::Context) {
         BNFreeVariableList(raw)
     }
@@ -1510,6 +1512,26 @@ unsafe impl CoreArrayProviderInner for Array<SSAVariable> {
     }
 }
 
+pub struct HighLevelILSSAVariable;
+impl CoreArrayProvider for HighLevelILSSAVariable {
+    type Raw = BNVariable;
+    type Context = Ref<HighLevelILFunction>;
+    type Wrapped<'a> = Array<SSAVariable>;
+}
+
+unsafe impl CoreArrayProviderInner for HighLevelILSSAVariable {
+    unsafe fn free(raw: *mut Self::Raw, _count: usize, _context: &Self::Context) {
+        BNFreeVariableList(raw)
+    }
+
+    unsafe fn wrap_raw<'a>(raw: &'a Self::Raw, context: &'a Self::Context) -> Self::Wrapped<'a> {
+        let mut count = 0;
+        let versions =
+            unsafe { BNGetHighLevelILVariableSSAVersions(context.handle, raw, &mut count) };
+        Array::new(versions, count, Variable::from_raw(*raw))
+    }
+}
+
 ///////////////
 // NamedVariable