We Want WebAssembly

GOTO Stockholm 2017

Ben Smith @binjimint

I work at Google on the Chrome team, on WebAssembly. Here's the logo!

WABT

(Web Assembly Binary Toolkit)

My primary contribution is to wabt, the WebAssembly binary toolkit. This is as suite of tools that convert from the WebAssembly text format to the binary format, and back. It also includes an interpreter, a module validator and more.

WebAssembly Module Overview
New Languages
The Future

For this talk, I wanted to cover a few topics. First, I want to give an overview of a WebAssembly module. Next, I'll talk about some new languages that compile to JavaScript. Finally, I'll talk about some planned features for future versions of WebAssembly.

A Cartoon intro To WebAssembly

By Lin Clark

Before I get started, I want to mention a really great series of articles by Lin Clark, an engineer at Mozilla. She covers a number of topics, including assembly languages, machine code, JITs and how these apply to WebAssembly. In fact, I liked it so much, I stole the visual style for the rest of the slides. :-)

There we go!

Oh, as another aside: the name WebAssembly is kind funny. It's primary use case is for the web, but it's also useful as a portable executable for non-web environments too. Also, it's not really an assembly language, but more of a virtual ISA. But what's in a name anyway?

OK, let's look at what's in a WebAssembly module.

A WebAssembly module is the container for everything. Think of it as an executable for the WebAssembly virtual ISA.

The most important components of a module are the functions. They work like functions for pretty much any language you've used: pass in parameters, get a result. The parameters are only allowed to be one of four types: i32, i64, f32, and f64.

Here's an example of what a WebAssembly function looks like. This is described using the WebAssembly text format. It has a one-to-one mapping with the binary format. This function is an implementation of a recursive factorial for i64 types.

Functions can call other functions inside the module.

They can also call "imported" functions, provided by the embedder. In most uses, the embedder will be JavaScript, but there are non-JS embedders as well.

Unlike JavaScript, WebAssembly does not have objects. All data is written to "linear memory". It's called linear memory because it is a continguous array of raw data. Memory can also be imported from the embedder, but that isn't shown here.

Here's an example of data that could be stored in a module. As you can see, it's just raw bytes. When compiling a language like C++ to WebAssembly, all data is written here: read-only data, uninitialized data, the data stack and the heap.

Functions can read from and write data to linear memory by using the store and load instructions, in 1-, 2-, 4- and 8-byte sizes.

The module can also contain global variables. These values could be written to linear memory, but global variables are convenient because they are named directly and typed. Global variables can be mutable or immutable. Notice that global variables can also be imported from the embedder.

Functions can read from and write to global variables using the get_global and set_global instructions.

Tables store references to other module components. They can also be imported, just like memory, functions, and globals.

Currently, the only component that can be stored in a table is a reference to a function.

This allows you to perform indirect calls. Normally a function call references the function it will call directly, as part of the instruction. An indirect function call references an index in the table instead.

Functions, Globals, Memories, and Tables all can be exported, even if they were originally imported. In this picture, the two functions and the imported global with a purple border are exported. An exported function can be called by the embedder. An exported global can be read (but not modified).