Introduction

Debugging Wasm? Put some Whamm on it!

If you're building a new dynamic analysis for Wasm and are looking for a framework to support you, you're in the right place! Whamm is a framework for "Wasm Application Monitoring and Manipulation"¹. This book will help you get on the right track when working with the language.

Tools in the Whamm framework are expressed using its domain-specific language (DSL). The DSL is inspired by Dtrace's D language. The Whamm DSL enables Wasm tool implementers to express their instrumentation using high-level abstractions of program events or locations at various levels of granularity.

Here are some of the goals of the Whamm DSL:

1. is high-level and intuitive
2. instrumentation is easy-to-build, testable, and debuggable
3. express instrumentation in terms of predicated probes
4. can instrument events of different granularity
5. provide behavior as Wasm functions, say where to call them in Whamm
6. write instrumentation once, Whamm takes care of the injection strategy.

A tool written in the Whamm framework can be applied using an engine's dynamic instrumentation capabilities or bytecode rewriting (if such capabilities aren't available). You can use the same tool for either strategy, Whamm takes care of the injection! Through providing such portability, Whamm broadens the applicability of tools, reducing tooling fragmentation across source languages (since Wasm is a polyglot) and Wasm engine (since it has the bytecode rewriting fallback that runs anywhere).

Let's take a moment to consider the scale of impact that this DSL could have on developer tooling by considering the following facts:

1. WebAssembly is growing to use cases beyond the browser.
2. Many languages can compile to Wasm.
3. With Whamm write instrumentation once to support wide domain of apps.
   • Use engine instrumentation capabilities as available.
   • Use bytecode rewriting to support everything else.

This means that developer tools written in Whamm could support a vast domain of applications, making WebAssembly the future target platform for debugging.

Resources

Injection strategies:

• Paper describing the non-intrusive injection strategy used by Whamm: Flexible Non-intrusive Dynamic Instrumentation for WebAssembly
• The library used to do the intrusive injection strategy (bytecode rewriting): wirm

Some helpful terms and concepts

1. WebAssembly (Wasm): WebAssembly is a binary instruction format for a stack-based virtual machine. It is designed as a portable compilation target for programming languages.
2. Instrumentation: When we say we are "instrumenting a program," at a high-level we mean we are "injecting some code into a program’s execution to do some operation." This definition is intentionally generic since instrumentation can really do anything we can imagine! You can use instrumentation to build debuggers, dynamic analyses, telemetry generators, and more.
3. Dynamic analysis: A dynamic analysis is something that analyzes a program as it is executing (in contrast to a static analysis which analyzes a program that is not running). This type of analysis can gain useful insights into a program as it is able to access information that is not available statically (such as hot code locations, memory accesses over time, code coverage of test suites, etc.).
4. Bytecode rewriting: This is an example strategy for injecting instrumentation logic into the application. It injects instrumentation through literally inserting new instructions into the application bytecode.

1: The 'h' is silent.