update idb_import idb-rs to 0.1.13

rbran · rbran · commit 432da6c526c9 · 2025-09-08T11:28:42.000Z
diff --git a/plugins/idb_import/src/addr_info.rs b/plugins/idb_import/src/addr_info.rs
@@ -1,50 +1,54 @@
-use std::borrow::Cow;
 use std::collections::HashMap;
 
 use anyhow::Result;
 
 use idb_rs::addr_info::all_address_info;
-use idb_rs::id0::{ID0Section, Netdelta};
+use idb_rs::id0::{ID0Section, RootInfo};
 use idb_rs::id1::ID1Section;
 use idb_rs::id2::ID2Section;
-use idb_rs::{til, Address, IDAKind};
+use idb_rs::{til, Address, IDAKind, IDBString};
 
 #[derive(Default)]
-pub struct AddrInfo<'a> {
+pub struct AddrInfo {
     // TODO does binja differentiate comments types on the API?
-    pub comments: Vec<Vec<u8>>,
-    pub label: Option<Cow<'a, [u8]>>,
+    pub comments: Vec<IDBString>,
+    pub label: Option<IDBString>,
     // TODO make this a ref
     pub ty: Option<til::Type>,
 }
 
-pub fn get_info<'a, K: IDAKind>(
-    id0: &'a ID0Section<K>,
-    id1: &ID1Section,
+pub fn get_info<K: IDAKind>(
+    id0: &ID0Section<K>,
+    id1: &ID1Section<K>,
     id2: Option<&ID2Section<K>>,
-    netdelta: Netdelta<K>,
-) -> Result<HashMap<Address<K>, AddrInfo<'a>>> {
+    root_info: &RootInfo<K>,
+) -> Result<HashMap<Address<K>, AddrInfo>> {
     let mut addr_info: HashMap<Address<K>, AddrInfo> = HashMap::new();
 
     // comments defined on the address information
+    let netdelta = root_info.netdelta();
     for (info, _info_size) in all_address_info(id0, id1, id2, netdelta) {
         let entry = addr_info.entry(info.address()).or_default();
         if let Some(comment) = info.comment() {
-            entry.comments.push(comment.to_vec());
+            entry.comments.push(comment.to_idb_string());
         }
         if let Some(comment) = info.comment_repeatable() {
-            entry.comments.push(comment.to_vec());
+            entry.comments.push(comment.to_idb_string());
         }
         if let Some(comment) = info.comment_pre() {
-            entry.comments.extend(comment.map(|line| line.to_vec()));
+            entry
+                .comments
+                .extend(comment.map(|line| line.to_idb_string()));
         }
         if let Some(comment) = info.comment_post() {
-            entry.comments.extend(comment.map(|line| line.to_vec()));
+            entry
+                .comments
+                .extend(comment.map(|line| line.to_idb_string()));
         }
         if let Some(label) = info.label()? {
             entry.label = Some(label);
         }
-        if let Some(ty) = info.tinfo()? {
+        if let Some(ty) = info.tinfo(root_info)? {
             entry.ty = Some(ty);
         }
     }
diff --git a/plugins/idb_import/src/lib.rs b/plugins/idb_import/src/lib.rs
@@ -3,8 +3,8 @@ use std::borrow::Cow;
 use std::io::{BufRead, Cursor, Seek};
 
 use idb_rs::id1::ID1Section;
-use idb_rs::id2::{ID2Section, ID2SectionVariants};
-use idb_rs::{IDAKind, IDAUsize, IDBFormat};
+use idb_rs::id2::ID2Section;
+use idb_rs::{IDAKind, IDAUsize, IDAVariants, IDBFormat, IDBString};
 use types::*;
 mod addr_info;
 use addr_info::*;
@@ -14,7 +14,7 @@ use binaryninja::debuginfo::{
     CustomDebugInfoParser, DebugFunctionInfo, DebugInfo, DebugInfoParser,
 };
 
-use idb_rs::id0::{ID0Section, ID0SectionVariants};
+use idb_rs::id0::ID0Section;
 use idb_rs::til::section::TILSection;
 use idb_rs::til::TypeVariant as TILTypeVariant;
 
@@ -135,8 +135,11 @@ fn parse_idb_info(
     let mut file = std::io::BufReader::new(file);
     let idb_kind = idb_rs::identify_idb_file(&mut file)?;
     match idb_kind {
-        idb_rs::IDBFormats::Separated(sep) => {
-            parse_idb_info_format(debug_info, bv, debug_file, sep, file, progress)
+        idb_rs::IDBFormats::Separated(IDAVariants::IDA32(sep32)) => {
+            parse_idb_info_format(debug_info, bv, debug_file, sep32, file, progress)
+        }
+        idb_rs::IDBFormats::Separated(IDAVariants::IDA64(sep64)) => {
+            parse_idb_info_format(debug_info, bv, debug_file, sep64, file, progress)
         }
         idb_rs::IDBFormats::InlineUncompressed(inline) => {
             parse_idb_info_format(debug_info, bv, debug_file, inline, file, progress)
@@ -156,11 +159,11 @@ fn parse_idb_info(
     }
 }
 
-fn parse_idb_info_format(
+fn parse_idb_info_format<K: IDAKind>(
     debug_info: &mut DebugInfo,
     bv: &BinaryView,
     debug_file: &BinaryView,
-    format: impl IDBFormat,
+    format: impl IDBFormat<K>,
     mut idb_data: impl BufRead + Seek,
     progress: Box<dyn Fn(usize, usize) -> Result<(), ()>>,
 ) -> Result<()> {
@@ -185,21 +188,7 @@ fn parse_idb_info_format(
         .map(|id2_idx| format.read_id2(&mut idb_data, id2_idx))
         .transpose()?;
 
-    match (id0, id2) {
-        (ID0SectionVariants::IDA32(id0), Some(ID2SectionVariants::IDA32(id2))) => {
-            parse_id0_section_info(debug_info, bv, debug_file, &id0, &id1, Some(&id2))?
-        }
-        (ID0SectionVariants::IDA32(id0), None) => {
-            parse_id0_section_info(debug_info, bv, debug_file, &id0, &id1, None)?
-        }
-        (ID0SectionVariants::IDA64(id0), Some(ID2SectionVariants::IDA64(id2))) => {
-            parse_id0_section_info(debug_info, bv, debug_file, &id0, &id1, Some(&id2))?
-        }
-        (ID0SectionVariants::IDA64(id0), None) => {
-            parse_id0_section_info(debug_info, bv, debug_file, &id0, &id1, None)?
-        }
-        _ => unreachable!(),
-    }
+    parse_id0_section_info(debug_info, bv, debug_file, &id0, &id1, id2.as_ref())?;
 
     Ok(())
 }
@@ -291,19 +280,18 @@ fn parse_id0_section_info<K: IDAKind>(
     bv: &BinaryView,
     debug_file: &BinaryView,
     id0: &ID0Section<K>,
-    id1: &ID1Section,
+    id1: &ID1Section<K>,
     id2: Option<&ID2Section<K>>,
 ) -> Result<()> {
     let ida_info_idx = id0.root_node()?;
     let ida_info = id0.ida_info(ida_info_idx)?;
     let idb_baseaddr = ida_info.addresses.loading_base.into_u64();
     let bv_baseaddr = bv.start();
-    let netdelta = ida_info.netdelta();
     // just addr this value to the address to translate from ida to bn
     // NOTE this delta could wrap here and while using translating
     let addr_delta = bv_baseaddr.wrapping_sub(idb_baseaddr);
 
-    for (idb_addr, info) in get_info(id0, id1, id2, netdelta)? {
+    for (idb_addr, info) in get_info(id0, id1, id2, &ida_info)? {
         let addr = addr_delta.wrapping_add(idb_addr.into_raw().into_u64());
         // just in case we change this struct in the future, this line will for us to review this code
         // TODO merge this data with folder locations
@@ -314,30 +302,35 @@ fn parse_id0_section_info<K: IDAKind>(
         } = info;
         // TODO set comments to address here
         for function in &bv.functions_containing(addr) {
-            function.set_comment_at(addr, &String::from_utf8_lossy(&comments.join(&b"\n"[..])));
+            let comments: Vec<String> = comments
+                .iter()
+                .map(idb_rs::IDBString::as_utf8_lossy)
+                .map(Cow::into_owned)
+                .collect();
+            function.set_comment_at(addr, &comments.join("\n"));
         }
 
-        let bnty = ty
-            .as_ref()
-            .and_then(|ty| match translate_ephemeral_type(debug_file, ty) {
-                TranslateTypeResult::Translated(result) => Some(result),
-                TranslateTypeResult::PartiallyTranslated(result, None) => {
-                    warn!("Unable to fully translate the type at {addr:#x}");
-                    Some(result)
-                }
-                TranslateTypeResult::NotYet => {
-                    error!("Unable to translate the type at {addr:#x}");
-                    None
-                }
-                TranslateTypeResult::PartiallyTranslated(_, Some(bn_type_error))
-                | TranslateTypeResult::Error(bn_type_error) => {
-                    error!("Unable to translate the type at {addr:#x}: {bn_type_error}",);
-                    None
-                }
-            });
+        let bnty =
+            ty.as_ref().and_then(
+                |ty| match translate_ephemeral_type(debug_file, &ida_info, ty) {
+                    TranslateTypeResult::Translated(result) => Some(result),
+                    TranslateTypeResult::PartiallyTranslated(result, None) => {
+                        warn!("Unable to fully translate the type at {addr:#x}");
+                        Some(result)
+                    }
+                    TranslateTypeResult::NotYet => {
+                        error!("Unable to translate the type at {addr:#x}");
+                        None
+                    }
+                    TranslateTypeResult::PartiallyTranslated(_, Some(bn_type_error))
+                    | TranslateTypeResult::Error(bn_type_error) => {
+                        error!("Unable to translate the type at {addr:#x}: {bn_type_error}",);
+                        None
+                    }
+                },
+            );
 
-        let label: Option<Cow<'_, str>> =
-            label.as_ref().map(Cow::as_ref).map(String::from_utf8_lossy);
+        let label: Option<Cow<'_, str>> = label.as_ref().map(IDBString::as_utf8_lossy);
         match (label, &ty, bnty) {
             (label, Some(ty), bnty) if matches!(&ty.type_variant, TILTypeVariant::Function(_)) => {
                 if bnty.is_none() {
diff --git a/plugins/idb_import/src/types.rs b/plugins/idb_import/src/types.rs
@@ -11,16 +11,16 @@ use binaryninja::types::{
     EnumerationBuilder, FunctionParameter, MemberAccess, MemberScope, StructureBuilder,
     StructureType, Type,
 };
+use idb_rs::id0::RootInfo;
 use idb_rs::til::function::CallingConvention as TILCallingConvention;
 use idb_rs::til::pointer::Pointer as TILPointer;
 use idb_rs::til::r#enum::EnumMembers;
 use idb_rs::til::{
     array::Array as TILArray, function::Function as TILFunction, r#enum::Enum as TILEnum,
-    r#struct::Struct as TILStruct, r#struct::StructMember as TILStructMember,
-    r#union::Union as TILUnion, section::TILSection, TILTypeInfo, Type as TILType,
-    TypeVariant as TILTypeVariant,
+    section::TILSection, udt::UDTMember as TILUDTMember, udt::UDT as TILUDT, TILTypeInfo,
+    Type as TILType, TypeVariant as TILTypeVariant,
 };
-use idb_rs::IDBString;
+use idb_rs::{IDAKind, IDBString};
 
 #[derive(Debug, Clone)]
 pub enum BnTypeError {
@@ -306,7 +306,7 @@ impl<F: Fn(usize, usize) -> Result<(), ()>> TranslateIDBTypes<'_, F> {
     fn condensate_bitfields_from_struct(
         &self,
         offset: usize,
-        members_slice: &[TILStructMember],
+        members_slice: &[TILUDTMember],
         struct_builder: &mut StructureBuilder,
     ) {
         if members_slice.is_empty() {
@@ -326,7 +326,7 @@ impl<F: Fn(usize, usize) -> Result<(), ()>> TranslateIDBTypes<'_, F> {
 
         let mut create_field = |start_idx, i, bytes| {
             let name = if start_idx == i - 1 {
-                let member: &TILStructMember = &members_slice[i - 1];
+                let member: &TILUDTMember = &members_slice[i - 1];
                 member
                     .name
                     .as_ref()
@@ -366,7 +366,7 @@ impl<F: Fn(usize, usize) -> Result<(), ()>> TranslateIDBTypes<'_, F> {
         }
     }
 
-    fn translate_struct(&self, ty_struct: &TILStruct) -> TranslateTypeResult {
+    fn translate_struct(&self, ty_struct: &TILUDT) -> TranslateTypeResult {
         if ty_struct.members.is_empty() {
             // binary ninja crashes if you create an empty struct, because it divide by 0
             return TranslateTypeResult::Translated(Type::void());
@@ -376,7 +376,7 @@ impl<F: Fn(usize, usize) -> Result<(), ()>> TranslateIDBTypes<'_, F> {
         if let Some(align) = ty_struct.alignment {
             structure.alignment(align.get().into());
         }
-        structure.packed(ty_struct.is_unaligned && ty_struct.is_uknown_8);
+        structure.packed(ty_struct.is_unaligned && ty_struct.is_unknown_8);
 
         let mut errors = vec![];
         let mut first_bitfield_seq = None;
@@ -440,16 +440,16 @@ impl<F: Fn(usize, usize) -> Result<(), ()>> TranslateIDBTypes<'_, F> {
         }
     }
 
-    fn translate_union(&self, ty_union: &TILUnion) -> TranslateTypeResult {
+    fn translate_union(&self, ty_union: &TILUDT) -> TranslateTypeResult {
         let mut is_partial = false;
         let mut structure = StructureBuilder::new();
         structure.structure_type(StructureType::UnionStructureType);
         let mut errors = vec![];
         for (i, member) in ty_union.members.iter().enumerate() {
             // bitfields can be translated into complete fields
-            let mem = match &member.ty.type_variant {
+            let mem = match &member.member_type.type_variant {
                 TILTypeVariant::Bitfield(field) => field_from_bytes(field.nbytes.get().into()),
-                _ => match self.translate_type(&member.ty) {
+                _ => match self.translate_type(&member.member_type) {
                     TranslateTypeResult::Translated(ty) => ty,
                     TranslateTypeResult::Error(error) => {
                         errors.push((i, error));
@@ -580,21 +580,28 @@ impl<F: Fn(usize, usize) -> Result<(), ()>> TranslateIDBTypes<'_, F> {
             TILTypeVariant::Enum(ty_enum) => {
                 TranslateTypeResult::Translated(self.translate_enum(ty_enum))
             }
-            TILTypeVariant::Typeref(typeref) => match &typeref.typeref_value {
-                idb_rs::til::TyperefValue::Ref(idx) => self.find_typedef(&self.types[*idx]),
-                idb_rs::til::TyperefValue::UnsolvedName(name) => self
-                    .find_typedef_by_name(name.as_ref().map(|x| x.as_bytes()).unwrap_or(&[]))
-                    .unwrap_or_else(|| {
-                        TranslateTypeResult::Error(BnTypeError::NameNotFound(
+            TILTypeVariant::Typeref(typeref) => {
+                match self.til.get_ref_value_idx(&typeref.typeref_value) {
+                    Some(idx) => self.find_typedef(&self.types[idx]),
+                    None => match &typeref.typeref_value {
+                        idb_rs::til::TyperefValue::Name(name) => {
+                            // search the default non-defined names
                             name.as_ref()
-                                .map(|x| x.as_utf8_lossy().to_string())
-                                .unwrap_or(String::new()),
-                        ))
-                    }),
-                idb_rs::til::TyperefValue::UnsolvedOrd(ord) => {
-                    TranslateTypeResult::Error(BnTypeError::OrdinalNotFound(*ord))
+                                .and_then(|name| self.find_typedef_by_name(name.as_bytes()))
+                                .unwrap_or_else(|| {
+                                    TranslateTypeResult::Error(BnTypeError::NameNotFound(
+                                        name.as_ref()
+                                            .map(|x| x.as_utf8_lossy().to_string())
+                                            .unwrap_or(String::new()),
+                                    ))
+                                })
+                        }
+                        idb_rs::til::TyperefValue::Ordinal(ord) => {
+                            TranslateTypeResult::Error(BnTypeError::OrdinalNotFound(*ord))
+                        }
+                    },
                 }
-            },
+            }
 
             TILTypeVariant::Pointer(ty) => self.translate_pointer(ty),
             TILTypeVariant::Function(fun) => self.translate_function(fun),
@@ -607,10 +614,15 @@ impl<F: Fn(usize, usize) -> Result<(), ()>> TranslateIDBTypes<'_, F> {
     }
 }
 
-pub fn translate_ephemeral_type(debug_file: &BinaryView, ty: &TILType) -> TranslateTypeResult {
+pub fn translate_ephemeral_type<K: IDAKind>(
+    debug_file: &BinaryView,
+    root_info: &RootInfo<K>,
+    ty: &TILType,
+) -> TranslateTypeResult {
     // in case we need to translate types
-    let header = idb_rs::til::ephemeral_til_header();
+    let header = root_info.til_header();
     let translator = TranslateIDBTypes {
+        // TODO find the correct processor using the segment registers
         arch: debug_file.default_arch().unwrap(/* TODO */),
         progress: |_, _| Ok(()),
         // TODO it's unclear what to do here
@@ -630,7 +642,7 @@ pub fn translate_til_types(
     arch: CoreArchitecture,
     til: &TILSection,
     progress: impl Fn(usize, usize) -> Result<(), ()>,
-) -> Result<Vec<TranslatesIDBType>> {
+) -> Result<Vec<TranslatesIDBType<'_>>> {
     let total = til.symbols.len() + til.types.len();
     let mut types = Vec::with_capacity(total);
     let mut types_by_ord = HashMap::with_capacity(total);
