[idb_import] Split enum-operand and number-format settings

Enum-displayed operands are a small, cheap set, while the per-operand number
formats can number in the hundreds of thousands and dominate import time on
large databases. Gate them independently:

- analysis.idb.applyOperandEnums controls enum displays.
- analysis.idb.applyOperandFormats controls number formats.

Add analysis.idb.skipDefaultOperandFormats (default true): when applying
number formats, skip operands whose format already matches Binary Ninja's
default rendering (hexadecimal). These make up the bulk of formatted operands
and applying them would not change the displayed text, so skipping them
greatly reduces the disassembly work without affecting the result.

Author: ChrisKader

plugins/idb_import/src/lib.rs

@@ -64,7 +64,9 @@ fn plugin_init() -> Result<(), ()> {
         match file_parser.parse(&mut file_reader) {
             Ok(idb_info) => {
                 IDBMapper::new(idb_info)
+                    .with_operand_enums(load_settings.apply_operand_enums)
                     .with_operand_formats(load_settings.apply_operand_formats)
+                    .with_skip_default_operand_formats(load_settings.skip_default_operand_formats)
                     .map_to_view(&view);
             }
             Err(e) => {

plugins/idb_import/src/mapper.rs

@@ -207,23 +207,40 @@ fn apply_operand_format_display(view: &BinaryView, operand_format: &OperandForma
 /// The mapper can be re-used if mapping into multiple views.
 pub struct IDBMapper {
     info: IDBInfo,
+    apply_operand_enums: bool,
     apply_operand_formats: bool,
+    skip_default_operand_formats: bool,
 }
 
 impl IDBMapper {
     pub fn new(info: IDBInfo) -> Self {
         Self {
             info,
+            apply_operand_enums: false,
             apply_operand_formats: false,
+            skip_default_operand_formats: true,
         }
     }
 
+    /// Enable displaying operands against the enumeration IDA assigned them.
+    pub fn with_operand_enums(mut self, enabled: bool) -> Self {
+        self.apply_operand_enums = enabled;
+        self
+    }
+
     /// Enable applying the IDB's per-operand number formats to the disassembly.
     pub fn with_operand_formats(mut self, enabled: bool) -> Self {
         self.apply_operand_formats = enabled;
         self
     }
 
+    /// Skip per-operand number formats that already match Binary Ninja's default rendering
+    /// (hexadecimal) when applying number formats.
+    pub fn with_skip_default_operand_formats(mut self, enabled: bool) -> Self {
+        self.skip_default_operand_formats = enabled;
+        self
+    }
+
     pub fn map_to_view(&self, view: &BinaryView) {
         let Some(id0) = &self.info.id0 else {
             tracing::warn!("No ID0 data found, skipping mapping.");
@@ -397,36 +414,57 @@ impl IDBMapper {
 
         // Per-operand number formats and enum displays need the containing function to exist, but
         // this import runs before functions are created. Rebase and stash them; the
-        // analysis-completion handler in `lib.rs` applies them once functions are available. Gated
-        // because applying them disassembles each affected instruction.
-        if self.apply_operand_formats
-            && (!self.info.operand_formats.is_empty() || !self.info.operand_enums.is_empty())
-        {
-            tracing::info!(
-                "Deferring {} operand formats and {} enum-displayed operands until analysis completes",
-                self.info.operand_formats.len(),
-                self.info.operand_enums.len()
-            );
-            let operand_formats = self
-                .info
-                .operand_formats
-                .iter()
-                .map(|operand_format| {
-                    let mut rebased = operand_format.clone();
-                    rebased.address = rebase(operand_format.address);
-                    rebased
-                })
-                .collect();
-            let operand_enums = self
-                .info
+        // analysis-completion handler in `lib.rs` applies them once functions are available. Each
+        // kind is gated by its own setting because applying them disassembles each instruction.
+        let operand_enums: Vec<OperandEnumInfo> = if self.apply_operand_enums {
+            self.info
                 .operand_enums
                 .iter()
                 .map(|operand_enum| {
                     let mut rebased = operand_enum.clone();
                     rebased.address = rebase(operand_enum.address);
                     rebased
                 })
-                .collect();
+                .collect()
+        } else {
+            Vec::new()
+        };
+        let operand_formats: Vec<OperandFormatInfo> = if self.apply_operand_formats {
+            self.info
+                .operand_formats
+                .iter()
+                .filter_map(|operand_format| {
+                    // When skipping defaults, drop formats that match Binary Ninja's default
+                    // rendering (hexadecimal); they make up the bulk on large databases and
+                    // changing them would not alter the displayed text.
+                    let formats: Vec<_> = operand_format
+                        .formats
+                        .iter()
+                        .filter(|(_, format)| {
+                            !(self.skip_default_operand_formats
+                                && operand_format_matches_default(*format))
+                        })
+                        .cloned()
+                        .collect();
+                    if formats.is_empty() {
+                        return None;
+                    }
+                    Some(OperandFormatInfo {
+                        address: rebase(operand_format.address),
+                        formats,
+                    })
+                })
+                .collect()
+        } else {
+            Vec::new()
+        };
+
+        if !operand_enums.is_empty() || !operand_formats.is_empty() {
+            tracing::info!(
+                "Deferring {} enum-displayed operands and {} operand number formats until analysis completes",
+                operand_enums.len(),
+                operand_formats.len()
+            );
             stash_operand_display(
                 view,
                 PendingOperandDisplay {
@@ -1041,6 +1079,13 @@ fn integer_token_value(kind: &InstructionTextTokenKind) -> Option<u64> {
     }
 }
 
+/// Whether a number format already matches Binary Ninja's default integer rendering
+/// (hexadecimal). Applying such a format as an override would not change the displayed text, so it
+/// can be skipped to avoid disassembling the bulk of formatted operands on large databases.
+fn operand_format_matches_default(format: OperandFormat) -> bool {
+    matches!(format, OperandFormat::Hex)
+}
+
 /// Map an IDA operand number format to the Binary Ninja integer display type.
 fn integer_display_type(format: OperandFormat) -> IntegerDisplayType {
     match format {

plugins/idb_import/src/settings.rs

@@ -6,13 +6,18 @@ use std::path::PathBuf;
 #[derive(Debug, Clone)]
 pub struct LoadSettings {
     pub auto_load_file: Option<PathBuf>,
+    pub apply_operand_enums: bool,
     pub apply_operand_formats: bool,
+    pub skip_default_operand_formats: bool,
 }
 
 impl LoadSettings {
     pub const AUTO_LOAD_FILE_DEFAULT: &'static str = "";
     pub const AUTO_LOAD_FILE_SETTING: &'static str = "analysis.idb.autoLoadFile";
+    pub const APPLY_OPERAND_ENUMS_SETTING: &'static str = "analysis.idb.applyOperandEnums";
     pub const APPLY_OPERAND_FORMATS_SETTING: &'static str = "analysis.idb.applyOperandFormats";
+    pub const SKIP_DEFAULT_OPERAND_FORMATS_SETTING: &'static str =
+        "analysis.idb.skipDefaultOperandFormats";
 
     pub fn register() {
         let bn_settings = Settings::new();
@@ -26,8 +31,21 @@ impl LoadSettings {
         });
         bn_settings.register_setting_json(Self::AUTO_LOAD_FILE_SETTING, &file_props.to_string());
 
+        let operand_enums_props = json!({
+            "title" : "Apply IDB Enum Operands",
+            "type" : "boolean",
+            "default" : false,
+            "description" : "Display operands against the enumeration IDA assigned them. This is \
+                applied once analysis has created the functions and only affects the handful of \
+                operands IDA displays as enumeration members, so it is inexpensive."
+        });
+        bn_settings.register_setting_json(
+            Self::APPLY_OPERAND_ENUMS_SETTING,
+            &operand_enums_props.to_string(),
+        );
+
         let operand_formats_props = json!({
-            "title" : "Apply IDB Operand Formats",
+            "title" : "Apply IDB Operand Number Formats",
             "type" : "boolean",
             "default" : false,
             "description" : "Apply the per-operand number formats (hexadecimal, decimal, \
@@ -39,6 +57,20 @@ impl LoadSettings {
             Self::APPLY_OPERAND_FORMATS_SETTING,
             &operand_formats_props.to_string(),
         );
+
+        let skip_default_formats_props = json!({
+            "title" : "Skip Default IDB Operand Number Formats",
+            "type" : "boolean",
+            "default" : true,
+            "description" : "When applying IDB operand number formats, skip operands whose format \
+                already matches Binary Ninja's default rendering (hexadecimal). On large databases \
+                most formatted operands are plain hexadecimal, so skipping them greatly reduces \
+                the work without changing the displayed result."
+        });
+        bn_settings.register_setting_json(
+            Self::SKIP_DEFAULT_OPERAND_FORMATS_SETTING,
+            &skip_default_formats_props.to_string(),
+        );
     }
 
     pub fn from_view_settings(view: &BinaryView) -> Self {
@@ -53,10 +85,18 @@ impl LoadSettings {
                 load_settings.auto_load_file = Some(path);
             }
         }
+        if settings.contains(Self::APPLY_OPERAND_ENUMS_SETTING) {
+            load_settings.apply_operand_enums =
+                settings.get_bool_with_opts(Self::APPLY_OPERAND_ENUMS_SETTING, &mut query_opts);
+        }
         if settings.contains(Self::APPLY_OPERAND_FORMATS_SETTING) {
             load_settings.apply_operand_formats =
                 settings.get_bool_with_opts(Self::APPLY_OPERAND_FORMATS_SETTING, &mut query_opts);
         }
+        if settings.contains(Self::SKIP_DEFAULT_OPERAND_FORMATS_SETTING) {
+            load_settings.skip_default_operand_formats = settings
+                .get_bool_with_opts(Self::SKIP_DEFAULT_OPERAND_FORMATS_SETTING, &mut query_opts);
+        }
         load_settings
     }
 }
@@ -65,7 +105,9 @@ impl Default for LoadSettings {
     fn default() -> Self {
         Self {
             auto_load_file: None,
+            apply_operand_enums: false,
             apply_operand_formats: false,
+            skip_default_operand_formats: true,
         }
     }
 }