fmt

Author: mkrasnitski

rust/examples/dwarf/dwarf_import/src/die_handlers.rs

@@ -169,7 +169,10 @@ pub(crate) fn handle_pointer<R: Reader<Offset = usize>>(
 
     if let Some(pointer_size) = get_size_as_usize(entry) {
         if let Some(entry_type_offset) = entry_type {
-            let parent_type = debug_info_builder.get_type(entry_type_offset).unwrap().get_type();
+            let parent_type = debug_info_builder
+                .get_type(entry_type_offset)
+                .unwrap()
+                .get_type();
             Some(Type::pointer_of_width(
                 parent_type.as_ref(),
                 pointer_size,
@@ -187,7 +190,10 @@ pub(crate) fn handle_pointer<R: Reader<Offset = usize>>(
             ))
         }
     } else if let Some(entry_type_offset) = entry_type {
-        let parent_type = debug_info_builder.get_type(entry_type_offset).unwrap().get_type();
+        let parent_type = debug_info_builder
+            .get_type(entry_type_offset)
+            .unwrap()
+            .get_type();
         Some(Type::pointer_of_width(
             parent_type.as_ref(),
             debug_info_builder_context.default_address_size(),
@@ -225,7 +231,10 @@ pub(crate) fn handle_array<R: Reader<Offset = usize>>(
     //   For multidimensional arrays, DW_TAG_subrange_type or DW_TAG_enumeration_type
 
     if let Some(entry_type_offset) = entry_type {
-        let parent_type = debug_info_builder.get_type(entry_type_offset).unwrap().get_type();
+        let parent_type = debug_info_builder
+            .get_type(entry_type_offset)
+            .unwrap()
+            .get_type();
 
         let mut tree = unit.entries_tree(Some(entry.offset())).unwrap();
         let mut children = tree.root().unwrap().children();
@@ -282,12 +291,10 @@ pub(crate) fn handle_function<R: Reader<Offset = usize>>(
     // or is otherwise DW_TAG_unspecified_parameters
 
     let return_type = match entry_type {
-        Some(entry_type_offset) => {
-            debug_info_builder
-                .get_type(entry_type_offset)
-                .expect("Subroutine return type was not processed")
-                .get_type()
-        }
+        Some(entry_type_offset) => debug_info_builder
+            .get_type(entry_type_offset)
+            .expect("Subroutine return type was not processed")
+            .get_type(),
         None => Type::void(),
     };
 
@@ -355,7 +362,10 @@ pub(crate) fn handle_const(
     //   ?DW_AT_type
 
     if let Some(entry_type_offset) = entry_type {
-        let parent_type = debug_info_builder.get_type(entry_type_offset).unwrap().get_type();
+        let parent_type = debug_info_builder
+            .get_type(entry_type_offset)
+            .unwrap()
+            .get_type();
         Some((*parent_type).to_builder().set_const(true).finalize())
     } else {
         Some(TypeBuilder::void().set_const(true).finalize())
@@ -375,7 +385,10 @@ pub(crate) fn handle_volatile(
     //   ?DW_AT_type
 
     if let Some(entry_type_offset) = entry_type {
-        let parent_type = debug_info_builder.get_type(entry_type_offset).unwrap().get_type();
+        let parent_type = debug_info_builder
+            .get_type(entry_type_offset)
+            .unwrap()
+            .get_type();
         Some((*parent_type).to_builder().set_volatile(true).finalize())
     } else {
         Some(TypeBuilder::void().set_volatile(true).finalize())

rust/examples/dwarf/dwarf_import/src/dwarfdebuginfo.rs

@@ -15,14 +15,14 @@
 use crate::helpers::{get_uid, resolve_specification, DieReference};
 
 use binaryninja::{
+    binaryninjacore_sys::BNVariableSourceType,
     binaryview::{BinaryView, BinaryViewBase, BinaryViewExt},
     debuginfo::{DebugFunctionInfo, DebugInfo},
     platform::Platform,
     rc::*,
     symbol::SymbolType,
     templatesimplifier::simplify_str_to_fqn,
     types::{Conf, FunctionParameter, NamedTypedVariable, Type, Variable},
-    binaryninjacore_sys::BNVariableSourceType,
 };
 
 use gimli::{DebuggingInformationEntry, Dwarf, Reader, Unit};
@@ -184,7 +184,7 @@ pub(crate) struct DebugInfoBuilder {
     full_function_name_indices: HashMap<String, usize>,
     types: HashMap<TypeUID, DebugType>,
     data_variables: HashMap<u64, (Option<String>, TypeUID)>,
-    range_data_offsets: iset::IntervalMap<u64, i64>
+    range_data_offsets: iset::IntervalMap<u64, i64>,
 }
 
 impl DebugInfoBuilder {
@@ -218,10 +218,10 @@ impl DebugInfoBuilder {
         // TODO : Consider further falling back on address/architecture
 
         /*
-            If it has a raw_name and we know it, update it and return
-            Else if it has a full_name and we know it, update it and return
-            Else Add a new entry if we don't know the full_name or raw_name
-         */
+           If it has a raw_name and we know it, update it and return
+           Else if it has a full_name and we know it, update it and return
+           Else Add a new entry if we don't know the full_name or raw_name
+        */
 
         if let Some(ident) = &raw_name {
             // check if we already know about this raw name's index
@@ -232,20 +232,20 @@ impl DebugInfoBuilder {
                 let function = self.functions.get_mut(*idx).unwrap();
 
                 if function.full_name.is_some() && function.full_name != full_name {
-                    self.full_function_name_indices.remove(function.full_name.as_ref().unwrap());
+                    self.full_function_name_indices
+                        .remove(function.full_name.as_ref().unwrap());
                 }
 
                 function.update(full_name, raw_name, return_type, address, parameters);
 
-                if function.full_name.is_some()  {
-                    self.full_function_name_indices.insert(function.full_name.clone().unwrap(), *idx);
+                if function.full_name.is_some() {
+                    self.full_function_name_indices
+                        .insert(function.full_name.clone().unwrap(), *idx);
                 }
 
                 return Some(*idx);
             }
-        }
-
-        else if let Some(ident) = &full_name {
+        } else if let Some(ident) = &full_name {
             // check if we already know about this full name's index
             // if we do, and the raw name will change, remove the known raw index if it exists
             // update the function
@@ -254,13 +254,15 @@ impl DebugInfoBuilder {
                 let function = self.functions.get_mut(*idx).unwrap();
 
                 if function.raw_name.is_some() && function.raw_name != raw_name {
-                    self.raw_function_name_indices.remove(function.raw_name.as_ref().unwrap());
+                    self.raw_function_name_indices
+                        .remove(function.raw_name.as_ref().unwrap());
                 }
 
                 function.update(full_name, raw_name, return_type, address, parameters);
 
-                if function.raw_name.is_some()  {
-                    self.raw_function_name_indices.insert(function.raw_name.clone().unwrap(), *idx);
+                if function.raw_name.is_some() {
+                    self.raw_function_name_indices
+                        .insert(function.raw_name.clone().unwrap(), *idx);
                 }
 
                 return Some(*idx);
@@ -284,15 +286,17 @@ impl DebugInfoBuilder {
         };
 
         if let Some(n) = &function.full_name {
-            self.full_function_name_indices.insert(n.clone(), self.functions.len());
+            self.full_function_name_indices
+                .insert(n.clone(), self.functions.len());
         }
 
         if let Some(n) = &function.raw_name {
-            self.raw_function_name_indices.insert(n.clone(), self.functions.len());
+            self.raw_function_name_indices
+                .insert(n.clone(), self.functions.len());
         }
 
         self.functions.push(function);
-        Some(self.functions.len()-1)
+        Some(self.functions.len() - 1)
     }
 
     pub(crate) fn functions(&self) -> &[FunctionInfoBuilder] {
@@ -303,7 +307,13 @@ impl DebugInfoBuilder {
         self.types.values()
     }
 
-    pub(crate) fn add_type(&mut self, type_uid: TypeUID, name: &String, t: Ref<Type>, commit: bool) {
+    pub(crate) fn add_type(
+        &mut self,
+        type_uid: TypeUID,
+        name: &String,
+        t: Ref<Type>,
+        commit: bool,
+    ) {
         if let Some(DebugType {
             name: existing_name,
             t: existing_type,
@@ -339,7 +349,6 @@ impl DebugInfoBuilder {
         self.types.contains_key(&type_uid)
     }
 
-
     pub(crate) fn add_stack_variable(
         &mut self,
         fn_idx: Option<usize>,
@@ -352,11 +361,10 @@ impl DebugInfoBuilder {
                 if x.len() == 1 && x.chars().next() == Some('\x00') {
                     // Anonymous variable, generate name
                     format!("debug_var_{}", offset)
-                }
-                else {
+                } else {
                     x
                 }
-            },
+            }
             None => {
                 // Anonymous variable, generate name
                 format!("debug_var_{}", offset)
@@ -365,14 +373,16 @@ impl DebugInfoBuilder {
 
         let Some(function_index) = fn_idx else {
             // If we somehow lost track of what subprogram we're in or we're not actually in a subprogram
-            error!("Trying to add a local variable outside of a subprogram. Please report this issue.");
+            error!(
+                "Trying to add a local variable outside of a subprogram. Please report this issue."
+            );
             return;
         };
 
         // Either get the known type or use a 0 confidence void type so we at least get the name applied
         let t = match type_uid {
             Some(uid) => Conf::new(self.get_type(uid).unwrap().get_type(), 128),
-            None => Conf::new(Type::void(), 0)
+            None => Conf::new(Type::void(), 0),
         };
         let function = &mut self.functions[function_index];
 
@@ -384,7 +394,8 @@ impl DebugInfoBuilder {
             return;
         };
 
-        let Some(offset_adjustment) = self.range_data_offsets.values_overlap(func_addr).next() else {
+        let Some(offset_adjustment) = self.range_data_offsets.values_overlap(func_addr).next()
+        else {
             // Unknown why, but this is happening with MachO + external dSYM
             debug!("Refusing to add a local variable ({}@{}) to function at {} without a known CIE offset.", name, offset, func_addr);
             return;
@@ -398,9 +409,14 @@ impl DebugInfoBuilder {
             return;
         }
 
-        let var = Variable::new(BNVariableSourceType::StackVariableSourceType, 0, adjusted_offset);
-        function.stack_variables.push(NamedTypedVariable::new(var, name, t, false));
-
+        let var = Variable::new(
+            BNVariableSourceType::StackVariableSourceType,
+            0,
+            adjusted_offset,
+        );
+        function
+            .stack_variables
+            .push(NamedTypedVariable::new(var, name, t, false));
     }
 
     pub(crate) fn add_data_variable(
@@ -448,7 +464,9 @@ impl DebugInfoBuilder {
 
     fn get_function_type(&self, function: &FunctionInfoBuilder) -> Ref<Type> {
         let return_type = match function.return_type {
-            Some(return_type_id) => Conf::new(self.get_type(return_type_id).unwrap().get_type(), 128),
+            Some(return_type_id) => {
+                Conf::new(self.get_type(return_type_id).unwrap().get_type(), 128)
+            }
             _ => Conf::new(binaryninja::types::Type::void(), 0),
         };
 
@@ -480,7 +498,7 @@ impl DebugInfoBuilder {
                 Some(self.get_function_type(function)),
                 function.address,
                 function.platform.clone(),
-                vec![], // TODO : Components
+                vec![],                           // TODO : Components
                 function.stack_variables.clone(), // TODO: local non-stack variables
             ));
         }
@@ -520,7 +538,7 @@ impl DebugInfoBuilder {
 
             if let Some(address) = func.address.as_mut() {
                 let diff = bv.start() - bv.original_base();
-                *address += diff;  // rebase the address
+                *address += diff; // rebase the address
                 let existing_functions = bv.functions_at(*address);
                 match existing_functions.len().cmp(&1) {
                     Ordering::Greater => {

rust/examples/dwarf/dwarf_import/src/functions.rs

@@ -80,7 +80,8 @@ pub(crate) fn parse_function_entry<R: Reader<Offset = usize>>(
     let raw_name = get_raw_name(unit, entry, debug_info_builder_context);
     let return_type = get_type(unit, entry, debug_info_builder_context, debug_info_builder);
     let address = get_start_address(unit, entry, debug_info_builder_context);
-    let (parameters, variable_arguments) = get_parameters(unit, entry, debug_info_builder_context, debug_info_builder);
+    let (parameters, variable_arguments) =
+        get_parameters(unit, entry, debug_info_builder_context, debug_info_builder);
 
     // If we have a raw name, it might be mangled, see if we can demangle it into full_name
     //  raw_name should contain a superset of the info we have in full_name
@@ -96,9 +97,7 @@ pub(crate) fn parse_function_entry<R: Reader<Offset = usize>>(
             });
 
             static ABI_REGEX_MEM: OnceLock<Regex> = OnceLock::new();
-            let abi_regex = ABI_REGEX_MEM.get_or_init(|| {
-                Regex::new(r"\[abi:v\d+\]").unwrap()
-            });
+            let abi_regex = ABI_REGEX_MEM.get_or_init(|| Regex::new(r"\[abi:v\d+\]").unwrap());
             if let Ok(sym) = cpp_demangle::Symbol::new(possibly_mangled_name) {
                 if let Ok(demangled) = sym.demangle(demangle_options) {
                     let cleaned = abi_regex.replace_all(&demangled, "");
@@ -114,5 +113,12 @@ pub(crate) fn parse_function_entry<R: Reader<Offset = usize>>(
         full_name = debug_info_builder_context.get_name(unit, entry)
     }
 
-    debug_info_builder.insert_function(full_name, raw_name, return_type, address, &parameters, variable_arguments)
+    debug_info_builder.insert_function(
+        full_name,
+        raw_name,
+        return_type,
+        address,
+        &parameters,
+        variable_arguments,
+    )
 }