deps: update blazesym submodule to v0.2.0-alpha.5

Update the blazesym submodule to version 0.2.0-alpha.5. Also change the
dependency to using the default features, which includes DWARF support
and transparent symbol demangling.
The profile example is overhauled to use the changed APIs and improve
the code to be less redundant.

Signed-off-by: Daniel Müller <deso@posteo.net>

Author: d-e-s-o

blazesym

@@ -55,32 +55,36 @@ static void show_stack_trace(__u64 *stack, int stack_sz, pid_t pid)
 
 	for (i = 0; i < stack_sz; i++) {
 		if (!result || result->size <= i || !result->entries[i].size) {
-			printf("  %d [<%016llx>]\n", i, stack[i]);
+			printf(" %2d [<%016llx>]\n", i, stack[i]);
 			continue;
 		}
 
 		if (result->entries[i].size == 1) {
 			sym = &result->entries[i].syms[0];
-			if (sym->path && sym->path[0]) {
-				printf("  %d [<%016llx>] %s+0x%llx %s:%ld\n", i, stack[i],
-				       sym->symbol, stack[i] - sym->addr, sym->path,
-				       sym->line);
+
+			if (sym->dir && sym->dir[0] != '\0' && sym->file && sym->file[0] != '\0') {
+				printf(" %2d [<%016llx>] %s+0x%lx %s/%s:%u\n", i, stack[i],
+				       sym->name, sym->offset, sym->dir, sym->file, sym->line);
+			} else if (sym->file && sym->file[0] != '\0') {
+				printf(" %2d [<%016llx>] %s+0x%lx %s:%u\n", i, stack[i],
+				       sym->name, sym->offset, sym->file, sym->line);
 			} else {
-				printf("  %d [<%016llx>] %s+0x%llx\n", i, stack[i], sym->symbol,
-				       stack[i] - sym->addr);
+				printf(" %2d [<%016llx>] %s+0x%lx\n", i, stack[i], sym->name, sym->offset);
 			}
 			continue;
 		}
 
-		printf("  %d [<%016llx>]\n", i, stack[i]);
+		printf(" %2d [<%016llx>]\n", i, stack[i]);
 		for (j = 0; j < result->entries[i].size; j++) {
 			sym = &result->entries[i].syms[j];
-			if (sym->path && sym->path[0]) {
-				printf("        %s+0x%llx %s:%ld\n", sym->symbol,
-				       stack[i] - sym->addr, sym->path, sym->line);
+			if (sym->dir && sym->dir[0] != '\0' && sym->file && sym->file[0] != '\0') {
+				printf("        %s+0x%lx %s/%s:%u\n", sym->name,
+				       sym->offset, sym->dir, sym->file, sym->line);
+			} else if (sym->file && sym->file[0] != '\0') {
+				printf("        %s+0x%lx %s:%u\n", sym->name,
+				       sym->offset, sym->file, sym->line);
 			} else {
-				printf("        %s+0x%llx\n", sym->symbol,
-				       stack[i] - sym->addr);
+				printf("        %s+0x%lx\n", sym->name, sym->offset);
 			}
 		}
 	}

examples/c/profile.c

@@ -6,7 +6,7 @@ license = "GPL-2.0 OR BSD-3-Clause"
 edition = "2021"
 
 [dependencies]
-blazesym = { path = "../../../blazesym", default-features = false, features = ["dont-generate-test-files"] }
+blazesym = { path = "../../../blazesym" }
 clap = { version = "4.0", features = ["derive"] }
 libbpf-rs = "0.19"
 libc = "*"

examples/rust/Cargo.lock

@@ -1,9 +1,6 @@
-use std::u64;
-
-use std::boxed::Box;
 use std::io::Error;
 use std::mem;
-use std::result::Result;
+use std::path::PathBuf;
 use std::time::Duration;
 
 use blazesym::symbolize;
@@ -93,53 +90,40 @@ fn show_stack_trace(stack: &[u64], symbolizer: &symbolize::Symbolizer, pid: u32)
         Ok(syms) => syms,
         Err(err) => {
             eprintln!("  failed to symbolize addresses: {err:#}");
-            return
-        },
-    };
-
-    for i in 0..stack.len() {
-        if syms.len() <= i || syms[i].len() == 0 {
-            println!("  {} [<{:016x}>]", i, stack[i]);
-            continue;
-        }
-
-        if syms[i].len() == 1 {
-            let sym = &syms[i][0];
-            if !sym.path.as_os_str().is_empty() {
-                println!(
-                    "  {} [<{:016x}>] {}+0x{:x} {}:{}",
-                    i,
-                    stack[i],
-                    sym.symbol,
-                    stack[i] - sym.addr,
-                    sym.path.display(),
-                    sym.line
-                );
-            } else {
-                println!(
-                    "  {} [<{:016x}>] {}+0x{}",
-                    i,
-                    stack[i],
-                    sym.symbol,
-                    stack[i] - sym.addr
-                );
-            }
-            continue;
+            return;
         }
+    };
 
-        println!("  {} [<{:016x}>]", i, stack[i]);
-
-        for sym in &syms[i] {
-            if !sym.path.as_os_str().is_empty() {
-                println!(
-                    "        {}+0x{:x} {}:{}",
-                    sym.symbol,
-                    stack[i] - sym.addr,
-                    sym.path.display(),
-                    sym.line
-                );
-            } else {
-                println!("        {}+0x{}", sym.symbol, stack[i] - sym.addr);
+    for (i, (addr, syms)) in stack.iter().zip(syms).enumerate() {
+        let mut addr_fmt = format!(" {i:2} [<{addr:016x}>]");
+        if syms.is_empty() {
+            println!("{addr_fmt}")
+        } else {
+            for (i, sym) in syms.into_iter().enumerate() {
+                if i == 1 {
+                    addr_fmt = addr_fmt.replace(|_c| true, " ");
+                }
+
+                let path = match (sym.dir, sym.file) {
+                    (Some(dir), Some(file)) => Some(dir.join(file)),
+                    (dir, file) => dir.or_else(|| file.map(PathBuf::from)),
+                };
+
+                let src_loc = if let (Some(path), Some(line)) = (path, sym.line) {
+                    if let Some(col) = sym.column {
+                        format!(" {}:{line}:{col}", path.display())
+                    } else {
+                        format!(" {}:{line}", path.display())
+                    }
+                } else {
+                    String::new()
+                };
+
+                let symbolize::Sym {
+                    name, addr, offset, ..
+                } = sym;
+
+                println!("{addr_fmt} {name} @ {addr:#x}+{offset:#x}{src_loc}");
             }
         }
     }