std: Use rustc_demangle from crates.io
No more need to duplicate the demangling routine between crates.io and the standard library, we can use the exact same one!
This commit is contained in:
Alex Crichton
parent
1897657ef0
commit
fcc8bb41e9
5 changed files with 27 additions and 236 deletions
|
|
@ -14,11 +14,12 @@
|
|||
use env;
|
||||
use io::prelude::*;
|
||||
use io;
|
||||
use path::{self, Path};
|
||||
use ptr;
|
||||
use rustc_demangle::demangle;
|
||||
use str;
|
||||
use sync::atomic::{self, Ordering};
|
||||
use path::{self, Path};
|
||||
use sys::mutex::Mutex;
|
||||
use ptr;
|
||||
|
||||
pub use sys::backtrace::{
|
||||
unwind_backtrace,
|
||||
|
|
@ -191,7 +192,14 @@ fn output(w: &mut dyn Write, idx: usize, frame: Frame,
|
|||
PrintFormat::Short => write!(w, " {:2}: ", idx)?,
|
||||
}
|
||||
match s {
|
||||
Some(string) => demangle(w, string, format)?,
|
||||
Some(string) => {
|
||||
let symbol = demangle(string);
|
||||
match format {
|
||||
PrintFormat::Full => write!(w, "{}", symbol)?,
|
||||
// strip the trailing hash if short mode
|
||||
PrintFormat::Short => write!(w, "{:#}", symbol)?,
|
||||
}
|
||||
}
|
||||
None => w.write_all(b"<unknown>")?,
|
||||
}
|
||||
w.write_all(b"\n")
|
||||
|
|
@ -235,228 +243,3 @@ fn output_fileline(w: &mut dyn Write,
|
|||
w.write_all(b"\n")
|
||||
}
|
||||
|
||||
|
||||
// All rust symbols are in theory lists of "::"-separated identifiers. Some
|
||||
// assemblers, however, can't handle these characters in symbol names. To get
|
||||
// around this, we use C++-style mangling. The mangling method is:
|
||||
//
|
||||
// 1. Prefix the symbol with "_ZN"
|
||||
// 2. For each element of the path, emit the length plus the element
|
||||
// 3. End the path with "E"
|
||||
//
|
||||
// For example, "_ZN4testE" => "test" and "_ZN3foo3barE" => "foo::bar".
|
||||
//
|
||||
// We're the ones printing our backtraces, so we can't rely on anything else to
|
||||
// demangle our symbols. It's *much* nicer to look at demangled symbols, so
|
||||
// this function is implemented to give us nice pretty output.
|
||||
//
|
||||
// Note that this demangler isn't quite as fancy as it could be. We have lots
|
||||
// of other information in our symbols like hashes, version, type information,
|
||||
// etc. Additionally, this doesn't handle glue symbols at all.
|
||||
pub fn demangle(writer: &mut dyn Write, mut s: &str, format: PrintFormat) -> io::Result<()> {
|
||||
// During ThinLTO LLVM may import and rename internal symbols, so strip out
|
||||
// those endings first as they're one of the last manglings applied to
|
||||
// symbol names.
|
||||
let llvm = ".llvm.";
|
||||
if let Some(i) = s.find(llvm) {
|
||||
let candidate = &s[i + llvm.len()..];
|
||||
let all_hex = candidate.chars().all(|c| {
|
||||
match c {
|
||||
'A' ..= 'F' | '0' ..= '9' => true,
|
||||
_ => false,
|
||||
}
|
||||
});
|
||||
|
||||
if all_hex {
|
||||
s = &s[..i];
|
||||
}
|
||||
}
|
||||
|
||||
// Validate the symbol. If it doesn't look like anything we're
|
||||
// expecting, we just print it literally. Note that we must handle non-rust
|
||||
// symbols because we could have any function in the backtrace.
|
||||
let mut valid = true;
|
||||
let mut inner = s;
|
||||
if s.len() > 4 && s.starts_with("_ZN") && s.ends_with("E") {
|
||||
inner = &s[3 .. s.len() - 1];
|
||||
// On Windows, dbghelp strips leading underscores, so we accept "ZN...E" form too.
|
||||
} else if s.len() > 3 && s.starts_with("ZN") && s.ends_with("E") {
|
||||
inner = &s[2 .. s.len() - 1];
|
||||
} else {
|
||||
valid = false;
|
||||
}
|
||||
|
||||
if valid {
|
||||
let mut chars = inner.chars();
|
||||
while valid {
|
||||
let mut i = 0;
|
||||
for c in chars.by_ref() {
|
||||
if c.is_numeric() {
|
||||
i = i * 10 + c as usize - '0' as usize;
|
||||
} else {
|
||||
break
|
||||
}
|
||||
}
|
||||
if i == 0 {
|
||||
valid = chars.next().is_none();
|
||||
break
|
||||
} else if chars.by_ref().take(i - 1).count() != i - 1 {
|
||||
valid = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Alright, let's do this.
|
||||
if !valid {
|
||||
writer.write_all(s.as_bytes())?;
|
||||
} else {
|
||||
// remove the `::hfc2edb670e5eda97` part at the end of the symbol.
|
||||
if format == PrintFormat::Short {
|
||||
// The symbol in still mangled.
|
||||
let mut split = inner.rsplitn(2, "17h");
|
||||
match (split.next(), split.next()) {
|
||||
(Some(addr), rest) => {
|
||||
if addr.len() == 16 &&
|
||||
addr.chars().all(|c| c.is_digit(16))
|
||||
{
|
||||
inner = rest.unwrap_or("");
|
||||
}
|
||||
}
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
|
||||
let mut first = true;
|
||||
while !inner.is_empty() {
|
||||
if !first {
|
||||
writer.write_all(b"::")?;
|
||||
} else {
|
||||
first = false;
|
||||
}
|
||||
let mut rest = inner;
|
||||
while rest.chars().next().unwrap().is_numeric() {
|
||||
rest = &rest[1..];
|
||||
}
|
||||
let i: usize = inner[.. (inner.len() - rest.len())].parse().unwrap();
|
||||
inner = &rest[i..];
|
||||
rest = &rest[..i];
|
||||
if rest.starts_with("_$") {
|
||||
rest = &rest[1..];
|
||||
}
|
||||
while !rest.is_empty() {
|
||||
if rest.starts_with(".") {
|
||||
if let Some('.') = rest[1..].chars().next() {
|
||||
writer.write_all(b"::")?;
|
||||
rest = &rest[2..];
|
||||
} else {
|
||||
writer.write_all(b".")?;
|
||||
rest = &rest[1..];
|
||||
}
|
||||
} else if rest.starts_with("$") {
|
||||
macro_rules! demangle {
|
||||
($($pat:expr => $demangled:expr),*) => ({
|
||||
$(if rest.starts_with($pat) {
|
||||
writer.write_all($demangled)?;
|
||||
rest = &rest[$pat.len()..];
|
||||
} else)*
|
||||
{
|
||||
writer.write_all(rest.as_bytes())?;
|
||||
break;
|
||||
}
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
// see src/librustc/back/link.rs for these mappings
|
||||
demangle! (
|
||||
"$SP$" => b"@",
|
||||
"$BP$" => b"*",
|
||||
"$RF$" => b"&",
|
||||
"$LT$" => b"<",
|
||||
"$GT$" => b">",
|
||||
"$LP$" => b"(",
|
||||
"$RP$" => b")",
|
||||
"$C$" => b",",
|
||||
|
||||
// in theory we can demangle any Unicode code point, but
|
||||
// for simplicity we just catch the common ones.
|
||||
"$u7e$" => b"~",
|
||||
"$u20$" => b" ",
|
||||
"$u27$" => b"'",
|
||||
"$u5b$" => b"[",
|
||||
"$u5d$" => b"]",
|
||||
"$u7b$" => b"{",
|
||||
"$u7d$" => b"}",
|
||||
"$u3b$" => b";",
|
||||
"$u2b$" => b"+",
|
||||
"$u22$" => b"\""
|
||||
)
|
||||
} else {
|
||||
let idx = match rest.char_indices().find(|&(_, c)| c == '$' || c == '.') {
|
||||
None => rest.len(),
|
||||
Some((i, _)) => i,
|
||||
};
|
||||
writer.write_all(rest[..idx].as_bytes())?;
|
||||
rest = &rest[idx..];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use sys_common;
|
||||
macro_rules! t { ($a:expr, $b:expr) => ({
|
||||
let mut m = Vec::new();
|
||||
sys_common::backtrace::demangle(&mut m,
|
||||
$a,
|
||||
super::PrintFormat::Full).unwrap();
|
||||
assert_eq!(String::from_utf8(m).unwrap(), $b);
|
||||
}) }
|
||||
|
||||
#[test]
|
||||
fn demangle() {
|
||||
t!("test", "test");
|
||||
t!("_ZN4testE", "test");
|
||||
t!("_ZN4test", "_ZN4test");
|
||||
t!("_ZN4test1a2bcE", "test::a::bc");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn demangle_dollars() {
|
||||
t!("_ZN4$RP$E", ")");
|
||||
t!("_ZN8$RF$testE", "&test");
|
||||
t!("_ZN8$BP$test4foobE", "*test::foob");
|
||||
t!("_ZN9$u20$test4foobE", " test::foob");
|
||||
t!("_ZN35Bar$LT$$u5b$u32$u3b$$u20$4$u5d$$GT$E", "Bar<[u32; 4]>");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn demangle_many_dollars() {
|
||||
t!("_ZN13test$u20$test4foobE", "test test::foob");
|
||||
t!("_ZN12test$BP$test4foobE", "test*test::foob");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn demangle_windows() {
|
||||
t!("ZN4testE", "test");
|
||||
t!("ZN13test$u20$test4foobE", "test test::foob");
|
||||
t!("ZN12test$RF$test4foobE", "test&test::foob");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn demangle_elements_beginning_with_underscore() {
|
||||
t!("_ZN13_$LT$test$GT$E", "<test>");
|
||||
t!("_ZN28_$u7b$$u7b$closure$u7d$$u7d$E", "{{closure}}");
|
||||
t!("_ZN15__STATIC_FMTSTRE", "__STATIC_FMTSTR");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn demangle_trait_impls() {
|
||||
t!("_ZN71_$LT$Test$u20$$u2b$$u20$$u27$static$u20$as$u20$foo..Bar$LT$Test$GT$$GT$3barE",
|
||||
"<Test + 'static as foo::Bar<Test>>::bar");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue