Migrate Rust demangler bindings and consumers

Introduce Rust config/result types and custom-demangler callbacks for the new C contract, update examples and regression tests, migrate Rust-based plugins, remove the obsolete standalone simplifier wrapper, and fold the final rustfmt/clippy fixes into the migration.

Author: plafosse

plugins/dwarf/dwarf_import/src/dwarfdebuginfo.rs

@@ -21,10 +21,10 @@ use crate::{
 use binaryninja::{
     binary_view::{BinaryView, BinaryViewBase},
     debuginfo::{DebugFunctionInfo, DebugInfo},
+    demangle::simplify_demangled_template_name,
     platform::Platform,
     rc::*,
     symbol::SymbolType,
-    template_simplifier::simplify_str_to_fqn,
     types::{FunctionParameter, Type},
     variable::NamedVariableWithType,
 };
@@ -733,9 +733,8 @@ impl DebugInfoBuilder {
                         let symbol_full_name = symbol.full_name();
 
                         // If our name has fewer namespaces than the existing name, assume we lost the namespace info
-                        if simplify_str_to_fqn(func_full_name, true).items.len()
-                            < simplify_str_to_fqn(symbol_full_name.clone(), true)
-                                .items
+                        if simplify_demangled_template_name(func_full_name).len()
+                            < simplify_demangled_template_name(symbol_full_name.to_string_lossy())
                                 .len()
                         {
                             func.full_name = Some(symbol_full_name.to_string_lossy().to_string());

plugins/dwarf/dwarf_import/src/functions.rs

@@ -18,7 +18,6 @@ use crate::dwarfdebuginfo::{DebugInfoBuilder, DebugInfoBuilderContext, TypeUID};
 use crate::types::get_type;
 use crate::{helpers::*, ReaderType};
 
-use binaryninja::template_simplifier::simplify_str_to_str;
 use cpp_demangle::DemangleOptions;
 use gimli::{constants, AttributeValue, DebuggingInformationEntry, Dwarf, Operation, Unit};
 use regex::Regex;
@@ -134,8 +133,7 @@ pub(crate) fn parse_function_entry<R: ReaderType>(
             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, "");
-                    let simplified = simplify_str_to_str(&cleaned);
-                    full_name = Some(simplified.to_string_lossy().to_string());
+                    full_name = Some(cleaned.to_string());
                 }
             }
         }

plugins/dwarf/dwarf_import/src/lib.rs

@@ -33,7 +33,6 @@ use binaryninja::{
     binary_view::BinaryView,
     debuginfo::{CustomDebugInfoParser, DebugInfo, DebugInfoParser},
     settings::Settings,
-    template_simplifier::simplify_str_to_str,
 };
 use dwarfreader::create_section_reader_object;
 
@@ -247,15 +246,11 @@ fn recover_names_internal<R: ReaderType>(
                     }
                     debug_info_builder_context.set_name(
                         get_uid(dwarf, &unit, entry),
-                        simplify_str_to_str(
-                            namespace_qualifiers
-                                .iter()
-                                .map(|(_, namespace)| namespace.to_owned())
-                                .collect::<Vec<String>>()
-                                .join("::"),
-                        )
-                        .to_string_lossy()
-                        .to_string(),
+                        namespace_qualifiers
+                            .iter()
+                            .map(|(_, namespace)| namespace.to_owned())
+                            .collect::<Vec<String>>()
+                            .join("::"),
                     );
                 }
                 constants::DW_TAG_typedef
