feat: Parameterize symbol demangling on command line. (#226)

* feat: Parameterize symbol demangling on command line.

This commit adds two new switched (--keep-mangled and --demangle) where --demangle is specified by default. keep-mangled can be useful when one wants to do the demangling themselves with a different library than rustc_demangle (e.g. to analyze symbol names with ast-demangle).

Author: john-donnal

.github/workflows/check-and-lint.yaml

@@ -43,9 +43,15 @@ jobs:
       - name: Native version of cargo-show-asm (Intel ASM) + atom
         run: cargo run -- --manifest-path sample/Cargo.toml --target-cpu atom --intel sample::main --rust
 
+      - name: Native version of cargo-show-asm with symbol mangling (Intel ASM)
+        run: cargo run -- --manifest-path sample/Cargo.toml --intel sample::main --rust --keep-mangled
+
       - name: Native version of cargo-show-asm (LLVM)
         run: cargo run -- --manifest-path sample/Cargo.toml --llvm sample::main
 
+      - name: Native version of cargo-show-asm with symbol mangling (LLVM)
+        run: cargo run -- --manifest-path sample/Cargo.toml --llvm --keep-mangled sample::main
+
       - name: Native version of cargo-show-asm (LLVM Input)
         run: cargo run -- --manifest-path sample/Cargo.toml --llvm-input sample::main
 
@@ -102,9 +108,15 @@ jobs:
       - name: Native version of cargo-show-asm (Intel ASM) + atom
         run: cargo run -- --manifest-path sample/Cargo.toml --target-cpu atom --intel sample::main --rust
 
+      - name: Native version of cargo-show-asm with symbol mangling (Intel ASM)
+        run: cargo run -- --manifest-path sample/Cargo.toml --intel sample::main --rust --keep-mangled
+
       - name: Native version of cargo-show-asm (LLVM)
         run: cargo run -- --manifest-path sample/Cargo.toml --llvm sample::main
 
+      - name: Native version of cargo-show-asm with symbol mangling (LLVM)
+        run: cargo run -- --manifest-path sample/Cargo.toml --llvm --keep-mangled sample::main
+
       - name: Native version of cargo-show-asm (LLVM Input)
         run: cargo run -- --manifest-path sample/Cargo.toml --llvm-input sample::main
 
@@ -158,9 +170,15 @@ jobs:
       - name: Native version of cargo-show-asm (Intel ASM) + atom
         run: cargo run -- --manifest-path sample/Cargo.toml --target-cpu atom --intel sample::main --rust
 
+      - name: Native version of cargo-show-asm with symbol mangling (Intel ASM)
+        run: cargo run -- --manifest-path sample/Cargo.toml --intel sample::main --rust --keep-mangled
+
       - name: Native version of cargo-show-asm (LLVM)
         run: cargo run -- --manifest-path sample/Cargo.toml --llvm sample::main
 
+      - name: Native version of cargo-show-asm with symbol mangling (LLVM)
+        run: cargo run -- --manifest-path sample/Cargo.toml --llvm --keep-mangled sample::main
+
       - name: Native version of cargo-show-asm (LLVM Input)
         run: cargo run -- --manifest-path sample/Cargo.toml --llvm-input sample::main
 

README.md

@@ -115,6 +115,10 @@ Show the code rustc generates for any function
   Disable color highlighting
 - **`    --full-name`** — 
   Include full demangled name instead of just prefix
+- **`    --short-name`** — 
+  Include demangled names without hash suffix (default)
+- **`    --keep-mangled`** — 
+  Do not demangle symbol names
 - **`-K`**, **`--keep-labels`** — 
   Keep all the original labels
 - **`-B`**, **`--keep-blanks`** — 

src/asm.rs

@@ -82,6 +82,7 @@ pub fn find_items(lines: &[Statement]) -> BTreeMap<Item, Range<usize>> {
                 let name = format!("{dem:#?}");
                 let name_entry = names.entry(name.clone()).or_insert(0);
                 item = Some(Item {
+                    mangled_name: label.id.to_owned(),
                     name,
                     hashed,
                     index: *name_entry,
@@ -156,6 +157,7 @@ fn get_item_in_section(
                 String::from(label.id)
             };
             return Some(Item {
+                mangled_name: label.id.to_owned(),
                 name: name.clone(),
                 hashed: name,
                 index: 0, // Written later in find_items
@@ -273,9 +275,9 @@ pub fn dump_range(
 
             empty_line = false;
             #[allow(clippy::match_bool)]
-            match fmt.full_name {
-                true => safeprintln!("{line:#}"),
-                false => safeprintln!("{line}"),
+            match fmt.name_display {
+                crate::opts::NameDisplay::Full => safeprintln!("{line:#}"),
+                _ => safeprintln!("{line}"),
             }
         }
     }

src/lib.rs

@@ -2,7 +2,7 @@
 
 use std::{collections::BTreeMap, ops::Range};
 
-use opts::{Format, ToDump};
+use opts::{Format, NameDisplay, ToDump};
 pub mod asm;
 pub mod cached_lines;
 pub mod demangle;
@@ -66,6 +66,8 @@ macro_rules! esafeprint {
 
 #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
 pub struct Item {
+    /// mangled name
+    pub mangled_name: String,
     /// demangled name
     pub name: String,
     /// demangled name with hash
@@ -76,13 +78,20 @@ pub struct Item {
     pub len: usize,
 }
 
-pub fn suggest_name<'a>(search: &str, full: bool, items: impl IntoIterator<Item = &'a Item>) {
+pub fn suggest_name<'a>(
+    search: &str,
+    name_display: &NameDisplay,
+    items: impl IntoIterator<Item = &'a Item>,
+) {
     let mut count = 0usize;
     let names = items.into_iter().fold(BTreeMap::new(), |mut m, item| {
         count += 1;
-        m.entry(if full { &item.hashed } else { &item.name })
-            .or_insert_with(Vec::new)
-            .push(item.len);
+        let entry = match name_display {
+            NameDisplay::Full => &item.hashed,
+            NameDisplay::Short => &item.name,
+            NameDisplay::Mangled => &item.mangled_name,
+        };
+        m.entry(entry).or_insert_with(Vec::new).push(item.len);
         m
     });
 
@@ -170,7 +179,7 @@ pub fn get_dump_range(
                 if filtered.is_empty() {
                     safeprintln!("Can't find any items matching {function:?}");
                 } else {
-                    suggest_name(&function, fmt.full_name, filtered.iter().map(|x| x.0));
+                    suggest_name(&function, &fmt.name_display, filtered.iter().map(|x| x.0));
                 }
                 std::process::exit(1);
             };
@@ -180,7 +189,7 @@ pub fn get_dump_range(
         // Unspecified, so print suggestions and exit
         ToDump::Unspecified => {
             let items = items.into_keys().collect::<Vec<_>>();
-            suggest_name("", fmt.full_name, &items);
+            suggest_name("", &fmt.name_display, &items);
             unreachable!("suggest_name exits");
         }
     }

src/llvm.rs

@@ -8,7 +8,7 @@ use crate::{
     color,
     demangle::{self, contents},
     get_dump_range,
-    opts::{Format, ToDump},
+    opts::{Format, NameDisplay, ToDump},
     safeprintln, Item,
 };
 use std::{
@@ -39,20 +39,22 @@ fn find_items(lines: &CachedLines) -> BTreeMap<Item, Range<usize>> {
             continue;
         } else if let (true, Some(name)) = (current_item.is_none(), line.strip_prefix("; ")) {
             current_item = Some(Item {
+                mangled_name: name.to_owned(),
                 name: name.to_owned(),
                 hashed: String::new(),
                 index: res.len(),
                 len: ix,
             });
         } else if line.starts_with("define ") {
-            if let (Some(cur), Some(hashed)) = (
+            if let (Some(cur), Some((mangled_name, hashed))) = (
                 &mut current_item,
                 regex
                     .captures(line)
                     .and_then(|c| c.get(1))
                     .map(|c| c.as_str())
-                    .and_then(demangle::demangled),
+                    .and_then(|c| Some((c.to_owned(), demangle::demangled(c)?))),
             ) {
+                cur.mangled_name = mangled_name;
                 cur.hashed = format!("{hashed:?}");
             }
         } else if line == "}" {
@@ -88,7 +90,7 @@ fn dump_range(fmt: &Format, strings: &[&str]) {
         if line.starts_with("; ") {
             safeprintln!("{}", color!(line, OwoColorize::bright_black));
         } else {
-            let line = demangle::contents(line, fmt.full_name);
+            let line = demangle::contents(line, fmt.name_display == NameDisplay::Full);
             safeprintln!("{line}");
         }
     }
@@ -142,11 +144,11 @@ pub fn collect_or_dump(
                 if line.starts_with("define ") {
                     state = State::Define;
 
-                    if let Some(hashed) = regex
+                    if let Some((mangled_name, hashed)) = regex
                         .captures(&line)
                         .and_then(|c| c.get(1))
                         .map(|c| c.as_str())
-                        .and_then(demangle::demangled)
+                        .and_then(|c| Some((c.to_owned(), demangle::demangled(c)?)))
                     {
                         let hashed = format!("{hashed:?}");
                         let name_entry = names.entry(name.clone()).or_insert(0);
@@ -155,6 +157,7 @@ pub fn collect_or_dump(
                         });
 
                         current_item = Some(Item {
+                            mangled_name,
                             name: name.clone(),
                             hashed,
                             index: *name_entry,
@@ -165,7 +168,10 @@ pub fn collect_or_dump(
                         if seen {
                             safeprintln!("{}", color!(name, OwoColorize::cyan));
                             safeprintln!("{}", color!(attrs, OwoColorize::cyan));
-                            safeprintln!("{}", contents(&line, fmt.full_name));
+                            safeprintln!(
+                                "{}",
+                                contents(&line, fmt.name_display == NameDisplay::Full)
+                            );
                         }
                     } else {
                         state = State::Skipping;
@@ -176,7 +182,7 @@ pub fn collect_or_dump(
             }
             State::Define => {
                 if seen {
-                    safeprintln!("{}", contents(&line, fmt.full_name));
+                    safeprintln!("{}", contents(&line, fmt.name_display == NameDisplay::Full));
                 }
                 if line == "}" {
                     if let Some(mut cur) = current_item.take() {

src/mca.rs

@@ -6,7 +6,7 @@ use std::{
 
 use crate::{
     demangle, esafeprintln, get_dump_range,
-    opts::{Format, ToDump},
+    opts::{Format, NameDisplay, ToDump},
     safeprintln,
 };
 
@@ -87,7 +87,7 @@ pub fn dump_function(
 
     for line in BufRead::lines(BufReader::new(o)) {
         let line = line?;
-        let line = demangle::contents(&line, fmt.full_name);
+        let line = demangle::contents(&line, fmt.name_display == NameDisplay::Full);
         safeprintln!("{line}");
     }
 

src/mir.rs

@@ -38,6 +38,7 @@ fn find_items(lines: &CachedLines) -> BTreeMap<Item, Range<usize>> {
                 break;
             }
             current_item = Some(Item {
+                mangled_name: name.to_owned(),
                 name: name.to_owned(),
                 hashed: name.to_owned(),
                 index: res.len(),

src/opts.rs

@@ -215,9 +215,8 @@ pub struct Format {
     #[bpaf(external(color_detection), hide_usage)]
     pub color: bool,
 
-    /// Include full demangled name instead of just prefix
-    #[bpaf(hide_usage)]
-    pub full_name: bool,
+    #[bpaf(hide_usage, external)]
+    pub name_display: NameDisplay,
 
     #[bpaf(external, hide_usage)]
     pub redundant_labels: RedundantLabels,
@@ -248,6 +247,22 @@ pub enum RedundantLabels {
     Strip,
 }
 
+#[derive(Debug, Copy, Clone, Bpaf, Eq, PartialEq)]
+#[bpaf(fallback(NameDisplay::Short))]
+pub enum NameDisplay {
+    #[bpaf(long("full-name"))]
+    /// Include full demangled name instead of just prefix
+    Full,
+
+    /// Include demangled names without hash suffix (default)
+    #[bpaf(long("short-name"))]
+    Short,
+
+    /// Do not demangle symbol names
+    #[bpaf(long("keep-mangled"))]
+    Mangled,
+}
+
 #[derive(Debug, Clone, Bpaf, Eq, PartialEq, Copy)]
 #[bpaf(custom_usage(&[("OUTPUT-FORMAT", Style::Metavar)]), fallback(Syntax::Intel))]
 /// Pick output format: