Add a --generate-dwarf[=true|false] flag to the wast subcommand (#10780)

This commit adds support for the `wast` subcommand to generate DWARF
debugging information for the text-to-binary translation that happens.
This leans on the support within the `wast` crate already and enables
more easily seeing where a trap is happening during development of
tests due to the fact that line numbers are available as opposed to just
having binary offsets with a stack trace.

Currently this is enabled-by-default with an option to disable it, but
I'm not actually sure if we have a use case for disabling it...

Author: alexcrichton

Cargo.lock

@@ -16,7 +16,7 @@ workspace = true
 [dependencies]
 anyhow = { workspace = true }
 wasmtime = { workspace = true, features = ['cranelift', 'wat', 'runtime', 'gc', 'async'] }
-wast = { workspace = true }
+wast = { workspace = true, features = ['dwarf'] }
 log = { workspace = true }
 tokio = { workspace = true, features = ['rt'] }
 

crates/wast/Cargo.toml

@@ -8,6 +8,7 @@ use std::path::Path;
 use std::str;
 use std::thread;
 use wasmtime::*;
+use wast::core::{EncodeOptions, GenerateDwarf};
 use wast::lexer::Lexer;
 use wast::parser::{self, ParseBuffer};
 use wast::{QuoteWat, Wast, WastArg, WastDirective, WastExecute, WastInvoke, WastRet, Wat};
@@ -24,6 +25,7 @@ pub struct WastContext<T: 'static> {
     component_linker: component::Linker<T>,
     pub(crate) store: Store<T>,
     pub(crate) async_runtime: Option<tokio::runtime::Runtime>,
+    generate_dwarf: bool,
 }
 
 enum Outcome<T = Results> {
@@ -118,6 +120,7 @@ where
             } else {
                 None
             },
+            generate_dwarf: true,
         }
     }
 
@@ -187,20 +190,25 @@ where
     }
 
     /// Perform the action portion of a command.
-    fn perform_execute(&mut self, exec: WastExecute<'_>) -> Result<Outcome> {
+    fn perform_execute(
+        &mut self,
+        exec: WastExecute<'_>,
+        filename: &str,
+        wast: &str,
+    ) -> Result<Outcome> {
         match exec {
             WastExecute::Invoke(invoke) => self.perform_invoke(invoke),
-            WastExecute::Wat(module) => {
-                Ok(match self.module_definition(QuoteWat::Wat(module))? {
+            WastExecute::Wat(module) => Ok(
+                match self.module_definition(QuoteWat::Wat(module), filename, wast)? {
                     (_, ModuleKind::Core(module)) => self
                         .instantiate_module(&module)?
                         .map(|_| Results::Core(Vec::new())),
                     #[cfg(feature = "component-model")]
                     (_, ModuleKind::Component(component)) => self
                         .instantiate_component(&component)?
                         .map(|_| Results::Component(Vec::new())),
-                })
-            }
+                },
+            ),
             WastExecute::Get { module, global, .. } => self.get(module.map(|s| s.name()), global),
         }
     }
@@ -325,14 +333,25 @@ where
     fn module_definition<'a>(
         &mut self,
         mut wat: QuoteWat<'a>,
+        filename: &str,
+        wast: &str,
     ) -> Result<(Option<&'a str>, ModuleKind)> {
         let (is_module, name) = match &wat {
             QuoteWat::Wat(Wat::Module(m)) => (true, m.id),
             QuoteWat::QuoteModule(..) => (true, None),
             QuoteWat::Wat(Wat::Component(m)) => (false, m.id),
             QuoteWat::QuoteComponent(..) => (false, None),
         };
-        let bytes = wat.encode()?;
+        let bytes = match &mut wat {
+            QuoteWat::Wat(wat) => {
+                let mut opts = EncodeOptions::new();
+                if self.generate_dwarf {
+                    opts.dwarf(filename.as_ref(), wast, GenerateDwarf::Lines);
+                }
+                opts.encode_wat(wat)?
+            }
+            _ => wat.encode()?,
+        };
         if is_module {
             let module = Module::new(self.store.engine(), &bytes)?;
             Ok((name.map(|n| n.name()), ModuleKind::Core(module)))
@@ -451,7 +470,8 @@ where
 
         let mut lexer = Lexer::new(wast);
         lexer.allow_confusing_unicode(filename.ends_with("names.wast"));
-        let buf = ParseBuffer::new_with_lexer(lexer).map_err(adjust_wast)?;
+        let mut buf = ParseBuffer::new_with_lexer(lexer).map_err(adjust_wast)?;
+        buf.track_instr_spans(self.generate_dwarf);
         let ast = parser::parse::<Wast>(&buf).map_err(adjust_wast)?;
 
         self.run_directives(ast.directives, filename, wast)
@@ -506,11 +526,11 @@ where
 
         match directive {
             Module(module) => {
-                let (name, module) = self.module_definition(module)?;
+                let (name, module) = self.module_definition(module, filename, wast)?;
                 self.module(name, &module)?;
             }
             ModuleDefinition(module) => {
-                let (name, module) = self.module_definition(module)?;
+                let (name, module) = self.module_definition(module, filename, wast)?;
                 if let Some(name) = name {
                     self.modules.insert(name.to_string(), module.clone());
                 }
@@ -541,15 +561,15 @@ where
                 exec,
                 results,
             } => {
-                let result = self.perform_execute(exec)?;
+                let result = self.perform_execute(exec, filename, wast)?;
                 self.assert_return(result, &results)?;
             }
             AssertTrap {
                 span: _,
                 exec,
                 message,
             } => {
-                let result = self.perform_execute(exec)?;
+                let result = self.perform_execute(exec, filename, wast)?;
                 self.assert_trap(result, message)?;
             }
             AssertExhaustion {
@@ -565,7 +585,7 @@ where
                 module,
                 message,
             } => {
-                let err = match self.module_definition(module) {
+                let err = match self.module_definition(module, filename, wast) {
                     Ok(_) => bail!("expected module to fail to build"),
                     Err(e) => e,
                 };
@@ -583,7 +603,7 @@ where
                 span: _,
                 message: _,
             } => {
-                if let Ok(_) = self.module_definition(module) {
+                if let Ok(_) = self.module_definition(module, filename, wast) {
                     bail!("expected malformed module to fail to instantiate");
                 }
             }
@@ -592,7 +612,8 @@ where
                 module,
                 message,
             } => {
-                let (name, module) = self.module_definition(QuoteWat::Wat(module))?;
+                let (name, module) =
+                    self.module_definition(QuoteWat::Wat(module), filename, wast)?;
                 let err = match self.module(name, &module) {
                     Ok(_) => bail!("expected module to fail to link"),
                     Err(e) => e,
@@ -632,6 +653,7 @@ where
                             .build()
                             .unwrap()
                     }),
+                    generate_dwarf: self.generate_dwarf,
                 };
                 let name = thread.name.name();
                 let child =
@@ -662,6 +684,13 @@ where
             std::fs::read(path).with_context(|| format!("failed to read `{}`", path.display()))?;
         self.run_buffer(path.to_str().unwrap(), &bytes)
     }
+
+    /// Whether or not to generate DWARF debugging information in custom
+    /// sections in modules being tested.
+    pub fn generate_dwarf(&mut self, enable: bool) -> &mut Self {
+        self.generate_dwarf = enable;
+        self
+    }
 }
 
 fn is_matching_assert_invalid_error_message(test: &str, expected: &str, actual: &str) -> bool {

crates/wast/src/wast.rs

@@ -16,6 +16,11 @@ pub struct WastCommand {
     /// The path of the WebAssembly test script to run
     #[arg(required = true, value_name = "SCRIPT_FILE")]
     scripts: Vec<PathBuf>,
+
+    /// Whether or not to generate DWARF debugging information in text-to-binary
+    /// transformations to show line numbers in backtraces.
+    #[arg(long, require_equals = true, value_name = "true|false")]
+    generate_dwarf: Option<Option<bool>>,
 }
 
 impl WastCommand {
@@ -35,6 +40,7 @@ impl WastCommand {
         }
         let mut wast_context = WastContext::new(store, wasmtime_wast::Async::Yes);
 
+        wast_context.generate_dwarf(optional_flag_with_default(self.generate_dwarf, true));
         wast_context
             .register_spectest(&SpectestConfig {
                 use_shared_memory: true,
@@ -51,3 +57,11 @@ impl WastCommand {
         Ok(())
     }
 }
+
+fn optional_flag_with_default(flag: Option<Option<bool>>, default: bool) -> bool {
+    match flag {
+        None => default,
+        Some(None) => true,
+        Some(Some(val)) => val,
+    }
+}

src/commands/wast.rs

@@ -2018,6 +2018,12 @@ criteria = "safe-to-deploy"
 delta = "0.29.0 -> 0.31.0"
 notes = "Various updates here and there, nothing too major, what you'd expect from a DWARF parsing crate."
 
+[[audits.gimli]]
+who = "Alex Crichton <[email protected]>"
+criteria = "safe-to-deploy"
+delta = "0.31.0 -> 0.31.1"
+notes = "No fundmanetally new `unsafe` code, some small refactoring of existing code. Lots of changes in tests, not as many changes in the rest of the crate. More dwarf!"
+
 [[audits.glob]]
 who = "Jamey Sharp <[email protected]>"
 criteria = "safe-to-deploy"

supply-chain/audits.toml

@@ -316,10 +316,6 @@ criteria = "safe-to-deploy"
 version = "0.2.6"
 criteria = "safe-to-deploy"
 
-[[exemptions.gimli]]
-version = "0.26.1"
-criteria = "safe-to-deploy"
-
 [[exemptions.h2]]
 version = "0.4.4"
 criteria = "safe-to-deploy"

supply-chain/config.toml

@@ -2507,6 +2507,23 @@ documentation.
 """
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
+[[audits.mozilla.audits.gimli]]
+who = "Alex Franchuk <[email protected]>"
+criteria = "safe-to-deploy"
+version = "0.30.0"
+notes = """
+Unsafe code blocks are sound. Minimal dependencies used. No use of
+side-effectful std functions.
+"""
+aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
+
+[[audits.mozilla.audits.gimli]]
+who = "Chris Martin <[email protected]>"
+criteria = "safe-to-deploy"
+delta = "0.30.0 -> 0.29.0"
+notes = "No unsafe code, mostly algorithms and parsing. Very unlikely to cause security issues."
+aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
+
 [[audits.mozilla.audits.half]]
 who = "John M. Schanck <[email protected]>"
 criteria = "safe-to-deploy"

supply-chain/imports.lock

@@ -242,6 +242,7 @@ fn run_wast(test: &WastTest, config: WastConfig) -> anyhow::Result<()> {
         let result = engine.and_then(|engine| {
             let store = Store::new(&engine, ());
             let mut wast_context = WastContext::new(store, Async::Yes);
+            wast_context.generate_dwarf(true);
             wast_context.register_spectest(&SpectestConfig {
                 use_shared_memory: true,
                 suppress_prints: true,