@@ -264,16 +259,12 @@ fn recover_names_internal<R: ReaderType>(
                     if let Some(name) = get_name(dwarf, &unit, entry, debug_info_builder_context) {
                         debug_info_builder_context.set_name(
                             get_uid(dwarf, &unit, entry),
-                            simplify_str_to_str(
-                                namespace_qualifiers
-                                    .iter()
-                                    .chain(vec![&(-1, name)].into_iter())
-                                    .map(|(_, namespace)| namespace.to_owned())
-                                    .collect::<Vec<String>>()
-                                    .join("::"),
-                            )
-                            .to_string_lossy()
-                            .to_string(),
+                            namespace_qualifiers
+                                .iter()
+                                .chain(vec![&(-1, name)].into_iter())
+                                .map(|(_, namespace)| namespace.to_owned())
+                                .collect::<Vec<String>>()
+                                .join("::"),
                         );
                     }
                 }

plugins/idb_import/src/mapper.rs

@@ -441,7 +441,7 @@ fn symbol_from_func(func: &FunctionInfo) -> Option<Ref<Symbol>> {
         return None;
     };
     let short_func_name = binaryninja::demangle::demangle_llvm(&func_name, true)
-        .map(|qn| qn.to_string())
+        .map(|result| result.name.to_string())
         .unwrap_or(func_name.clone());
     let sym_type = match func.is_library {
         true => SymbolType::LibraryFunction,

plugins/pdb-ng/src/symbol_parser.rs

@@ -39,7 +39,7 @@ use crate::PDBParserInstance;
 use binaryninja::architecture::{Architecture, ArchitectureExt, Register, RegisterId};
 use binaryninja::binary_view::BinaryViewBase;
 use binaryninja::confidence::{Conf, MAX_CONFIDENCE, MIN_CONFIDENCE};
-use binaryninja::demangle::demangle_ms_with_view;
+use binaryninja::demangle::demangle_ms;
 use binaryninja::rc::Ref;
 use binaryninja::types::{FunctionParameter, QualifiedName, StructureBuilder, Type, TypeClass};
 use binaryninja::variable::{Variable, VariableSourceType};
@@ -1813,9 +1813,15 @@ impl<'a, S: Source<'a> + 'a> PDBParserInstance<'a, S> {
         raw_name: &String,
         rva: Rva,
     ) -> Result<(Option<Conf<Ref<Type>>>, Option<QualifiedName>)> {
-        let (mut t, mut name) = match demangle_ms_with_view(&self.arch, raw_name, Some(self.bv)) {
-            Some((name, Some(t))) => (Some(Conf::new(t, DEMANGLE_CONFIDENCE)), name),
-            Some((name, _)) => (None, name),
+        let simplify_templates = self.settings.get_bool_with_opts(
+            "analysis.types.templateSimplifier",
+            &mut self.settings_query_opts.clone(),
+        );
+        let (mut t, mut name) = match demangle_ms(&self.arch, raw_name, simplify_templates) {
+            Some(result) => (
+                result.ty.map(|ty| Conf::new(ty, DEMANGLE_CONFIDENCE)),
+                result.name,
+            ),
             _ => (None, QualifiedName::new(vec![raw_name.clone()])),
         };
 

plugins/warp/src/convert/symbol.rs

@@ -1,4 +1,5 @@
 use binaryninja::binary_view::BinaryView;
+use binaryninja::demangle::{demangle_any, DemanglerConfig};
 use binaryninja::rc::Ref as BNRef;
 use binaryninja::symbol::Symbol as BNSymbol;
 use binaryninja::symbol::SymbolType as BNSymbolType;
@@ -74,18 +75,19 @@ pub fn to_bn_symbol_at_address(view: &BinaryView, symbol: &Symbol, addr: u64) ->
     };
     let raw_name = symbol.name.as_str();
     let mut symbol_builder = BNSymbol::builder(symbol_type, &symbol.name, addr);
-    // Demangle symbol name (short is with simplifications).
-    if let Some(arch) = view.default_arch() {
-        if let Some((full_name, _)) =
-            binaryninja::demangle::demangle_generic(&arch, raw_name, Some(view), false)
-        {
-            symbol_builder = symbol_builder.full_name(full_name);
-        }
-        if let Some((short_name, _)) =
-            binaryninja::demangle::demangle_generic(&arch, raw_name, Some(view), false)
-        {
-            symbol_builder = symbol_builder.short_name(short_name);
-        }
+    let config = DemanglerConfig::for_binary_view(view);
+    if let Some(result) = demangle_any(raw_name, &config) {
+        let short_name = result.name.to_string();
+        let platform = config.get_platform();
+        let full_name = match result.ty {
+            Some(ty) => format!(
+                "{}{}",
+                short_name,
+                ty.get_string_after_name(Some(&platform))
+            ),
+            None => short_name.clone(),
+        };
+        symbol_builder = symbol_builder.short_name(short_name).full_name(full_name);
     }
     symbol_builder.create()
 }

plugins/warp/tests/symbol.rs

@@ -0,0 +1,23 @@
+use binaryninja::architecture::{ArchitectureExt, CoreArchitecture};
+use binaryninja::binary_view::BinaryView;
+use binaryninja::file_metadata::FileMetadata;
+use binaryninja::headless::Session;
+use warp::symbol::{Symbol, SymbolClass, SymbolModifiers};
+use warp_ninja::convert::to_bn_symbol_at_address;
+
+#[test]
+fn demangled_symbol_names_include_parameters_only_in_the_full_name() {
+    let _session = Session::new().expect("Failed to create session");
+    let view = BinaryView::from_data(&FileMetadata::new(), &[]);
+    let platform = CoreArchitecture::by_name("x86_64")
+        .expect("x86_64 exists")
+        .standalone_platform()
+        .expect("x86_64 standalone platform exists");
+    view.set_default_platform(&platform);
+
+    let symbol = Symbol::new("_Z3fooi", SymbolClass::Function, SymbolModifiers::default());
+    let bn_symbol = to_bn_symbol_at_address(&view, &symbol, 0);
+
+    assert_eq!(bn_symbol.short_name().to_string_lossy(), "foo");
+    assert_eq!(bn_symbol.full_name().to_string_lossy(), "foo(int32_t)");
+}

plugins/workflow_swift/src/demangler/mod.rs

@@ -2,12 +2,10 @@ mod function_type;
 mod name;
 mod type_reconstruction;
 
-use binaryninja::architecture::CoreArchitecture;
 use binaryninja::binary_view::BinaryView;
-use binaryninja::demangle::CustomDemangler;
-use binaryninja::rc::Ref;
+use binaryninja::demangle::{CustomDemangler, DemanglerConfig, DemanglerResult};
 use binaryninja::settings::{QueryOptions, Settings};
-use binaryninja::types::{QualifiedName, Type};
+use binaryninja::types::QualifiedName;
 
 fn should_extract_types(view: Option<&BinaryView>) -> bool {
     let mut opts = match view {
@@ -30,27 +28,25 @@ impl CustomDemangler for SwiftDemangler {
             || name.starts_with("_T")
     }
 
-    fn demangle(
-        &self,
-        arch: &CoreArchitecture,
-        name: &str,
-        view: Option<Ref<BinaryView>>,
-    ) -> Option<(QualifiedName, Option<Ref<Type>>)> {
+    fn demangle(&self, name: &str, config: &DemanglerConfig) -> Option<DemanglerResult> {
         let ctx = swift_demangler::Context::new();
         let symbol = swift_demangler::Symbol::parse(&ctx, name)?;
 
-        if should_extract_types(view.as_deref()) {
-            let ty = function_type::build_function_type(&symbol, arch);
+        if should_extract_types(config.view.as_deref()) {
+            let ty = config
+                .platform
+                .as_ref()
+                .and_then(|platform| function_type::build_function_type(&symbol, &platform.arch()));
             let qname = if ty.is_some() {
                 name::build_short_name(&symbol)
             } else {
                 None
             }
             .unwrap_or_else(|| QualifiedName::from(symbol.display()));
-            Some((qname, ty))
+            Some(DemanglerResult::new(qname, ty))
         } else {
             let qname = QualifiedName::from(symbol.display());
-            Some((qname, None))
+            Some(DemanglerResult::new(qname, None))
         }
     }
 }

plugins/workflow_swift/src/lib.rs

@@ -30,7 +30,5 @@ pub extern "C" fn CorePluginInit() -> bool {
         }"#,
     );
 
-    Demangler::register("Swift", SwiftDemangler);
-
-    true
+    Demangler::register("Swift", SwiftDemangler)
 }

rust/examples/demangler.rs

@@ -1,7 +1,5 @@
-use binaryninja::architecture::CoreArchitecture;
-use binaryninja::binary_view::BinaryView;
-use binaryninja::demangle::{CustomDemangler, Demangler};
-use binaryninja::rc::Ref;
+use binaryninja::architecture::{ArchitectureExt, CoreArchitecture};
+use binaryninja::demangle::{CustomDemangler, Demangler, DemanglerConfig, DemanglerResult};
 use binaryninja::tracing::TracingLogListener;
 use binaryninja::types::{QualifiedName, Type};
 
@@ -12,15 +10,16 @@ impl CustomDemangler for TestDemangler {
         name == "test_name" || name == "test_name2"
     }
 
-    fn demangle(
-        &self,
-        _arch: &CoreArchitecture,
-        name: &str,
-        _view: Option<Ref<BinaryView>>,
-    ) -> Option<(QualifiedName, Option<Ref<Type>>)> {
+    fn demangle(&self, name: &str, _config: &DemanglerConfig) -> Option<DemanglerResult> {
         match name {
-            "test_name" => Some((QualifiedName::from(vec!["test_name"]), Some(Type::bool()))),
-            "test_name2" => Some((QualifiedName::from(vec!["test_name2", "aaa"]), None)),
+            "test_name" => Some(DemanglerResult::new(
+                QualifiedName::from(vec!["test_name"]),
+                Some(Type::bool()),
+            )),
+            "test_name2" => Some(DemanglerResult::new(
+                QualifiedName::from(vec!["test_name2", "aaa"]),
+                None,
+            )),
             _ => None,
         }
     }
@@ -30,14 +29,18 @@ fn main() {
     tracing_subscriber::fmt::init();
     let _listener = TracingLogListener::new().register();
 
+    tracing::info!("Registering demangler...");
+    assert!(Demangler::register("Test", TestDemangler));
+
     // This loads all the core architecture, platform, etc plugins
     let _headless_session =
         binaryninja::headless::Session::new().expect("Failed to initialize session");
 
-    tracing::info!("Registering demangler...");
-    Demangler::register("Test", TestDemangler);
-
     let placeholder_arch = CoreArchitecture::by_name("x86_64").expect("x86 exists");
+    let platform = placeholder_arch
+        .standalone_platform()
+        .expect("x86 standalone platform exists");
+    let config = DemanglerConfig::for_platform(&platform, false);
 
     for d in Demangler::list().iter() {
         tracing::info!("{}", d.name());
@@ -46,17 +49,8 @@ fn main() {
             "  \"__ZN1AC2Ei\" is mangled? {}",
             d.is_mangled_string("__ZN1AC2Ei")
         );
-        tracing::info!(
-            "  \"__ZN1AC2Ei\" : {:?}",
-            d.demangle(&placeholder_arch, "__ZN1AC2Ei", None)
-        );
-        tracing::info!(
-            "  \"test_name\" : {:?}",
-            d.demangle(&placeholder_arch, "test_name", None)
-        );
-        tracing::info!(
-            "  \"test_name2\" : {:?}",
-            d.demangle(&placeholder_arch, "test_name2", None)
-        );
+        tracing::info!("  \"__ZN1AC2Ei\" : {:?}", d.demangle("__ZN1AC2Ei", &config));
+        tracing::info!("  \"test_name\" : {:?}", d.demangle("test_name", &config));
+        tracing::info!("  \"test_name2\" : {:?}", d.demangle("test_name2", &config));
     }
 }