Provide filename/line number information in Trap (#2452)

* Provide filename/line number information in `Trap`

This commit extends the `Trap` type and `Store` to retain DWARF debug
information found in a wasm file unconditionally, if it's present. This
then enables us to print filenames and line numbers which point back to
actual source code when a trap backtrace is printed. Additionally the
`FrameInfo` type has been souped up to return filename/line number
information as well.

The implementation here is pretty simplistic currently. The meat of all
the work happens in `gimli` and `addr2line`, and otherwise wasmtime is
just schlepping around bytes of dwarf debuginfo here and there!

The general goal here is to assist with debugging when using wasmtime
because filenames and line numbers are generally orders of magnitude
better even when you already have a stack trace. Another nicety here is
that backtraces will display inlined frames (learned through debug
information), improving the experience in release mode as well.

An example of this is that with this file:

```rust
fn main() {
    panic!("hello");
}
```

we get this stack trace:

```
$ rustc foo.rs --target wasm32-wasi -g
$ cargo run foo.wasm
    Finished dev [unoptimized + debuginfo] target(s) in 0.16s
     Running `target/debug/wasmtime foo.wasm`
thread 'main' panicked at 'hello', foo.rs:2:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Error: failed to run main module `foo.wasm`

Caused by:
    0: failed to invoke command default
    1: wasm trap: unreachable
       wasm backtrace:
           0: 0x6c1c - panic_abort::__rust_start_panic::abort::h2d60298621b1ccbf
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/panic_abort/src/lib.rs:77:17
                     - __rust_start_panic
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/panic_abort/src/lib.rs:32:5
           1: 0x68c7 - rust_panic
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/std/src/panicking.rs:626:9
           2: 0x65a1 - std::panicking::rust_panic_with_hook::h2345fb0909b53e12
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/std/src/panicking.rs:596:5
           3: 0x1436 - std::panicking::begin_panic::{{closure}}::h106f151a6db8c8fb
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/std/src/panicking.rs:506:9
           4:  0xda8 - std::sys_common::backtrace::__rust_end_short_backtrace::he55aa13f22782798
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/std/src/sys_common/backtrace.rs:153:18
           5: 0x1324 - std::panicking::begin_panic::h1727e7d1d719c76f
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/std/src/panicking.rs:505:12
           6:  0xfde - foo::main::h2db1313a64510850
                           at /Users/acrichton/code/wasmtime/foo.rs:2:5
           7: 0x11d5 - core::ops::function::FnOnce::call_once::h20ee1cc04aeff1fc
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/core/src/ops/function.rs:227:5
           8:  0xddf - std::sys_common::backtrace::__rust_begin_short_backtrace::h054493e41e27e69c
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/std/src/sys_common/backtrace.rs:137:18
           9: 0x1d5a - std::rt::lang_start::{{closure}}::hd83784448d3fcb42
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/std/src/rt.rs:66:18
          10: 0x69d8 - core::ops::function::impls::<impl core::ops::function::FnOnce<A> for &F>::call_once::h564d3dad35014917
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/core/src/ops/function.rs:259:13
                     - std::panicking::try::do_call::hdca4832ace5a8603
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/std/src/panicking.rs:381:40
                     - std::panicking::try::ha8624a1a6854b456
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/std/src/panicking.rs:345:19
                     - std::panic::catch_unwind::h71421f57cf2bc688
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/std/src/panic.rs:382:14
                     - std::rt::lang_start_internal::h260050c92cd470af
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/std/src/rt.rs:51:25
          11: 0x1d0c - std::rt::lang_start::h0b4bcf3c5e498224
                           at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/std/src/rt.rs:65:5
          12:  0xffc - <unknown>!__original_main
          13:  0x393 - __muloti4
                           at /cargo/registry/src/github.com-1ecc6299db9ec823/compiler_builtins-0.1.35/src/macros.rs:269
```

This is relatively noisy by default but there's filenames and line
numbers! Additionally frame 10 can be seen to have lots of frames
inlined into it. All information is always available to the embedder but
we could try to handle the `__rust_begin_short_backtrace` and
`__rust_end_short_backtrace` markers to trim the backtrace by default as
well.

The only gotcha here is that it looks like `__muloti4` is out of place.
That's because the libc that Rust ships with doesn't have dwarf
information, although I'm not sure why we land in that function for
symbolizing it...

* Add a configuration switch for debuginfo

* Control debuginfo by default with `WASM_BACKTRACE_DETAILS`

* Try cpp_demangle on demangling as well

* Rename to WASMTIME_BACKTRACE_DETAILS

crates/jit/Cargo.toml

@@ -36,6 +36,7 @@ log = "0.4"
 gimli = { version = "0.23.0", default-features = false, features = ["write"] }
 object = { version = "0.22.0", default-features = false, features = ["write"] }
 serde = { version = "1.0.94", features = ["derive"] }
+addr2line = { version = "0.14", default-features = false }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 winapi = { version = "0.3.8", features = ["winnt", "impl-default"] }

crates/jit/src/compiler.rs

@@ -139,7 +139,7 @@ impl Compiler {
             .into_iter()
             .collect::<CompiledFunctions>();
 
-        let dwarf_sections = if self.tunables.debug_info && !funcs.is_empty() {
+        let dwarf_sections = if self.tunables.generate_native_debuginfo && !funcs.is_empty() {
             transform_dwarf_data(
                 &*self.isa,
                 &translation.module,

crates/jit/src/instantiate.rs

@@ -12,6 +12,7 @@ use object::File as ObjectFile;
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 use std::any::Any;
+use std::ops::Range;
 use std::sync::Arc;
 use thiserror::Error;
 use wasmtime_debug::create_gdbjit_image;
@@ -19,8 +20,8 @@ use wasmtime_environ::entity::PrimaryMap;
 use wasmtime_environ::isa::TargetIsa;
 use wasmtime_environ::wasm::{DefinedFuncIndex, ModuleIndex, SignatureIndex};
 use wasmtime_environ::{
-    CompileError, DataInitializer, DataInitializerLocation, FunctionAddressMap, Module,
-    ModuleEnvironment, ModuleTranslation, StackMapInformation, TrapInformation,
+    CompileError, DataInitializer, DataInitializerLocation, DebugInfoData, FunctionAddressMap,
+    Module, ModuleEnvironment, ModuleTranslation, StackMapInformation, TrapInformation,
 };
 use wasmtime_profiling::ProfilingAgent;
 use wasmtime_runtime::{
@@ -69,12 +70,35 @@ pub struct CompilationArtifacts {
     /// Descriptions of compiled functions
     funcs: PrimaryMap<DefinedFuncIndex, FunctionInfo>,
 
-    /// Debug info presence flags.
-    debug_info: bool,
-
     /// Where to find this module's submodule code in the top-level list of
     /// modules.
     submodules: PrimaryMap<ModuleIndex, usize>,
+
+    /// Whether or not native debug information is available in `obj`
+    native_debug_info_present: bool,
+
+    /// Whether or not the original wasm module contained debug information that
+    /// we skipped and did not parse.
+    has_unparsed_debuginfo: bool,
+
+    /// Debug information found in the wasm file, used for symbolicating
+    /// backtraces.
+    debug_info: Option<DebugInfo>,
+}
+
+#[derive(Serialize, Deserialize)]
+struct DebugInfo {
+    data: Box<[u8]>,
+    code_section_offset: u64,
+    debug_abbrev: Range<usize>,
+    debug_addr: Range<usize>,
+    debug_info: Range<usize>,
+    debug_line: Range<usize>,
+    debug_line_str: Range<usize>,
+    debug_ranges: Range<usize>,
+    debug_rnglists: Range<usize>,
+    debug_str: Range<usize>,
+    debug_str_offsets: Range<usize>,
 }
 
 impl CompilationArtifacts {
@@ -103,6 +127,8 @@ impl CompilationArtifacts {
                     module,
                     data_initializers,
                     submodules,
+                    debuginfo,
+                    has_unparsed_debuginfo,
                     ..
                 } = translation;
 
@@ -132,7 +158,13 @@ impl CompilationArtifacts {
                             address_map: func.address_map,
                         })
                         .collect(),
-                    debug_info: compiler.tunables().debug_info,
+                    native_debug_info_present: compiler.tunables().generate_native_debuginfo,
+                    debug_info: if compiler.tunables().parse_wasm_debuginfo {
+                        Some(debuginfo.into())
+                    } else {
+                        None
+                    },
+                    has_unparsed_debuginfo,
                 })
             })
             .collect::<Result<Vec<_>, SetupError>>()
@@ -202,7 +234,7 @@ impl CompiledModule {
         })?;
 
         // Register GDB JIT images; initialize profiler and load the wasm module.
-        let dbg_jit_registration = if artifacts.debug_info {
+        let dbg_jit_registration = if artifacts.native_debug_info_present {
             let bytes = create_dbg_image(
                 artifacts.obj.to_vec(),
                 code_range,
@@ -348,6 +380,85 @@ impl CompiledModule {
     pub fn submodule_idx(&self, idx: ModuleIndex) -> usize {
         self.artifacts.submodules[idx]
     }
+
+    /// Creates a new symbolication context which can be used to further
+    /// symbolicate stack traces.
+    ///
+    /// Basically this makes a thing which parses debuginfo and can tell you
+    /// what filename and line number a wasm pc comes from.
+    pub fn symbolize_context(&self) -> Result<Option<SymbolizeContext>, gimli::Error> {
+        use gimli::EndianSlice;
+        let info = match &self.artifacts.debug_info {
+            Some(info) => info,
+            None => return Ok(None),
+        };
+        // For now we clone the data into the `SymbolizeContext`, but if this
+        // becomes prohibitive we could always `Arc` it with our own allocation
+        // here.
+        let data = info.data.clone();
+        let endian = gimli::LittleEndian;
+        let cx = addr2line::Context::from_sections(
+            EndianSlice::new(&data[info.debug_abbrev.clone()], endian).into(),
+            EndianSlice::new(&data[info.debug_addr.clone()], endian).into(),
+            EndianSlice::new(&data[info.debug_info.clone()], endian).into(),
+            EndianSlice::new(&data[info.debug_line.clone()], endian).into(),
+            EndianSlice::new(&data[info.debug_line_str.clone()], endian).into(),
+            EndianSlice::new(&data[info.debug_ranges.clone()], endian).into(),
+            EndianSlice::new(&data[info.debug_rnglists.clone()], endian).into(),
+            EndianSlice::new(&data[info.debug_str.clone()], endian).into(),
+            EndianSlice::new(&data[info.debug_str_offsets.clone()], endian).into(),
+            EndianSlice::new(&[], endian),
+        )?;
+        Ok(Some(SymbolizeContext {
+            // See comments on `SymbolizeContext` for why we do this static
+            // lifetime promotion.
+            inner: unsafe {
+                std::mem::transmute::<Addr2LineContext<'_>, Addr2LineContext<'static>>(cx)
+            },
+            code_section_offset: info.code_section_offset,
+            _data: data,
+        }))
+    }
+
+    /// Returns whether the original wasm module had unparsed debug information
+    /// based on the tunables configuration.
+    pub fn has_unparsed_debuginfo(&self) -> bool {
+        self.artifacts.has_unparsed_debuginfo
+    }
+}
+
+type Addr2LineContext<'a> = addr2line::Context<gimli::EndianSlice<'a, gimli::LittleEndian>>;
+
+/// A context which contains dwarf debug information to translate program
+/// counters back to filenames and line numbers.
+pub struct SymbolizeContext {
+    // Note the `'static` lifetime on `inner`. That's actually a bunch of slices
+    // which point back into the `_data` field. We currently unsafely manage
+    // this by saying that when inside the struct it's `'static` (since we own
+    // the referenced data just next to it) and we only loan out borrowed
+    // references.
+    _data: Box<[u8]>,
+    inner: Addr2LineContext<'static>,
+    code_section_offset: u64,
+}
+
+impl SymbolizeContext {
+    /// Returns access to the [`addr2line::Context`] which can be used to query
+    /// frame information with.
+    pub fn addr2line(&self) -> &Addr2LineContext<'_> {
+        // Here we demote our synthetic `'static` lifetime which doesn't
+        // actually exist back to a lifetime that's tied to `&self`, which
+        // should be safe.
+        unsafe {
+            std::mem::transmute::<&Addr2LineContext<'static>, &Addr2LineContext<'_>>(&self.inner)
+        }
+    }
+
+    /// Returns the offset of the code section in the original wasm file, used
+    /// to calculate lookup values into the DWARF.
+    pub fn code_section_offset(&self) -> u64 {
+        self.code_section_offset
+    }
 }
 
 /// Similar to `DataInitializer`, but owns its own copy of the data rather
@@ -432,3 +543,37 @@ fn build_code_memory(
 
     Ok((code_memory, code_range, finished_functions, trampolines))
 }
+
+impl From<DebugInfoData<'_>> for DebugInfo {
+    fn from(raw: DebugInfoData<'_>) -> DebugInfo {
+        use gimli::Section;
+
+        let mut data = Vec::new();
+        let mut push = |section: &[u8]| {
+            data.extend_from_slice(section);
+            data.len() - section.len()..data.len()
+        };
+        let debug_abbrev = push(raw.dwarf.debug_abbrev.reader().slice());
+        let debug_addr = push(raw.dwarf.debug_addr.reader().slice());
+        let debug_info = push(raw.dwarf.debug_info.reader().slice());
+        let debug_line = push(raw.dwarf.debug_line.reader().slice());
+        let debug_line_str = push(raw.dwarf.debug_line_str.reader().slice());
+        let debug_ranges = push(raw.debug_ranges.reader().slice());
+        let debug_rnglists = push(raw.debug_rnglists.reader().slice());
+        let debug_str = push(raw.dwarf.debug_str.reader().slice());
+        let debug_str_offsets = push(raw.dwarf.debug_str_offsets.reader().slice());
+        DebugInfo {
+            data: data.into(),
+            debug_abbrev,
+            debug_addr,
+            debug_info,
+            debug_line,
+            debug_line_str,
+            debug_ranges,
+            debug_rnglists,
+            debug_str,
+            debug_str_offsets,
+            code_section_offset: raw.wasm_file.code_section_offset,
+        }
+    }
+}

crates/jit/src/lib.rs

@@ -46,7 +46,9 @@ pub mod trampoline;
 
 pub use crate::code_memory::CodeMemory;
 pub use crate::compiler::{Compilation, CompilationStrategy, Compiler};
-pub use crate::instantiate::{CompilationArtifacts, CompiledModule, ModuleCode, SetupError};
+pub use crate::instantiate::{
+    CompilationArtifacts, CompiledModule, ModuleCode, SetupError, SymbolizeContext,
+};
 pub use crate::link::link_module;
 
 /// Version number of this crate.