src/libstd/rt/backtrace.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Simple backtrace functionality (to print on failure)
  12
  13 #![allow(non_camel_case_types)]
  14
  15 use char::Char;
  16 use container::Container;
  17 use from_str::from_str;
  18 use io::{IoResult, Writer};
  19 use iter::Iterator;
  20 use option::{Some, None};
  21 use os;
  22 use result::{Ok, Err};
  23 use str::StrSlice;
  24 use sync::atomics;
  25
  26 pub use self::imp::write;
  27
  28 // For now logging is turned off by default, and this function checks to see
  29 // whether the magical environment variable is present to see if it's turned on.
  30 pub fn log_enabled() -> bool {
  31     static mut ENABLED: atomics::AtomicInt = atomics::INIT_ATOMIC_INT;
  32     unsafe {
  33         match ENABLED.load(atomics::SeqCst) {
  34             1 => return false,
  35             2 => return true,
  36             _ => {}
  37         }
  38     }
  39
  40     let val = match os::getenv("RUST_BACKTRACE") {
  41         Some(..) => 2,
  42         None => 1,
  43     };
  44     unsafe { ENABLED.store(val, atomics::SeqCst); }
  45     val == 2
  46 }
  47
  48 #[cfg(target_word_size = "64")] static HEX_WIDTH: uint = 18;
  49 #[cfg(target_word_size = "32")] static HEX_WIDTH: uint = 10;
  50
  51 // All rust symbols are in theory lists of "::"-separated identifiers. Some
  52 // assemblers, however, can't handle these characters in symbol names. To get
  53 // around this, we use C++-style mangling. The mangling method is:
  54 //
  55 // 1. Prefix the symbol with "_ZN"
  56 // 2. For each element of the path, emit the length plus the element
  57 // 3. End the path with "E"
  58 //
  59 // For example, "_ZN4testE" => "test" and "_ZN3foo3bar" => "foo::bar".
  60 //
  61 // We're the ones printing our backtraces, so we can't rely on anything else to
  62 // demangle our symbols. It's *much* nicer to look at demangled symbols, so
  63 // this function is implemented to give us nice pretty output.
  64 //
  65 // Note that this demangler isn't quite as fancy as it could be. We have lots
  66 // of other information in our symbols like hashes, version, type information,
  67 // etc. Additionally, this doesn't handle glue symbols at all.
  68 fn demangle(writer: &mut Writer, s: &str) -> IoResult<()> {
  69     // First validate the symbol. If it doesn't look like anything we're
  70     // expecting, we just print it literally. Note that we must handle non-rust
  71     // symbols because we could have any function in the backtrace.
  72     let mut valid = true;
  73     if s.len() > 4 && s.starts_with("_ZN") && s.ends_with("E") {
  74         let mut chars = s.slice(3, s.len() - 1).chars();
  75         while valid {
  76             let mut i = 0;
  77             for c in chars {
  78                 if c.is_digit() {
  79                     i = i * 10 + c as uint - '0' as uint;
  80                 } else {
  81                     break
  82                 }
  83             }
  84             if i == 0 {
  85                 valid = chars.next().is_none();
  86                 break
  87             } else if chars.by_ref().take(i - 1).len() != i - 1 {
  88                 valid = false;
  89             }
  90         }
  91     } else {
  92         valid = false;
  93     }
  94
  95     // Alright, let's do this.
  96     if !valid {
  97         try!(writer.write_str(s));
  98     } else {
  99         let mut s = s.slice_from(3);
 100         let mut first = true;
 101         while s.len() > 1 {
 102             if !first {
 103                 try!(writer.write_str("::"));
 104             } else {
 105                 first = false;
 106             }
 107             let mut rest = s;
 108             while rest.char_at(0).is_digit() {
 109                 rest = rest.slice_from(1);
 110             }
 111             let i: uint = from_str(s.slice_to(s.len() - rest.len())).unwrap();
 112             s = rest.slice_from(i);
 113             rest = rest.slice_to(i);
 114             while rest.len() > 0 {
 115                 if rest.starts_with("$") {
 116                     macro_rules! demangle(
 117                         ($($pat:expr => $demangled:expr),*) => ({
 118                             $(if rest.starts_with($pat) {
 119                                 try!(writer.write_str($demangled));
 120                                 rest = rest.slice_from($pat.len());
 121                               } else)*
 122                             {
 123                                 try!(writer.write_str(rest));
 124                                 break;
 125                             }
 126
 127                         })
 128                     )
 129                     // see src/librustc/back/link.rs for these mappings
 130                     demangle! (
 131                         "$SP$" => "@",
 132                         "$UP$" => "Box",
 133                         "$RP$" => "*",
 134                         "$BP$" => "&",
 135                         "$LT$" => "<",
 136                         "$GT$" => ">",
 137                         "$LP$" => "(",
 138                         "$RP$" => ")",
 139                         "$C$"  => ",",
 140
 141                         // in theory we can demangle any unicode code point, but
 142                         // for simplicity we just catch the common ones.
 143                         "$x20" => " ",
 144                         "$x27" => "'",
 145                         "$x5b" => "[",
 146                         "$x5d" => "]"
 147                     )
 148                 } else {
 149                     let idx = match rest.find('$') {
 150                         None => rest.len(),
 151                         Some(i) => i,
 152                     };
 153                     try!(writer.write_str(rest.slice_to(idx)));
 154                     rest = rest.slice_from(idx);
 155                 }
 156             }
 157         }
 158     }
 159
 160     Ok(())
 161 }
 162
 163 /// Backtrace support built on libgcc with some extra OS-specific support
 164 ///
 165 /// Some methods of getting a backtrace:
 166 ///
 167 /// * The backtrace() functions on unix. It turns out this doesn't work very
 168 ///   well for green threads on OSX, and the address to symbol portion of it
 169 ///   suffers problems that are described below.
 170 ///
 171 /// * Using libunwind. This is more difficult than it sounds because libunwind
 172 ///   isn't installed everywhere by default. It's also a bit of a hefty library,
 173 ///   so possibly not the best option. When testing, libunwind was excellent at
 174 ///   getting both accurate backtraces and accurate symbols across platforms.
 175 ///   This route was not chosen in favor of the next option, however.
 176 ///
 177 /// * We're already using libgcc_s for exceptions in rust (triggering task
 178 ///   unwinding and running destructors on the stack), and it turns out that it
 179 ///   conveniently comes with a function that also gives us a backtrace. All of
 180 ///   these functions look like _Unwind_*, but it's not quite the full
 181 ///   repertoire of the libunwind API. Due to it already being in use, this was
 182 ///   the chosen route of getting a backtrace.
 183 ///
 184 /// After choosing libgcc_s for backtraces, the sad part is that it will only
 185 /// give us a stack trace of instruction pointers. Thankfully these instruction
 186 /// pointers are accurate (they work for green and native threads), but it's
 187 /// then up to us again to figure out how to translate these addresses to
 188 /// symbols. As with before, we have a few options. Before, that, a little bit
 189 /// of an interlude about symbols. This is my very limited knowledge about
 190 /// symbol tables, and this information is likely slightly wrong, but the
 191 /// general idea should be correct.
 192 ///
 193 /// When talking about symbols, it's helpful to know a few things about where
 194 /// symbols are located. Some symbols are located in the dynamic symbol table
 195 /// of the executable which in theory means that they're available for dynamic
 196 /// linking and lookup. Other symbols end up only in the local symbol table of
 197 /// the file. This loosely corresponds to pub and priv functions in Rust.
 198 ///
 199 /// Armed with this knowledge, we know that our solution for address to symbol
 200 /// translation will need to consult both the local and dynamic symbol tables.
 201 /// With that in mind, here's our options of translating an address to
 202 /// a symbol.
 203 ///
 204 /// * Use dladdr(). The original backtrace()-based idea actually uses dladdr()
 205 ///   behind the scenes to translate, and this is why backtrace() was not used.
 206 ///   Conveniently, this method works fantastically on OSX. It appears dladdr()
 207 ///   uses magic to consult the local symbol table, or we're putting everything
 208 ///   in the dynamic symbol table anyway. Regardless, for OSX, this is the
 209 ///   method used for translation. It's provided by the system and easy to do.o
 210 ///
 211 ///   Sadly, all other systems have a dladdr() implementation that does not
 212 ///   consult the local symbol table. This means that most functions are blank
 213 ///   because they don't have symbols. This means that we need another solution.
 214 ///
 215 /// * Use unw_get_proc_name(). This is part of the libunwind api (not the
 216 ///   libgcc_s version of the libunwind api), but involves taking a dependency
 217 ///   to libunwind. We may pursue this route in the future if we bundle
 218 ///   libunwind, but libunwind was unwieldy enough that it was not chosen at
 219 ///   this time to provide this functionality.
 220 ///
 221 /// * Shell out to a utility like `readelf`. Crazy though it may sound, it's a
 222 ///   semi-reasonable solution. The stdlib already knows how to spawn processes,
 223 ///   so in theory it could invoke readelf, parse the output, and consult the
 224 ///   local/dynamic symbol tables from there. This ended up not getting chosen
 225 ///   due to the craziness of the idea plus the advent of the next option.
 226 ///
 227 /// * Use `libbacktrace`. It turns out that this is a small library bundled in
 228 ///   the gcc repository which provides backtrace and symbol translation
 229 ///   functionality. All we really need from it is the backtrace functionality,
 230 ///   and we only really need this on everything that's not OSX, so this is the
 231 ///   chosen route for now.
 232 ///
 233 /// In summary, the current situation uses libgcc_s to get a trace of stack
 234 /// pointers, and we use dladdr() or libbacktrace to translate these addresses
 235 /// to symbols. This is a bit of a hokey implementation as-is, but it works for
 236 /// all unix platforms we support right now, so it at least gets the job done.
 237 #[cfg(unix)]
 238 mod imp {
 239     use c_str::CString;
 240     use cast;
 241     use io::{IoResult, IoError, Writer};
 242     use libc;
 243     use option::{Some, None, Option};
 244     use result::{Ok, Err};
 245     use unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
 246     use uw = rt::libunwind;
 247
 248     struct Context<'a> {
 249         idx: int,
 250         writer: &'a mut Writer,
 251         last_error: Option<IoError>,
 252     }
 253
 254     #[inline(never)] // if we know this is a function call, we can skip it when
 255                      // tracing
 256     pub fn write(w: &mut Writer) -> IoResult<()> {
 257         // When using libbacktrace, we use some necessary global state, so we
 258         // need to prevent more than one thread from entering this block. This
 259         // is semi-reasonable in terms of printing anyway, and we know that all
 260         // I/O done here is blocking I/O, not green I/O, so we don't have to
 261         // worry about this being a native vs green mutex.
 262         static mut LOCK: StaticNativeMutex = NATIVE_MUTEX_INIT;
 263         let _g = unsafe { LOCK.lock() };
 264
 265         try!(writeln!(w, "stack backtrace:"));
 266
 267         let mut cx = Context { writer: w, last_error: None, idx: 0 };
 268         return match unsafe {
 269             uw::_Unwind_Backtrace(trace_fn,
 270                                   &mut cx as *mut Context as *libc::c_void)
 271         } {
 272             uw::_URC_NO_REASON => {
 273                 match cx.last_error {
 274                     Some(err) => Err(err),
 275                     None => Ok(())
 276                 }
 277             }
 278             _ => Ok(()),
 279         };
 280
 281         extern fn trace_fn(ctx: *uw::_Unwind_Context,
 282                            arg: *libc::c_void) -> uw::_Unwind_Reason_Code {
 283             let cx: &mut Context = unsafe { cast::transmute(arg) };
 284             let ip = unsafe { uw::_Unwind_GetIP(ctx) as *libc::c_void };
 285             // dladdr() on osx gets whiny when we use FindEnclosingFunction, and
 286             // it appears to work fine without it, so we only use
 287             // FindEnclosingFunction on non-osx platforms. In doing so, we get a
 288             // slightly more accurate stack trace in the process.
 289             //
 290             // This is often because failure involves the last instruction of a
 291             // function being "call std::rt::begin_unwind", with no ret
 292             // instructions after it. This means that the return instruction
 293             // pointer points *outside* of the calling function, and by
 294             // unwinding it we go back to the original function.
 295             let ip = if cfg!(target_os = "macos") {
 296                 ip
 297             } else {
 298                 unsafe { uw::_Unwind_FindEnclosingFunction(ip) }
 299             };
 300
 301             // Don't print out the first few frames (they're not user frames)
 302             cx.idx += 1;
 303             if cx.idx <= 0 { return uw::_URC_NO_REASON }
 304             // Don't print ginormous backtraces
 305             if cx.idx > 100 {
 306                 match write!(cx.writer, " ... <frames omitted>\n") {
 307                     Ok(()) => {}
 308                     Err(e) => { cx.last_error = Some(e); }
 309                 }
 310                 return uw::_URC_FAILURE
 311             }
 312
 313             // Once we hit an error, stop trying to print more frames
 314             if cx.last_error.is_some() { return uw::_URC_FAILURE }
 315
 316             match print(cx.writer, cx.idx, ip) {
 317                 Ok(()) => {}
 318                 Err(e) => { cx.last_error = Some(e); }
 319             }
 320
 321             // keep going
 322             return uw::_URC_NO_REASON
 323         }
 324     }
 325
 326     #[cfg(target_os = "macos")]
 327     fn print(w: &mut Writer, idx: int, addr: *libc::c_void) -> IoResult<()> {
 328         use intrinsics;
 329         struct Dl_info {
 330             dli_fname: *libc::c_char,
 331             dli_fbase: *libc::c_void,
 332             dli_sname: *libc::c_char,
 333             dli_saddr: *libc::c_void,
 334         }
 335         extern {
 336             fn dladdr(addr: *libc::c_void,
 337                       info: *mut Dl_info) -> libc::c_int;
 338         }
 339
 340         let mut info: Dl_info = unsafe { intrinsics::init() };
 341         if unsafe { dladdr(addr, &mut info) == 0 } {
 342             output(w, idx,addr, None)
 343         } else {
 344             output(w, idx, addr, Some(unsafe {
 345                 CString::new(info.dli_sname, false)
 346             }))
 347         }
 348     }
 349
 350     #[cfg(not(target_os = "macos"))]
 351     fn print(w: &mut Writer, idx: int, addr: *libc::c_void) -> IoResult<()> {
 352         use container::Container;
 353         use iter::Iterator;
 354         use os;
 355         use path::GenericPath;
 356         use ptr::RawPtr;
 357         use ptr;
 358         use slice::{ImmutableVector, MutableVector};
 359
 360         ////////////////////////////////////////////////////////////////////////
 361         // libbacktrace.h API
 362         ////////////////////////////////////////////////////////////////////////
 363         type backtrace_syminfo_callback =
 364             extern "C" fn(data: *mut libc::c_void,
 365                           pc: libc::uintptr_t,
 366                           symname: *libc::c_char,
 367                           symval: libc::uintptr_t,
 368                           symsize: libc::uintptr_t);
 369         type backtrace_error_callback =
 370             extern "C" fn(data: *mut libc::c_void,
 371                           msg: *libc::c_char,
 372                           errnum: libc::c_int);
 373         enum backtrace_state {}
 374         #[link(name = "backtrace", kind = "static")]
 375         extern {
 376             fn backtrace_create_state(filename: *libc::c_char,
 377                                       threaded: libc::c_int,
 378                                       error: backtrace_error_callback,
 379                                       data: *mut libc::c_void)
 380                                             -> *mut backtrace_state;
 381             fn backtrace_syminfo(state: *mut backtrace_state,
 382                                  addr: libc::uintptr_t,
 383                                  cb: backtrace_syminfo_callback,
 384                                  error: backtrace_error_callback,
 385                                  data: *mut libc::c_void) -> libc::c_int;
 386         }
 387
 388         ////////////////////////////////////////////////////////////////////////
 389         // helper callbacks
 390         ////////////////////////////////////////////////////////////////////////
 391
 392         extern fn error_cb(_data: *mut libc::c_void, _msg: *libc::c_char,
 393                            _errnum: libc::c_int) {
 394             // do nothing for now
 395         }
 396         extern fn syminfo_cb(data: *mut libc::c_void,
 397                              _pc: libc::uintptr_t,
 398                              symname: *libc::c_char,
 399                              _symval: libc::uintptr_t,
 400                              _symsize: libc::uintptr_t) {
 401             let slot = data as *mut *libc::c_char;
 402             unsafe { *slot = symname; }
 403         }
 404
 405         // The libbacktrace API supports creating a state, but it does not
 406         // support destroying a state. I personally take this to mean that a
 407         // state is meant to be created and then live forever.
 408         //
 409         // I would love to register an at_exit() handler which cleans up this
 410         // state, but libbacktrace provides no way to do so.
 411         //
 412         // With these constraints, this function has a statically cached state
 413         // that is calculated the first time this is requested. Remember that
 414         // backtracing all happens serially (one global lock).
 415         //
 416         // An additionally oddity in this function is that we initialize the
 417         // filename via self_exe_name() to pass to libbacktrace. It turns out
 418         // that on linux libbacktrace seamlessly gets the filename of the
 419         // current executable, but this fails on freebsd. by always providing
 420         // it, we make sure that libbacktrace never has a reason to not look up
 421         // the symbols. The libbacktrace API also states that the filename must
 422         // be in "permanent memory", so we copy it to a static and then use the
 423         // static as the pointer.
 424         unsafe fn init_state() -> *mut backtrace_state {
 425             static mut STATE: *mut backtrace_state = 0 as *mut backtrace_state;
 426             static mut LAST_FILENAME: [libc::c_char, ..256] = [0, ..256];
 427             if !STATE.is_null() { return STATE }
 428             let selfname = if cfg!(target_os = "freebsd") {
 429                 os::self_exe_name()
 430             } else {
 431                 None
 432             };
 433             let filename = match selfname {
 434                 Some(path) => {
 435                     let bytes = path.as_vec();
 436                     if bytes.len() < LAST_FILENAME.len() {
 437                         let i = bytes.iter();
 438                         for (slot, val) in LAST_FILENAME.mut_iter().zip(i) {
 439                             *slot = *val as libc::c_char;
 440                         }
 441                         LAST_FILENAME.as_ptr()
 442                     } else {
 443                         ptr::null()
 444                     }
 445                 }
 446                 None => ptr::null(),
 447             };
 448             STATE = backtrace_create_state(filename, 0, error_cb,
 449                                            ptr::mut_null());
 450             return STATE
 451         }
 452
 453         ////////////////////////////////////////////////////////////////////////
 454         // translation
 455         ////////////////////////////////////////////////////////////////////////
 456
 457         // backtrace errors are currently swept under the rug, only I/O
 458         // errors are reported
 459         let state = unsafe { init_state() };
 460         if state.is_null() {
 461             return output(w, idx, addr, None)
 462         }
 463         let mut data = 0 as *libc::c_char;
 464         let data_addr = &mut data as *mut *libc::c_char;
 465         let ret = unsafe {
 466             backtrace_syminfo(state, addr as libc::uintptr_t,
 467                               syminfo_cb, error_cb,
 468                               data_addr as *mut libc::c_void)
 469         };
 470         if ret == 0 || data.is_null() {
 471             output(w, idx, addr, None)
 472         } else {
 473             output(w, idx, addr, Some(unsafe { CString::new(data, false) }))
 474         }
 475     }
 476
 477     // Finally, after all that work above, we can emit a symbol.
 478     fn output(w: &mut Writer, idx: int, addr: *libc::c_void,
 479               s: Option<CString>) -> IoResult<()> {
 480         try!(write!(w, "  {:2}: {:2$} - ", idx, addr, super::HEX_WIDTH));
 481         match s.as_ref().and_then(|c| c.as_str()) {
 482             Some(string) => try!(super::demangle(w, string)),
 483             None => try!(write!(w, "<unknown>")),
 484         }
 485         w.write(['\n' as u8])
 486     }
 487 }
 488
 489 /// As always, windows has something very different than unix, we mainly want
 490 /// to avoid having to depend too much on libunwind for windows.
 491 ///
 492 /// If you google around, you'll find a fair bit of references to built-in
 493 /// functions to get backtraces on windows. It turns out that most of these are
 494 /// in an external library called dbghelp. I was unable to find this library
 495 /// via `-ldbghelp`, but it is apparently normal to do the `dlopen` equivalent
 496 /// of it.
 497 ///
 498 /// You'll also find that there's a function called CaptureStackBackTrace
 499 /// mentioned frequently (which is also easy to use), but sadly I didn't have a
 500 /// copy of that function in my mingw install (maybe it was broken?). Instead,
 501 /// this takes the route of using StackWalk64 in order to walk the stack.
 502 #[cfg(windows)]
 503 #[allow(dead_code, uppercase_variables)]
 504 mod imp {
 505     use c_str::CString;
 506     use container::Container;
 507     use io::{IoResult, Writer};
 508     use iter::Iterator;
 509     use libc;
 510     use mem;
 511     use ops::Drop;
 512     use option::{Some, None};
 513     use path::Path;
 514     use result::{Ok, Err};
 515     use str::StrSlice;
 516     use unstable::dynamic_lib::DynamicLibrary;
 517     use intrinsics;
 518     use unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
 519     use slice::ImmutableVector;
 520
 521     extern "system" {
 522         fn GetCurrentProcess() -> libc::HANDLE;
 523         fn GetCurrentThread() -> libc::HANDLE;
 524         fn RtlCaptureContext(ctx: *mut arch::CONTEXT);
 525     }
 526
 527     type SymFromAddrFn =
 528         extern "system" fn(libc::HANDLE, u64, *mut u64,
 529                            *mut SYMBOL_INFO) -> libc::BOOL;
 530     type SymInitializeFn =
 531         extern "system" fn(libc::HANDLE, *libc::c_void,
 532                            libc::BOOL) -> libc::BOOL;
 533     type SymCleanupFn =
 534         extern "system" fn(libc::HANDLE) -> libc::BOOL;
 535
 536     type StackWalk64Fn =
 537         extern "system" fn(libc::DWORD, libc::HANDLE, libc::HANDLE,
 538                            *mut STACKFRAME64, *mut arch::CONTEXT,
 539                            *libc::c_void, *libc::c_void,
 540                            *libc::c_void, *libc::c_void) -> libc::BOOL;
 541
 542     static MAX_SYM_NAME: uint = 2000;
 543     static IMAGE_FILE_MACHINE_I386: libc::DWORD = 0x014c;
 544     static IMAGE_FILE_MACHINE_IA64: libc::DWORD = 0x0200;
 545     static IMAGE_FILE_MACHINE_AMD64: libc::DWORD = 0x8664;
 546
 547     #[packed]
 548     struct SYMBOL_INFO {
 549         SizeOfStruct: libc::c_ulong,
 550         TypeIndex: libc::c_ulong,
 551         Reserved: [u64, ..2],
 552         Index: libc::c_ulong,
 553         Size: libc::c_ulong,
 554         ModBase: u64,
 555         Flags: libc::c_ulong,
 556         Value: u64,
 557         Address: u64,
 558         Register: libc::c_ulong,
 559         Scope: libc::c_ulong,
 560         Tag: libc::c_ulong,
 561         NameLen: libc::c_ulong,
 562         MaxNameLen: libc::c_ulong,
 563         // note that windows has this as 1, but it basically just means that
 564         // the name is inline at the end of the struct. For us, we just bump
 565         // the struct size up to MAX_SYM_NAME.
 566         Name: [libc::c_char, ..MAX_SYM_NAME],
 567     }
 568
 569     #[repr(C)]
 570     enum ADDRESS_MODE {
 571         AddrMode1616,
 572         AddrMode1632,
 573         AddrModeReal,
 574         AddrModeFlat,
 575     }
 576
 577     struct ADDRESS64 {
 578         Offset: u64,
 579         Segment: u16,
 580         Mode: ADDRESS_MODE,
 581     }
 582
 583     struct STACKFRAME64 {
 584         AddrPC: ADDRESS64,
 585         AddrReturn: ADDRESS64,
 586         AddrFrame: ADDRESS64,
 587         AddrStack: ADDRESS64,
 588         AddrBStore: ADDRESS64,
 589         FuncTableEntry: *libc::c_void,
 590         Params: [u64, ..4],
 591         Far: libc::BOOL,
 592         Virtual: libc::BOOL,
 593         Reserved: [u64, ..3],
 594         KdHelp: KDHELP64,
 595     }
 596
 597     struct KDHELP64 {
 598         Thread: u64,
 599         ThCallbackStack: libc::DWORD,
 600         ThCallbackBStore: libc::DWORD,
 601         NextCallback: libc::DWORD,
 602         FramePointer: libc::DWORD,
 603         KiCallUserMode: u64,
 604         KeUserCallbackDispatcher: u64,
 605         SystemRangeStart: u64,
 606         KiUserExceptionDispatcher: u64,
 607         StackBase: u64,
 608         StackLimit: u64,
 609         Reserved: [u64, ..5],
 610     }
 611
 612     #[cfg(target_arch = "x86")]
 613     mod arch {
 614         use libc;
 615
 616         static MAXIMUM_SUPPORTED_EXTENSION: uint = 512;
 617
 618         pub struct CONTEXT {
 619             ContextFlags: libc::DWORD,
 620             Dr0: libc::DWORD,
 621             Dr1: libc::DWORD,
 622             Dr2: libc::DWORD,
 623             Dr3: libc::DWORD,
 624             Dr6: libc::DWORD,
 625             Dr7: libc::DWORD,
 626             FloatSave: FLOATING_SAVE_AREA,
 627             SegGs: libc::DWORD,
 628             SegFs: libc::DWORD,
 629             SegEs: libc::DWORD,
 630             SegDs: libc::DWORD,
 631             Edi: libc::DWORD,
 632             Esi: libc::DWORD,
 633             Ebx: libc::DWORD,
 634             Edx: libc::DWORD,
 635             Ecx: libc::DWORD,
 636             Eax: libc::DWORD,
 637             Ebp: libc::DWORD,
 638             Eip: libc::DWORD,
 639             SegCs: libc::DWORD,
 640             EFlags: libc::DWORD,
 641             Esp: libc::DWORD,
 642             SegSs: libc::DWORD,
 643             ExtendedRegisters: [u8, ..MAXIMUM_SUPPORTED_EXTENSION],
 644         }
 645
 646         pub struct FLOATING_SAVE_AREA {
 647             ControlWord: libc::DWORD,
 648             StatusWord: libc::DWORD,
 649             TagWord: libc::DWORD,
 650             ErrorOffset: libc::DWORD,
 651             ErrorSelector: libc::DWORD,
 652             DataOffset: libc::DWORD,
 653             DataSelector: libc::DWORD,
 654             RegisterArea: [u8, ..80],
 655             Cr0NpxState: libc::DWORD,
 656         }
 657
 658         pub fn init_frame(frame: &mut super::STACKFRAME64,
 659                           ctx: &CONTEXT) -> libc::DWORD {
 660             frame.AddrPC.Offset = ctx.Eip as u64;
 661             frame.AddrPC.Mode = super::AddrModeFlat;
 662             frame.AddrStack.Offset = ctx.Esp as u64;
 663             frame.AddrStack.Mode = super::AddrModeFlat;
 664             frame.AddrFrame.Offset = ctx.Ebp as u64;
 665             frame.AddrFrame.Mode = super::AddrModeFlat;
 666             super::IMAGE_FILE_MACHINE_I386
 667         }
 668     }
 669
 670     #[cfg(target_arch = "x86_64")]
 671     mod arch {
 672         use libc::{c_longlong, c_ulonglong};
 673         use libc::types::os::arch::extra::{WORD, DWORD, DWORDLONG};
 674
 675         pub struct CONTEXT {
 676             P1Home: DWORDLONG,
 677             P2Home: DWORDLONG,
 678             P3Home: DWORDLONG,
 679             P4Home: DWORDLONG,
 680             P5Home: DWORDLONG,
 681             P6Home: DWORDLONG,
 682
 683             ContextFlags: DWORD,
 684             MxCsr: DWORD,
 685
 686             SegCs: WORD,
 687             SegDs: WORD,
 688             SegEs: WORD,
 689             SegFs: WORD,
 690             SegGs: WORD,
 691             SegSs: WORD,
 692             EFlags: DWORD,
 693
 694             Dr0: DWORDLONG,
 695             Dr1: DWORDLONG,
 696             Dr2: DWORDLONG,
 697             Dr3: DWORDLONG,
 698             Dr6: DWORDLONG,
 699             Dr7: DWORDLONG,
 700
 701             Rax: DWORDLONG,
 702             Rcx: DWORDLONG,
 703             Rdx: DWORDLONG,
 704             Rbx: DWORDLONG,
 705             Rsp: DWORDLONG,
 706             Rbp: DWORDLONG,
 707             Rsi: DWORDLONG,
 708             Rdi: DWORDLONG,
 709             R8:  DWORDLONG,
 710             R9:  DWORDLONG,
 711             R10: DWORDLONG,
 712             R11: DWORDLONG,
 713             R12: DWORDLONG,
 714             R13: DWORDLONG,
 715             R14: DWORDLONG,
 716             R15: DWORDLONG,
 717
 718             Rip: DWORDLONG,
 719
 720             FltSave: FLOATING_SAVE_AREA,
 721
 722             VectorRegister: [M128A, .. 26],
 723             VectorControl: DWORDLONG,
 724
 725             DebugControl: DWORDLONG,
 726             LastBranchToRip: DWORDLONG,
 727             LastBranchFromRip: DWORDLONG,
 728             LastExceptionToRip: DWORDLONG,
 729             LastExceptionFromRip: DWORDLONG,
 730         }
 731
 732         pub struct M128A {
 733             Low:  c_ulonglong,
 734             High: c_longlong
 735         }
 736
 737         pub struct FLOATING_SAVE_AREA {
 738             _Dummy: [u8, ..512] // FIXME: Fill this out
 739         }
 740
 741         pub fn init_frame(frame: &mut super::STACKFRAME64,
 742                           ctx: &CONTEXT) -> DWORD {
 743             frame.AddrPC.Offset = ctx.Rip as u64;
 744             frame.AddrPC.Mode = super::AddrModeFlat;
 745             frame.AddrStack.Offset = ctx.Rsp as u64;
 746             frame.AddrStack.Mode = super::AddrModeFlat;
 747             frame.AddrFrame.Offset = ctx.Rbp as u64;
 748             frame.AddrFrame.Mode = super::AddrModeFlat;
 749             super::IMAGE_FILE_MACHINE_AMD64
 750         }
 751     }
 752
 753     struct Cleanup {
 754         handle: libc::HANDLE,
 755         SymCleanup: SymCleanupFn,
 756     }
 757
 758     impl Drop for Cleanup {
 759         fn drop(&mut self) { (self.SymCleanup)(self.handle); }
 760     }
 761
 762     pub fn write(w: &mut Writer) -> IoResult<()> {
 763         // According to windows documentation, all dbghelp functions are
 764         // single-threaded.
 765         static mut LOCK: StaticNativeMutex = NATIVE_MUTEX_INIT;
 766         let _g = unsafe { LOCK.lock() };
 767
 768         // Open up dbghelp.dll, we don't link to it explicitly because it can't
 769         // always be found. Additionally, it's nice having fewer dependencies.
 770         let path = Path::new("dbghelp.dll");
 771         let lib = match DynamicLibrary::open(Some(&path)) {
 772             Ok(lib) => lib,
 773             Err(..) => return Ok(()),
 774         };
 775
 776         macro_rules! sym( ($e:expr, $t:ident) => (
 777             match unsafe { lib.symbol::<$t>($e) } {
 778                 Ok(f) => f,
 779                 Err(..) => return Ok(())
 780             }
 781         ) )
 782
 783         // Fetch the symbols necessary from dbghelp.dll
 784         let SymFromAddr = sym!("SymFromAddr", SymFromAddrFn);
 785         let SymInitialize = sym!("SymInitialize", SymInitializeFn);
 786         let SymCleanup = sym!("SymCleanup", SymCleanupFn);
 787         let StackWalk64 = sym!("StackWalk64", StackWalk64Fn);
 788
 789         // Allocate necessary structures for doing the stack walk
 790         let process = unsafe { GetCurrentProcess() };
 791         let thread = unsafe { GetCurrentThread() };
 792         let mut context: arch::CONTEXT = unsafe { intrinsics::init() };
 793         unsafe { RtlCaptureContext(&mut context); }
 794         let mut frame: STACKFRAME64 = unsafe { intrinsics::init() };
 795         let image = arch::init_frame(&mut frame, &context);
 796
 797         // Initialize this process's symbols
 798         let ret = SymInitialize(process, 0 as *libc::c_void, libc::TRUE);
 799         if ret != libc::TRUE { return Ok(()) }
 800         let _c = Cleanup { handle: process, SymCleanup: SymCleanup };
 801
 802         // And now that we're done with all the setup, do the stack walking!
 803         let mut i = 0;
 804         try!(write!(w, "stack backtrace:\n"));
 805         while StackWalk64(image, process, thread, &mut frame, &mut context,
 806                           0 as *libc::c_void, 0 as *libc::c_void,
 807                           0 as *libc::c_void, 0 as *libc::c_void) == libc::TRUE{
 808             let addr = frame.AddrPC.Offset;
 809             if addr == frame.AddrReturn.Offset || addr == 0 ||
 810                frame.AddrReturn.Offset == 0 { break }
 811
 812             i += 1;
 813             try!(write!(w, "  {:2}: {:#2$x}", i, addr, super::HEX_WIDTH));
 814             let mut info: SYMBOL_INFO = unsafe { intrinsics::init() };
 815             info.MaxNameLen = MAX_SYM_NAME as libc::c_ulong;
 816             info.SizeOfStruct = (mem::size_of::<SYMBOL_INFO>() -
 817                                  info.Name.len() + 1) as libc::c_ulong;
 818
 819             let mut displacement = 0u64;
 820             let ret = SymFromAddr(process, addr as u64, &mut displacement,
 821                                   &mut info);
 822
 823             if ret == libc::TRUE {
 824                 try!(write!(w, " - "));
 825                 let cstr = unsafe { CString::new(info.Name.as_ptr(), false) };
 826                 let bytes = cstr.as_bytes();
 827                 match cstr.as_str() {
 828                     Some(s) => try!(super::demangle(w, s)),
 829                     None => try!(w.write(bytes.slice_to(bytes.len() - 1))),
 830                 }
 831             }
 832             try!(w.write(['\n' as u8]));
 833         }
 834
 835         Ok(())
 836     }
 837 }
 838
 839 #[cfg(test)]
 840 mod test {
 841     use prelude::*;
 842     use io::MemWriter;
 843     use str;
 844
 845     macro_rules! t( ($a:expr, $b:expr) => ({
 846         let mut m = MemWriter::new();
 847         super::demangle(&mut m, $a).unwrap();
 848         assert_eq!(str::from_utf8(m.unwrap().as_slice()).unwrap().to_owned(), $b.to_owned());
 849     }) )
 850
 851     #[test]
 852     fn demangle() {
 853         t!("test", "test");
 854         t!("_ZN4testE", "test");
 855         t!("_ZN4test", "_ZN4test");
 856         t!("_ZN4test1a2bcE", "test::a::bc");
 857     }
 858
 859     #[test]
 860     fn demangle_dollars() {
 861         t!("_ZN4$UP$E", "Box");
 862         t!("_ZN8$UP$testE", "Boxtest");
 863         t!("_ZN8$UP$test4foobE", "Boxtest::foob");
 864         t!("_ZN8$x20test4foobE", " test::foob");
 865     }
 866
 867     #[test]
 868     fn demangle_many_dollars() {
 869         t!("_ZN12test$x20test4foobE", "test test::foob");
 870         t!("_ZN12test$UP$test4foobE", "testBoxtest::foob");
 871     }
 872 }