Add demangle option to collapsers

Cargo.toml

@@ -37,6 +37,8 @@ lazy_static = "1.3.0"
 fnv = "1.0.3"
 itoa = "0.4.3"
 indexmap = "1.0"
+symbolic-common = "6.1.3"
+symbolic-demangle = "6.1.3"
 
 [dev-dependencies]
 pretty_assertions = "0.6"

src/bin/collapse-dtrace.rs

@@ -30,6 +30,10 @@ struct Opt {
     #[structopt(long = "includeoffset")]
     includeoffset: bool,
 
+    /// Demangle function names
+    #[structopt(long = "demangle")]
+    demangle: bool,
+
     /// perf script output file, or STDIN if not specified
     infile: Option<PathBuf>,
 }
@@ -40,6 +44,7 @@ impl Opt {
             self.infile,
             Options {
                 includeoffset: self.includeoffset,
+                demangle: self.demangle,
             },
         )
     }

src/bin/collapse-perf.rs

@@ -54,6 +54,10 @@ struct Opt {
     #[structopt(short = "v", long = "verbose", parse(from_occurrences))]
     verbose: usize,
 
+    /// Demangle function names
+    #[structopt(long = "demangle")]
+    demangle: bool,
+
     /// perf script output file, or STDIN if not specified
     infile: Option<PathBuf>,
 }
@@ -69,6 +73,7 @@ impl Opt {
                 annotate_jit: self.annotate_jit || self.annotate_all,
                 annotate_kernel: self.annotate_kernel || self.annotate_all,
                 event_filter: self.event_filter,
+                demangle: self.demangle,
             },
         )
     }

src/collapse/dtrace.rs

@@ -1,9 +1,11 @@
 use super::Collapse;
 use fnv::FnvHashMap;
 use log::warn;
+use std::borrow::Cow;
 use std::collections::VecDeque;
 use std::io;
 use std::io::prelude::*;
+use symbolic_demangle::demangle;
 
 /// Settings that change how frames are named from the incoming stack traces.
 ///
@@ -12,6 +14,9 @@ use std::io::prelude::*;
 pub struct Options {
     /// include function offset (except leafs)
     pub includeoffset: bool,
+
+    /// Demangle function names
+    pub demangle: bool,
 }
 
 /// A stack collapser for the output of dtrace `ustrace()`.
@@ -182,8 +187,17 @@ impl Folder {
             frame = Self::uncpp(frame);
         }
 
-        if frame.is_empty() {
-            frame = "-";
+        let frame = if frame.is_empty() {
+            Cow::Owned("-".to_owned())
+        } else if self.opt.demangle {
+            let mut parts = frame.split('`');
+            if let (Some(pname), Some(func)) = (parts.next(), parts.next()) {
+                Cow::Owned(format!("{}`{}", pname, demangle(func)))
+            } else {
+                Cow::Borrowed(frame)
+            }
+        } else {
+            Cow::Borrowed(frame)
         };
 
         if has_inlines {
@@ -207,7 +221,7 @@ impl Folder {
         } else if has_semicolon {
             self.stack.push_front(frame.replace(';', ":"))
         } else {
-            self.stack.push_front(frame.to_owned())
+            self.stack.push_front(frame.to_string())
         }
     }
 
@@ -231,6 +245,7 @@ impl Folder {
                 stack_str.push_str(&e);
             }
         }
+
         // count it!
         *self.occurrences.entry(stack_str).or_insert(0) += count;
         // reset for the next event

src/collapse/perf.rs

@@ -1,9 +1,11 @@
 use super::Collapse;
 use fnv::FnvHashMap;
 use log::warn;
+use std::borrow::Cow;
 use std::collections::VecDeque;
 use std::io;
 use std::io::prelude::*;
+use symbolic_demangle::demangle;
 
 const TIDY_GENERIC: bool = true;
 const TIDY_JAVA: bool = true;
@@ -32,6 +34,9 @@ pub struct Options {
     /// Annotate kernel functions with a `_[k]` suffix.
     pub annotate_kernel: bool,
 
+    /// Demangle function names
+    pub demangle: bool,
+
     /// Only consider samples of the given event type (see `perf list`).
     ///
     /// If this option is set to `None`, it will be set to the first encountered event type.
@@ -318,6 +323,12 @@ impl Folder {
                 return;
             }
 
+            let rawfunc = if self.opt.demangle {
+                demangle(rawfunc)
+            } else {
+                Cow::Borrowed(rawfunc)
+            };
+
             // Support Java inlining by splitting on "->". After the first func, the
             // rest are annotated with "_[i]" to mark them as inlined.
             // See https://github.com/brendangregg/FlameGraph/pull/89.

tests/collapse-dtrace.rs

@@ -10,7 +10,7 @@ use std::io::{self, BufReader, Cursor};
 use std::process::{Command, Stdio};
 
 fn test_collapse_dtrace(test_file: &str, expected_file: &str, options: Options) -> io::Result<()> {
-    test_collapse(Folder::from(options), test_file, expected_file)
+    test_collapse(Folder::from(options), test_file, expected_file, false)
 }
 
 fn test_collapse_dtrace_logs<F>(input_file: &str, asserter: F)
@@ -43,6 +43,7 @@ fn collapse_dtrace_compare_to_upstream_with_offsets() {
         result_file,
         Options {
             includeoffset: true,
+            demangle: false,
         },
     )
     .unwrap()
@@ -76,6 +77,7 @@ fn collapse_dtrace_compare_to_flamegraph_bug() {
         result_file,
         Options {
             includeoffset: true,
+            demangle: false,
         },
     )
     .unwrap()
@@ -108,6 +110,21 @@ fn collapse_dtrace_scope_with_no_argument_list() {
     test_collapse_dtrace(test_file, result_file, Options::default()).unwrap()
 }
 
+#[test]
+fn collapse_dtrace_demangle() {
+    let test_file = "./tests/data/collapse-dtrace/mangled.txt";
+    let result_file = "./tests/data/collapse-dtrace/results/demangled.txt";
+    test_collapse_dtrace(
+        test_file,
+        result_file,
+        Options {
+            includeoffset: false,
+            demangle: true,
+        },
+    )
+    .unwrap()
+}
+
 #[test]
 fn collapse_dtrace_cli() {
     let input_file = "./flamegraph/example-dtrace-stacks.txt";
@@ -120,7 +137,7 @@ fn collapse_dtrace_cli() {
         .output()
         .expect("failed to execute process");
     let expected = BufReader::new(File::open(expected_file).unwrap());
-    compare_results(Cursor::new(output.stdout), expected, expected_file);
+    compare_results(Cursor::new(output.stdout), expected, expected_file, false);
 
     // Test with STDIN
     let mut child = Command::cargo_bin("inferno-collapse-dtrace")
@@ -134,5 +151,5 @@ fn collapse_dtrace_cli() {
     io::copy(&mut input, stdin).unwrap();
     let output = child.wait_with_output().expect("Failed to read stdout");
     let expected = BufReader::new(File::open(expected_file).unwrap());
-    compare_results(Cursor::new(output.stdout), expected, expected_file);
+    compare_results(Cursor::new(output.stdout), expected, expected_file, false);
 }

tests/collapse-guess.rs

@@ -10,7 +10,7 @@ use std::io::{self, BufReader, Cursor};
 use std::process::{Command, Stdio};
 
 fn test_collapse_guess(test_file: &str, expected_file: &str) -> io::Result<()> {
-    test_collapse(Folder {}, test_file, expected_file)
+    test_collapse(Folder {}, test_file, expected_file, true)
 }
 
 fn test_collapse_guess_logs<F>(input_file: &str, asserter: F)
@@ -116,7 +116,7 @@ fn collapse_guess_cli() {
         .output()
         .expect("failed to execute process");
     let expected = BufReader::new(File::open(expected_file).unwrap());
-    compare_results(Cursor::new(output.stdout), expected, expected_file);
+    compare_results(Cursor::new(output.stdout), expected, expected_file, true);
 
     // Test with STDIN
     let mut child = Command::cargo_bin("inferno-collapse-guess")
@@ -130,5 +130,5 @@ fn collapse_guess_cli() {
     io::copy(&mut input, stdin).unwrap();
     let output = child.wait_with_output().expect("Failed to read stdout");
     let expected = BufReader::new(File::open(expected_file).unwrap());
-    compare_results(Cursor::new(output.stdout), expected, expected_file);
+    compare_results(Cursor::new(output.stdout), expected, expected_file, true);
 }

tests/collapse-perf.rs

@@ -10,8 +10,18 @@ use std::io::{self, BufReader, Cursor};
 use std::path::Path;
 use std::process::{Command, Stdio};
 
-fn test_collapse_perf(test_file: &str, expected_file: &str, options: Options) -> io::Result<()> {
-    test_collapse(Folder::from(options), test_file, expected_file)
+fn test_collapse_perf(
+    test_file: &str,
+    expected_file: &str,
+    options: Options,
+    strip_quotes: bool,
+) -> io::Result<()> {
+    test_collapse(
+        Folder::from(options),
+        test_file,
+        expected_file,
+        strip_quotes,
+    )
 }
 
 fn test_collapse_perf_logs<F>(input_file: &str, asserter: F)
@@ -87,6 +97,7 @@ macro_rules! collapse_perf_tests_inner {
                 test_path.join(test_file).to_str().unwrap(),
                 results_path.join(result_file).to_str().unwrap(),
                 options_from_vec(options),
+                true
             )
 
                 .unwrap()
@@ -211,6 +222,7 @@ fn collapse_perf_example_perf_stacks() {
         "./flamegraph/example-perf-stacks.txt.gz",
         "./tests/data/collapse-perf/results/example-perf-stacks-collapsed.txt",
         Default::default(),
+        false,
     )
     .unwrap();
 }
@@ -255,6 +267,22 @@ fn collapse_perf_should_warn_about_weird_input_lines() {
     );
 }
 
+#[test]
+fn collapse_perf_demangle() {
+    let test_file = "./tests/data/collapse-perf/mangled.txt";
+    let result_file = "./tests/data/collapse-perf/results/demangled.txt";
+    test_collapse_perf(
+        test_file,
+        result_file,
+        Options {
+            demangle: true,
+            ..Default::default()
+        },
+        false,
+    )
+    .unwrap()
+}
+
 #[test]
 fn collapse_perf_cli() {
     let input_file = "./flamegraph/test/perf-vertx-stacks-01.txt";
@@ -268,7 +296,7 @@ fn collapse_perf_cli() {
         .output()
         .expect("failed to execute process");
     let expected = BufReader::new(File::open(expected_file).unwrap());
-    compare_results(Cursor::new(output.stdout), expected, expected_file);
+    compare_results(Cursor::new(output.stdout), expected, expected_file, true);
 
     // Test with STDIN
     let mut child = Command::cargo_bin("inferno-collapse-perf")
@@ -283,5 +311,5 @@ fn collapse_perf_cli() {
     io::copy(&mut input, stdin).unwrap();
     let output = child.wait_with_output().expect("Failed to read stdout");
     let expected = BufReader::new(File::open(expected_file).unwrap());
-    compare_results(Cursor::new(output.stdout), expected, expected_file);
+    compare_results(Cursor::new(output.stdout), expected, expected_file, true);
 }

tests/collapse_common/mod.rs

@@ -7,6 +7,7 @@ pub(crate) fn test_collapse<C>(
     mut collapser: C,
     test_filename: &str,
     expected_filename: &str,
+    strip_quotes: bool,
 ) -> io::Result<()>
 where
     C: Collapse,
@@ -53,7 +54,7 @@ where
         eprintln!("test output in {}", tm.display());
     }
     // and then compare
-    compare_results(result, expected, expected_filename);
+    compare_results(result, expected, expected_filename, strip_quotes);
     Ok(return_value)
 }
 
@@ -68,16 +69,19 @@ where
     testing_logger::validate(asserter);
 }
 
-pub(crate) fn compare_results<R, E>(result: R, mut expected: E, expected_file: &str)
+pub(crate) fn compare_results<R, E>(result: R, mut expected: E, expected_file: &str, strip_quotes: bool)
 where
     R: BufRead,
     E: BufRead,
 {
     let mut buf = String::new();
     let mut line_num = 1;
     for line in result.lines() {
-        // Strip out " and ' since perl version does.
-        let line = line.unwrap().replace("\"", "").replace("'", "");
+        let line = if strip_quotes {
+            line.unwrap().replace("\"", "").replace("'", "")
+        } else {
+            line.unwrap()
+        };
         if expected.read_line(&mut buf).unwrap() == 0 {
             panic!(
                 "\noutput has more lines than expected result file: {}",