Add mozjs, V8 and WABT setup script (#3053)

Adds a new script `./third_party/setup.py` to conveniently install necessary dependencies for testing and fuzzing, including the SpiderMonkey JS shell (mozjs), the V8 JS shell and WABT. Other scripts now automatically pick these up when installed and fall back to look for the tools in PATH like before.

10 files changed, 730 insertions, 1 deletions

diff --git a/README.md b/README.md
index 2ce6f1abb..83a742071 100644
--- a/README.md
+++ b/README.md
@@ -342,6 +342,24 @@ The `check.py` script supports some options:
  * We have tests from upstream in `tests/spec`, in git submodules. Running
    `./check.py` should update those.
 
+### Setting up dependencies
+
+```
+./third_party/setup.py [mozjs|v8|wabt|all]
+```
+
+(or `python third_party/setup.py`) installs required dependencies like the SpiderMonkey JS shell, the V8 JS shell
+and WABT in `third_party/`. Other scripts automatically pick these up when installed.
+
+### Fuzzing
+
+```
+./scripts/fuzz_opt.py [--binaryen-bin=build/bin]
+```
+
+(or `python scripts/fuzz_opt.py`) will run various fuzzing modes on random inputs with random passes until it finds
+a possible bug. See [the wiki page](https://github.com/WebAssembly/binaryen/wiki/Fuzzing) for all the details.
+
 ## Design Principles
 
  * **Interned strings for names**: It's very convenient to have names on nodes,
diff --git a/scripts/test/shared.py b/scripts/test/shared.py
index ace68c3ee..4d2cb21b4 100644
--- a/scripts/test/shared.py
+++ b/scripts/test/shared.py
@@ -155,7 +155,13 @@ def which(program):
         if is_exe(program):
             return program
     else:
-        for path in os.environ["PATH"].split(os.pathsep):
+        paths = [
+            # Prefer tools installed using third_party/setup.py
+            os.path.join(options.binaryen_root, 'third_party', 'mozjs'),
+            os.path.join(options.binaryen_root, 'third_party', 'v8'),
+            os.path.join(options.binaryen_root, 'third_party', 'wabt', 'bin')
+        ] + os.environ['PATH'].split(os.pathsep)
+        for path in paths:
             path = path.strip('"')
             exe_file = os.path.join(path, program)
             if is_exe(exe_file):
diff --git a/third_party/mozjs/.gitignore b/third_party/mozjs/.gitignore
new file mode 100644
index 000000000..d6b7ef32c
--- /dev/null
+++ b/third_party/mozjs/.gitignore
@@ -0,0 +1,2 @@
+*
+!.gitignore
diff --git a/third_party/setup.py b/third_party/setup.py
new file mode 100755
index 000000000..8baaa02db
--- /dev/null
+++ b/third_party/setup.py
@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+#
+# Copyright 2020 WebAssembly Community Group participants
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import collections
+import json
+import io
+import os
+import re
+import sys
+import tarfile
+import urllib.request
+import zipfile
+
+
+def fetch_json(url):
+    with urllib.request.urlopen(url) as res:
+        return json.loads(res.read().decode())
+
+
+def download_zip(url, dir):
+    with urllib.request.urlopen(url) as res:
+        data = io.BytesIO(res.read())
+        archive = zipfile.ZipFile(data)
+        for name in archive.namelist():
+            file = archive.open(name)
+            with open(os.path.join(dir, name), 'wb') as output:
+                output.write(file.read())
+
+
+def download_tar(url, dir):
+    tempfile = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'temp.tar.gz')
+    with urllib.request.urlopen(url) as res:
+        with open(tempfile, 'wb') as temp:
+            temp.write(res.read())
+    with tarfile.open(tempfile, 'r') as archive:
+        for member in archive.getmembers():
+            match = re.match('^[^/]+/', member.name)
+            if match:
+                outname = os.path.join(dir, member.name[match.span(0)[1]:])
+                if member.isdir():
+                    if not os.path.exists(outname):
+                        os.mkdir(outname)
+                elif member.isfile():
+                    with archive.extractfile(member) as infile:
+                        with open(outname, 'wb') as outfile:
+                            outfile.write(infile.read())
+                        if sys.platform != 'win32':
+                            os.chmod(outname, member.mode)
+    os.remove(tempfile)
+
+
+# mozjs
+# see: https://github.com/GoogleChromeLabs/jsvu/tree/main/engines/spidermonkey
+
+mozjs_bin = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'mozjs')
+
+
+def mozjs_determine_platform():
+    is_64bits = sys.maxsize > 2**32
+    if sys.platform.startswith('linux'):
+        return 'linux-x86_64' if is_64bits else 'linux-i686'
+    if sys.platform == 'darwin':
+        return 'mac'
+    if sys.platform == 'win32':
+        return 'win64' if is_64bits else 'win32'
+    print('Cannot determine platform, assuming \'linux-x86_64\'')
+    return 'linux-x86_64'
+
+
+def mozjs_determine_version(platform):
+    data = fetch_json('https://product-details.mozilla.org/1.0/firefox_history_development_releases.json')
+    latest = ''
+    version = ''
+    for v, t in data.items():
+        if t > latest:
+            latest = t
+            version = v
+    return version
+
+
+def mozjs_download(platform, version):
+    download_zip('https://archive.mozilla.org/pub/firefox/releases/' + version + '/jsshell/jsshell-' + platform + '.zip', mozjs_bin)
+    if sys.platform != 'win32':
+        os.rename(os.path.join(mozjs_bin, 'js'), os.path.join(mozjs_bin, 'mozjs'))
+        os.chmod(os.path.join(mozjs_bin, 'mozjs'), 0o755)
+    else:
+        os.rename(os.path.join(mozjs_bin, 'js.exe'), os.path.join(mozjs_bin, 'mozjs.exe'))
+
+
+def mozjs_is_installed():
+    return os.path.exists(os.path.join(mozjs_bin, 'mozjs.exe' if sys.platform == 'win32' else 'mozjs'))
+
+
+def mozjs_main():
+    print('Setting up mozjs ...')
+    platform = mozjs_determine_platform()
+    print('* Platform: ' + platform)
+    version = mozjs_determine_version(platform)
+    print('* Latest version: ' + version)
+    print('* Downloading to: ' + mozjs_bin)
+    mozjs_download(platform, version)
+    if mozjs_is_installed():
+        print('* Complete')
+    else:
+        print('* Something went wrong :(')
+
+
+# V8
+# see: https://github.com/GoogleChromeLabs/jsvu/tree/main/engines/v8
+
+v8_bin = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'v8')
+
+
+def v8_determine_platform():
+    is_64bits = sys.maxsize > 2**32
+    if sys.platform.startswith('linux'):
+        return 'linux64' if is_64bits else 'linux32'
+    if sys.platform == 'darwin':
+        return 'mac64'
+    if sys.platform == 'win32':
+        return 'win64' if is_64bits else 'win32'
+    print('Cannot determine platform, assuming \'linux64\'')
+    return 'linux64'
+
+
+def v8_determine_version(platform):
+    data = fetch_json('https://storage.googleapis.com/chromium-v8/official/canary/v8-' + platform + '-rel-latest.json')
+    return data['version']
+
+
+def v8_download(platform, version):
+    download_zip('https://storage.googleapis.com/chromium-v8/official/canary/v8-' + platform + '-rel-' + version + '.zip', v8_bin)
+    if sys.platform != 'win32':
+        os.chmod(os.path.join(v8_bin, 'd8'), 0o755)
+
+
+def v8_is_installed():
+    return os.path.exists(os.path.join(v8_bin, 'd8.exe' if sys.platform == 'win32' else 'd8'))
+
+
+def v8_main():
+    print('Setting up V8 ...')
+    platform = v8_determine_platform()
+    print('* Platform: ' + platform)
+    version = v8_determine_version(platform)
+    print('* Latest version: ' + version)
+    print('* Downloading to: ' + v8_bin)
+    v8_download(platform, version)
+    if v8_is_installed():
+        print('* Complete')
+    else:
+        print('* Something went wrong :(')
+
+
+# WABT
+# see: https://github.com/WebAssembly/wabt/releases
+
+wabt_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'wabt')
+wabt_bin = os.path.join(wabt_dir, 'bin')
+
+
+def wabt_determine_platform():
+    if sys.platform.startswith('linux'):
+        return 'ubuntu'
+    if sys.platform == 'darwin':
+        return 'macos'
+    if sys.platform == 'win32':
+        return 'windows'
+    print('Cannot determine platform, assuming \'ubuntu\'')
+    return 'ubuntu'
+
+
+def wabt_determine_release(platform):
+    data = fetch_json('https://api.github.com/repos/WebAssembly/wabt/releases/latest')
+    for asset in data['assets']:
+        if asset['name'].endswith('-' + platform + '.tar.gz'):
+            return asset['browser_download_url']
+    print('Cannot determine release')
+    return ''
+
+
+def wabt_download(release):
+    download_tar(release, wabt_dir)
+
+
+def wabt_is_installed():
+    return os.path.exists(os.path.join(wabt_bin, 'wasm2c.exe' if sys.platform == 'win32' else 'wasm2c'))
+
+
+def wabt_main():
+    print('Setting up WABT ...')
+    platform = wabt_determine_platform()
+    print('* Platform: ' + platform)
+    release = wabt_determine_release(platform)
+    print('* Latest release: ' + release)
+    print('* Downloading to: ' + wabt_bin)
+    wabt_download(release)
+    if wabt_is_installed():
+        print('* Complete')
+    else:
+        print('* Something went wrong :(')
+
+
+TOOLS = collections.OrderedDict([
+    ('mozjs', mozjs_main),
+    ('v8', v8_main),
+    ('wabt', wabt_main),
+])
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2 or sys.argv[1] == '--help':
+        msg = ''
+        for key in TOOLS.keys():
+            if len(msg):
+                msg += '|'
+            msg += key
+        print('usage: ./setup.py [' + msg + '|all]')
+        sys.exit(0)
+    tool = sys.argv[1]
+    if tool == 'all':
+        for main in TOOLS.values():
+            code = main()
+            if code:
+                sys.exit(code)
+        sys.exit(0)
+    elif TOOLS[tool]:
+        main = TOOLS[tool]
+        sys.exit(main())
+    else:
+        print('No such tool: ' + tool)
+        sys.exit(1)
diff --git a/third_party/v8/.gitignore b/third_party/v8/.gitignore
new file mode 100644
index 000000000..d6b7ef32c
--- /dev/null
+++ b/third_party/v8/.gitignore
@@ -0,0 +1,2 @@
+*
+!.gitignore
diff --git a/third_party/wabt/.gitignore b/third_party/wabt/.gitignore
new file mode 100644
index 000000000..ba18c1f73
--- /dev/null
+++ b/third_party/wabt/.gitignore
@@ -0,0 +1,4 @@
+*
+!.gitignore
+!wasm2c
+!wasm2c/*
diff --git a/third_party/wabt/wasm2c/README.md b/third_party/wabt/wasm2c/README.md
new file mode 100644
index 000000000..16ab3fc6c
--- /dev/null
+++ b/third_party/wabt/wasm2c/README.md
@@ -0,0 +1,5 @@
+These files are part of WABT, but are currently not present in releases, so the
+directory is included as a fallback in Binaryen in a way that the files will be
+overwritten in case WABT contains them in the future.
+
+Original README: https://github.com/WebAssembly/wabt/blob/master/wasm2c/README.md
diff --git a/third_party/wabt/wasm2c/wasm-rt-impl.c b/third_party/wabt/wasm2c/wasm-rt-impl.c
new file mode 100644
index 000000000..c52063ab3
--- /dev/null
+++ b/third_party/wabt/wasm2c/wasm-rt-impl.c
@@ -0,0 +1,182 @@
+/*
+ * Copyright 2018 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "wasm-rt-impl.h"
+
+#include <assert.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if WASM_RT_MEMCHECK_SIGNAL_HANDLER_POSIX
+#include <signal.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#endif
+
+#define PAGE_SIZE 65536
+
+typedef struct FuncType {
+  wasm_rt_type_t* params;
+  wasm_rt_type_t* results;
+  uint32_t param_count;
+  uint32_t result_count;
+} FuncType;
+
+uint32_t wasm_rt_call_stack_depth;
+uint32_t g_saved_call_stack_depth;
+
+#if WASM_RT_MEMCHECK_SIGNAL_HANDLER
+bool g_signal_handler_installed = false;
+#endif
+
+jmp_buf g_jmp_buf;
+FuncType* g_func_types;
+uint32_t g_func_type_count;
+
+void wasm_rt_trap(wasm_rt_trap_t code) {
+  assert(code != WASM_RT_TRAP_NONE);
+  wasm_rt_call_stack_depth = g_saved_call_stack_depth;
+  WASM_RT_LONGJMP(g_jmp_buf, code);
+}
+
+static bool func_types_are_equal(FuncType* a, FuncType* b) {
+  if (a->param_count != b->param_count || a->result_count != b->result_count)
+    return 0;
+  int i;
+  for (i = 0; i < a->param_count; ++i)
+    if (a->params[i] != b->params[i])
+      return 0;
+  for (i = 0; i < a->result_count; ++i)
+    if (a->results[i] != b->results[i])
+      return 0;
+  return 1;
+}
+
+uint32_t wasm_rt_register_func_type(uint32_t param_count,
+                                    uint32_t result_count,
+                                    ...) {
+  FuncType func_type;
+  func_type.param_count = param_count;
+  func_type.params = malloc(param_count * sizeof(wasm_rt_type_t));
+  func_type.result_count = result_count;
+  func_type.results = malloc(result_count * sizeof(wasm_rt_type_t));
+
+  va_list args;
+  va_start(args, result_count);
+
+  uint32_t i;
+  for (i = 0; i < param_count; ++i)
+    func_type.params[i] = va_arg(args, wasm_rt_type_t);
+  for (i = 0; i < result_count; ++i)
+    func_type.results[i] = va_arg(args, wasm_rt_type_t);
+  va_end(args);
+
+  for (i = 0; i < g_func_type_count; ++i) {
+    if (func_types_are_equal(&g_func_types[i], &func_type)) {
+      free(func_type.params);
+      free(func_type.results);
+      return i + 1;
+    }
+  }
+
+  uint32_t idx = g_func_type_count++;
+  g_func_types = realloc(g_func_types, g_func_type_count * sizeof(FuncType));
+  g_func_types[idx] = func_type;
+  return idx + 1;
+}
+
+#if WASM_RT_MEMCHECK_SIGNAL_HANDLER_POSIX
+static void signal_handler(int sig, siginfo_t* si, void* unused) {
+  wasm_rt_trap(WASM_RT_TRAP_OOB);
+}
+#endif
+
+void wasm_rt_allocate_memory(wasm_rt_memory_t* memory,
+                             uint32_t initial_pages,
+                             uint32_t max_pages) {
+  uint32_t byte_length = initial_pages * PAGE_SIZE;
+#if WASM_RT_MEMCHECK_SIGNAL_HANDLER_POSIX
+  if (!g_signal_handler_installed) {
+    g_signal_handler_installed = true;
+    struct sigaction sa;
+    sa.sa_flags = SA_SIGINFO;
+    sigemptyset(&sa.sa_mask);
+    sa.sa_sigaction = signal_handler;
+
+    /* Install SIGSEGV and SIGBUS handlers, since macOS seems to use SIGBUS. */
+    if (sigaction(SIGSEGV, &sa, NULL) != 0 ||
+        sigaction(SIGBUS, &sa, NULL) != 0) {
+      perror("sigaction failed");
+      abort();
+    }
+  }
+
+  /* Reserve 8GiB. */
+  void* addr =
+      mmap(NULL, 0x200000000ul, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  if (addr == (void*)-1) {
+    perror("mmap failed");
+    abort();
+  }
+  mprotect(addr, byte_length, PROT_READ | PROT_WRITE);
+  memory->data = addr;
+#else
+  memory->data = calloc(byte_length, 1);
+#endif
+  memory->size = byte_length;
+  memory->pages = initial_pages;
+  memory->max_pages = max_pages;
+}
+
+uint32_t wasm_rt_grow_memory(wasm_rt_memory_t* memory, uint32_t delta) {
+  uint32_t old_pages = memory->pages;
+  uint32_t new_pages = memory->pages + delta;
+  if (new_pages == 0) {
+    return 0;
+  }
+  if (new_pages < old_pages || new_pages > memory->max_pages) {
+    return (uint32_t)-1;
+  }
+  uint32_t old_size = old_pages * PAGE_SIZE;
+  uint32_t new_size = new_pages * PAGE_SIZE;
+  uint32_t delta_size = delta * PAGE_SIZE;
+#if WASM_RT_MEMCHECK_SIGNAL_HANDLER_POSIX
+  uint8_t* new_data = memory->data;
+  mprotect(new_data + old_size, delta_size, PROT_READ | PROT_WRITE);
+#else
+  uint8_t* new_data = realloc(memory->data, new_size);
+  if (new_data == NULL) {
+    return (uint32_t)-1;
+  }
+  memset(new_data + old_size, 0, delta_size);
+#endif
+  memory->pages = new_pages;
+  memory->size = new_size;
+  memory->data = new_data;
+  return old_pages;
+}
+
+void wasm_rt_allocate_table(wasm_rt_table_t* table,
+                            uint32_t elements,
+                            uint32_t max_elements) {
+  table->size = elements;
+  table->max_size = max_elements;
+  table->data = calloc(table->size, sizeof(wasm_rt_elem_t));
+}
diff --git a/third_party/wabt/wasm2c/wasm-rt-impl.h b/third_party/wabt/wasm2c/wasm-rt-impl.h
new file mode 100644
index 000000000..39d5ed930
--- /dev/null
+++ b/third_party/wabt/wasm2c/wasm-rt-impl.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2018 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef WASM_RT_IMPL_H_
+#define WASM_RT_IMPL_H_
+
+#include <setjmp.h>
+
+#include "wasm-rt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** A setjmp buffer used for handling traps. */
+extern jmp_buf g_jmp_buf;
+
+/** Saved call stack depth that will be restored in case a trap occurs. */
+extern uint32_t g_saved_call_stack_depth;
+
+#if WASM_RT_MEMCHECK_SIGNAL_HANDLER_POSIX
+#define WASM_RT_SETJMP(buf) sigsetjmp(buf, 1)
+#define WASM_RT_LONGJMP(buf, val) siglongjmp(buf, val)
+#else
+#define WASM_RT_SETJMP(buf) setjmp(buf)
+#define WASM_RT_LONGJMP(buf, val) longjmp(buf, val)
+#endif
+
+/** Convenience macro to use before calling a wasm function. On first execution
+ * it will return `WASM_RT_TRAP_NONE` (i.e. 0). If the function traps, it will
+ * jump back and return the trap that occurred.
+ *
+ * ```
+ *   wasm_rt_trap_t code = wasm_rt_impl_try();
+ *   if (code != 0) {
+ *     printf("A trap occurred with code: %d\n", code);
+ *     ...
+ *   }
+ *
+ *   // Call the potentially-trapping function.
+ *   my_wasm_func();
+ * ```
+ */
+#define wasm_rt_impl_try()                              \
+  (g_saved_call_stack_depth = wasm_rt_call_stack_depth, \
+   WASM_RT_SETJMP(g_jmp_buf))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // WASM_RT_IMPL_H_
diff --git a/third_party/wabt/wasm2c/wasm-rt.h b/third_party/wabt/wasm2c/wasm-rt.h
new file mode 100644
index 000000000..2797e8f71
--- /dev/null
+++ b/third_party/wabt/wasm2c/wasm-rt.h
@@ -0,0 +1,201 @@
+/*
+ * Copyright 2018 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef WASM_RT_H_
+#define WASM_RT_H_
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Maximum stack depth before trapping. This can be configured by defining
+ * this symbol before including wasm-rt when building the generated c files,
+ * for example:
+ *
+ * ```
+ *   cc -c -DWASM_RT_MAX_CALL_STACK_DEPTH=100 my_module.c -o my_module.o
+ * ```
+ * */
+#ifndef WASM_RT_MAX_CALL_STACK_DEPTH
+#define WASM_RT_MAX_CALL_STACK_DEPTH 500
+#endif
+
+/** Enable memory checking via a signal handler via the following definition:
+ *
+ * #define WASM_RT_MEMCHECK_SIGNAL_HANDLER 1
+ *
+ * This is usually 10%-25% faster, but requires OS-specific support.
+ * */
+
+/** Check whether the signal handler is supported at all. */
+#if (defined(__linux__) || defined(__unix__) || defined(__APPLE__)) && \
+    defined(__WORDSIZE) && __WORDSIZE == 64
+
+/* If the signal handler is supported, then use it by default. */
+#ifndef WASM_RT_MEMCHECK_SIGNAL_HANDLER
+#define WASM_RT_MEMCHECK_SIGNAL_HANDLER 1
+#endif
+
+#if WASM_RT_MEMCHECK_SIGNAL_HANDLER
+#define WASM_RT_MEMCHECK_SIGNAL_HANDLER_POSIX 1
+#endif
+
+#else
+
+/* The signal handler is not supported, error out if the user was trying to
+ * enable it. */
+#if WASM_RT_MEMCHECK_SIGNAL_HANDLER
+#error "Signal handler is not supported for this OS/Architecture!"
+#endif
+
+#define WASM_RT_MEMCHECK_SIGNAL_HANDLER 0
+#define WASM_RT_MEMCHECK_SIGNAL_HANDLER_POSIX 0
+
+#endif
+
+/** Reason a trap occurred. Provide this to `wasm_rt_trap`. */
+typedef enum {
+  WASM_RT_TRAP_NONE,         /** No error. */
+  WASM_RT_TRAP_OOB,          /** Out-of-bounds access in linear memory. */
+  WASM_RT_TRAP_INT_OVERFLOW, /** Integer overflow on divide or truncation. */
+  WASM_RT_TRAP_DIV_BY_ZERO,  /** Integer divide by zero. */
+  WASM_RT_TRAP_INVALID_CONVERSION, /** Conversion from NaN to integer. */
+  WASM_RT_TRAP_UNREACHABLE,        /** Unreachable instruction executed. */
+  WASM_RT_TRAP_CALL_INDIRECT,      /** Invalid call_indirect, for any reason. */
+  WASM_RT_TRAP_EXHAUSTION,         /** Call stack exhausted. */
+} wasm_rt_trap_t;
+
+/** Value types. Used to define function signatures. */
+typedef enum {
+  WASM_RT_I32,
+  WASM_RT_I64,
+  WASM_RT_F32,
+  WASM_RT_F64,
+} wasm_rt_type_t;
+
+/** A function type for all `anyfunc` functions in a Table. All functions are
+ * stored in this canonical form, but must be cast to their proper signature to
+ * call. */
+typedef void (*wasm_rt_anyfunc_t)(void);
+
+/** A single element of a Table. */
+typedef struct {
+  /** The index as returned from `wasm_rt_register_func_type`. */
+  uint32_t func_type;
+  /** The function. The embedder must know the actual C signature of the
+   * function and cast to it before calling. */
+  wasm_rt_anyfunc_t func;
+} wasm_rt_elem_t;
+
+/** A Memory object. */
+typedef struct {
+  /** The linear memory data, with a byte length of `size`. */
+  uint8_t* data;
+  /** The current and maximum page count for this Memory object. If there is no
+   * maximum, `max_pages` is 0xffffffffu (i.e. UINT32_MAX). */
+  uint32_t pages, max_pages;
+  /** The current size of the linear memory, in bytes. */
+  uint32_t size;
+} wasm_rt_memory_t;
+
+/** A Table object. */
+typedef struct {
+  /** The table element data, with an element count of `size`. */
+  wasm_rt_elem_t* data;
+  /** The maximum element count of this Table object. If there is no maximum,
+   * `max_size` is 0xffffffffu (i.e. UINT32_MAX). */
+  uint32_t max_size;
+  /** The current element count of the table. */
+  uint32_t size;
+} wasm_rt_table_t;
+
+/** Stop execution immediately and jump back to the call to `wasm_rt_try`.
+ *  The result of `wasm_rt_try` will be the provided trap reason.
+ *
+ *  This is typically called by the generated code, and not the embedder. */
+extern void wasm_rt_trap(wasm_rt_trap_t) __attribute__((noreturn));
+
+/** Register a function type with the given signature. The returned function
+ * index is guaranteed to be the same for all calls with the same signature.
+ * The following varargs must all be of type `wasm_rt_type_t`, first the
+ * params` and then the `results`.
+ *
+ *  ```
+ *    // Register (func (param i32 f32) (result i64)).
+ *    wasm_rt_register_func_type(2, 1, WASM_RT_I32, WASM_RT_F32, WASM_RT_I64);
+ *    => returns 1
+ *
+ *    // Register (func (result i64)).
+ *    wasm_rt_register_func_type(0, 1, WASM_RT_I32);
+ *    => returns 2
+ *
+ *    // Register (func (param i32 f32) (result i64)) again.
+ *    wasm_rt_register_func_type(2, 1, WASM_RT_I32, WASM_RT_F32, WASM_RT_I64);
+ *    => returns 1
+ *  ``` */
+extern uint32_t wasm_rt_register_func_type(uint32_t params,
+                                           uint32_t results,
+                                           ...);
+
+/** Initialize a Memory object with an initial page size of `initial_pages` and
+ * a maximum page size of `max_pages`.
+ *
+ *  ```
+ *    wasm_rt_memory_t my_memory;
+ *    // 1 initial page (65536 bytes), and a maximum of 2 pages.
+ *    wasm_rt_allocate_memory(&my_memory, 1, 2);
+ *  ``` */
+extern void wasm_rt_allocate_memory(wasm_rt_memory_t*,
+                                    uint32_t initial_pages,
+                                    uint32_t max_pages);
+
+/** Grow a Memory object by `pages`, and return the previous page count. If
+ * this new page count is greater than the maximum page count, the grow fails
+ * and 0xffffffffu (UINT32_MAX) is returned instead.
+ *
+ *  ```
+ *    wasm_rt_memory_t my_memory;
+ *    ...
+ *    // Grow memory by 10 pages.
+ *    uint32_t old_page_size = wasm_rt_grow_memory(&my_memory, 10);
+ *    if (old_page_size == UINT32_MAX) {
+ *      // Failed to grow memory.
+ *    }
+ *  ``` */
+extern uint32_t wasm_rt_grow_memory(wasm_rt_memory_t*, uint32_t pages);
+
+/** Initialize a Table object with an element count of `elements` and a maximum
+ * page size of `max_elements`.
+ *
+ *  ```
+ *    wasm_rt_table_t my_table;
+ *    // 5 elemnets and a maximum of 10 elements.
+ *    wasm_rt_allocate_table(&my_table, 5, 10);
+ *  ``` */
+extern void wasm_rt_allocate_table(wasm_rt_table_t*,
+                                   uint32_t elements,
+                                   uint32_t max_elements);
+
+/** Current call stack depth. */
+extern uint32_t wasm_rt_call_stack_depth;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WASM_RT_H_ */