rustrip 0.1.14

Make stripped Rust binaries readable again: recover slice-string boundaries, demangle symbols, and reconstruct panic source locations from release/stripped ELF, PE, and Mach-O binaries.
Documentation
//! Demangle Rust symbol names from .symtab / .dynsym / PE exports.
//!
//! Covers both the legacy `_ZN…E` (C++-style Itanium) mangling used by
//! rustc pre-1.70 and the v0 `_R…` mangling introduced afterward. The
//! `rustc-demangle` crate handles both formats and falls back gracefully
//! on non-Rust symbols by passing them through unchanged.

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;

/// Analyzer that demangles Rust symbol names from the symbol table.
#[derive(Debug, Clone, Default)]
pub struct SymbolsAnalyzer;

impl SymbolsAnalyzer {
    /// Create a new symbol demangling analyzer.
    #[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");
    }
}