use crate::analyzers::{Analyzer, Annotation, AnnotationKind};
use crate::binary::Binary;
use std::fmt::{self, Write as _};
const MAX_MANGLED_LEN: usize = 16 * 1024;
const MAX_DEMANGLED_LEN: usize = 4096;
#[derive(Debug, Clone, Default)]
pub struct SymbolsAnalyzer;
impl SymbolsAnalyzer {
#[must_use]
pub const fn new() -> Self {
Self
}
}
impl Analyzer for SymbolsAnalyzer {
fn name(&self) -> &'static str {
"symbols"
}
fn analyze(&self, bin: &Binary) -> Vec<Annotation> {
let mut out = Vec::with_capacity(bin.symbols.len());
for sym in &bin.symbols {
let pretty = try_demangle(&sym.name);
if pretty.is_empty() {
continue;
}
out.push(Annotation {
vaddr: sym.vaddr,
kind: AnnotationKind::Symbol,
label: pretty,
comment: if sym.size > 0 {
Some(format!("size={}", sym.size))
} else {
None
},
});
}
out
}
}
fn try_demangle(raw: &str) -> String {
try_demangle_with_limit(raw, MAX_DEMANGLED_LEN)
}
fn try_demangle_with_limit(raw: &str, max_len: usize) -> String {
if !is_demangle_candidate(raw) {
return raw.to_string();
}
let Ok(demangled) = rustc_demangle::try_demangle(raw) else {
return raw.to_string();
};
let mut output = BoundedOutput {
text: String::with_capacity(raw.len().min(max_len)),
max_len,
};
if write!(&mut output, "{demangled:#}").is_err() || output.text.is_empty() {
raw.to_string()
} else {
output.text
}
}
const fn is_demangle_candidate(raw: &str) -> bool {
raw.len() <= MAX_MANGLED_LEN && raw.is_ascii()
}
struct BoundedOutput {
text: String,
max_len: usize,
}
impl fmt::Write for BoundedOutput {
fn write_str(&mut self, s: &str) -> fmt::Result {
if self
.text
.len()
.checked_add(s.len())
.is_none_or(|len| len > self.max_len)
{
return Err(fmt::Error);
}
self.text.push_str(s);
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn demangles_v0() {
let s = try_demangle("_RNvCs4fqI2P2rA4_7mycrate3foo");
assert!(s.contains("mycrate"), "got: {s}");
}
#[test]
fn demangles_legacy() {
let s = try_demangle("_ZN7mycrate3fooE");
assert!(s.contains("mycrate"), "got: {s}");
}
#[test]
fn alternate_format_suppresses_legacy_hash() {
assert_eq!(try_demangle("_ZN3foo17h05af221e174051e9E"), "foo");
}
#[test]
fn demangling_stops_at_output_limit() {
let mut exponential = String::from("_RMC0");
exponential.push_str(&"T".repeat(20));
exponential.push('p');
for offset in (3u8..=22).rev() {
let digit = if offset < 10 {
char::from(b'0' + offset)
} else {
char::from(b'a' + offset - 10)
};
exponential.push('B');
exponential.push(digit);
exponential.push_str("_E");
}
assert!(exponential.len() < 128);
assert!(rustc_demangle::try_demangle(&exponential).is_ok());
assert_eq!(try_demangle_with_limit(&exponential, 64), exponential);
}
#[test]
fn bounded_output_allows_writes_that_exactly_fill_limit() {
let mut output = BoundedOutput {
text: String::new(),
max_len: 3,
};
assert_eq!(fmt::Write::write_str(&mut output, "ab"), Ok(()));
assert_eq!(fmt::Write::write_str(&mut output, "c"), Ok(()));
assert_eq!(output.text, "abc");
assert!(fmt::Write::write_str(&mut output, "d").is_err());
assert_eq!(output.text, "abc");
}
#[test]
fn oversized_or_non_ascii_input_skips_demangler() {
let exact_limit = "A".repeat(16_384);
assert!(is_demangle_candidate(&exact_limit));
let over_limit = "A".repeat(16_385);
assert!(!is_demangle_candidate(&over_limit));
let oversized = format!("_R{}", "A".repeat(MAX_MANGLED_LEN));
assert!(!is_demangle_candidate(&oversized));
assert_eq!(try_demangle(&oversized), oversized);
assert!(!is_demangle_candidate("_Ré"));
assert_eq!(try_demangle("_Ré"), "_Ré");
}
#[test]
fn passthrough_non_rust() {
let s = try_demangle("printf");
assert_eq!(s, "printf");
}
#[test]
fn empty_demangle_output_falls_back_to_raw_symbol() {
assert_eq!(try_demangle("RC0"), "RC0");
}
#[test]
fn analyzer_skips_empty_raw_symbol_names() {
let bin = Binary::from_test_parts(
crate::binary::BinaryFormat::Elf,
true,
true,
vec![],
vec![crate::binary::Symbol {
vaddr: 0x1000,
name: String::new(),
size: 0,
}],
vec![],
);
assert!(SymbolsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn name_returns_symbols() {
assert_eq!(SymbolsAnalyzer::new().name(), "symbols");
}
}