Add inlined unresolved indirect branches to rust BB analysis context

Author: zznop

rust/src/architecture.rs

@@ -1952,7 +1952,6 @@ pub struct BasicBlockAnalysisContext {
     pub translate_tail_calls: bool,
     pub disallow_branch_to_string: bool,
     pub max_function_size: u64,
-    pub halt_on_invalid_instruction: bool,
     pub max_size_reached: bool,
 
     // In/Out
@@ -1962,6 +1961,7 @@ pub struct BasicBlockAnalysisContext {
     direct_code_references: HashMap<u64, ArchAndAddr>,
     direct_no_return_calls: HashSet<ArchAndAddr>,
     halted_disassembly_addresses: HashSet<ArchAndAddr>,
+    inlined_unresolved_indirect_branches: HashSet<ArchAndAddr>,
 }
 
 impl BasicBlockAnalysisContext {
@@ -2021,6 +2021,15 @@ impl BasicBlockAnalysisContext {
             })
             .collect::<HashSet<_>>();
 
+        let inlined_unresolved_indirect_branches = (0..ctx_ref
+            .inlinedUnresolvedIndirectBranchCount)
+            .map(|i| {
+                let raw =
+                    unsafe { std::ptr::read(ctx_ref.inlinedUnresolvedIndirectBranches.add(i)) };
+                ArchAndAddr::from(raw)
+            })
+            .collect::<HashSet<_>>();
+
         BasicBlockAnalysisContext {
             handle,
             contextual_returns_dirty: false,
@@ -2030,12 +2039,12 @@ impl BasicBlockAnalysisContext {
             translate_tail_calls: ctx_ref.translateTailCalls,
             disallow_branch_to_string: ctx_ref.disallowBranchToString,
             max_function_size: ctx_ref.maxFunctionSize,
-            halt_on_invalid_instruction: ctx_ref.haltOnInvalidInstructions,
             max_size_reached: ctx_ref.maxSizeReached,
             contextual_returns,
             direct_code_references,
             direct_no_return_calls,
             halted_disassembly_addresses,
+            inlined_unresolved_indirect_branches,
         }
     }
 
@@ -2059,6 +2068,10 @@ impl BasicBlockAnalysisContext {
         self.halted_disassembly_addresses.insert(loc);
     }
 
+    pub fn add_inlined_unresolved_indirect_branch(&mut self, loc: ArchAndAddr) {
+        self.inlined_unresolved_indirect_branches.insert(loc);
+    }
+
     pub fn create_basic_block(
         &self,
         arch: CoreArchitecture,
@@ -2135,6 +2148,21 @@ impl BasicBlockAnalysisContext {
             }
         }
 
+        if !self.inlined_unresolved_indirect_branches.is_empty() {
+            let total = self.inlined_unresolved_indirect_branches.len();
+            let mut locations: Vec<BNArchitectureAndAddress> = Vec::with_capacity(total);
+            for loc in &self.inlined_unresolved_indirect_branches {
+                locations.push(loc.into_raw());
+            }
+            unsafe {
+                BNAnalyzeBasicBlocksContextSetInlinedUnresolvedIndirectBranches(
+                    self.handle,
+                    locations.as_mut_ptr(),
+                    total,
+                );
+            }
+        }
+
         if self.contextual_returns_dirty {
             let total = self.contextual_returns.len();
             let mut locations: Vec<BNArchitectureAndAddress> = Vec::with_capacity(total);