redo CMakeLists.txt to use WASI interpreter

current status is that it hits error: OutOfMemory for unknown reasons, probably due to bugs in the C WASI interpreter port.
2026-04-27 19:09:47 +03:00 · 2022-11-15 00:33:05 -07:00
parent 8c1c67bdd0
commit ef447c3eca
4 changed files with 4332 additions and 420 deletions
@@ -1,11 +1,5 @@
 cmake_minimum_required(VERSION 2.8.12)

-# Use ccache if possible
-FIND_PROGRAM(CCACHE_PROGRAM ccache)
-IF(CCACHE_PROGRAM)
-    MESSAGE(STATUS "Found ccache ${CCACHE_PROGRAM}")
-ENDIF()
-
 if(NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE "Debug" CACHE STRING
        "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel." FORCE)
@@ -98,10 +92,15 @@ set(ZIG_SHARED_LLVM off CACHE BOOL "Prefer linking against shared LLVM libraries
 set(ZIG_STATIC_LLVM off CACHE BOOL "Prefer linking against static LLVM libraries")
 set(ZIG_STATIC_ZLIB off CACHE BOOL "Prefer linking against static zlib")
 set(ZIG_STATIC_ZSTD off CACHE BOOL "Prefer linking against static zstd")
-set(ZIG_USE_CCACHE off CACHE BOOL "Use ccache if available")
+set(ZIG_USE_CCACHE off CACHE BOOL "Use ccache")

-if(CCACHE_PROGRAM AND ZIG_USE_CCACHE)
-    SET_PROPERTY(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
+if(ZIG_USE_CCACHE)
+    find_program(CCACHE_PROGRAM ccache)
+    if(CCACHE_PROGRAM)
+      set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
+    else()
+      message(SEND_ERROR "ccache requested but not found")
+    endif()
 endif()

 if(ZIG_STATIC)
@@ -118,19 +117,9 @@ string(REGEX REPLACE "\\\\" "\\\\\\\\" ZIG_LIBC_LIB_DIR_ESCAPED "${ZIG_LIBC_LIB_
 string(REGEX REPLACE "\\\\" "\\\\\\\\" ZIG_LIBC_STATIC_LIB_DIR_ESCAPED "${ZIG_LIBC_STATIC_LIB_DIR}")
 string(REGEX REPLACE "\\\\" "\\\\\\\\" ZIG_LIBC_INCLUDE_DIR_ESCAPED "${ZIG_LIBC_INCLUDE_DIR}")

-option(ZIG_TEST_COVERAGE "Build Zig with test coverage instrumentation" OFF)
-
 set(ZIG_TARGET_TRIPLE "native" CACHE STRING "arch-os-abi to output binaries for")
 set(ZIG_TARGET_MCPU "native" CACHE STRING "-mcpu parameter to output binaries for")
-set(ZIG_EXECUTABLE "" CACHE STRING "(when cross compiling) path to already-built zig binary")
 set(ZIG_SINGLE_THREADED off CACHE BOOL "limit the zig compiler to use only 1 thread")
-set(ZIG_OMIT_STAGE2 off CACHE BOOL "omit the stage2 backend from stage1")
-
-if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
-    set(ZIG_ENABLE_LOGGING ON CACHE BOOL "enable logging")
-else()
-    set(ZIG_ENABLE_LOGGING OFF CACHE BOOL "enable logging")
-endif()

 if("${ZIG_TARGET_TRIPLE}" STREQUAL "native")
    set(ZIG_USE_LLVM_CONFIG ON CACHE BOOL "use llvm-config to find LLVM libraries")
@@ -179,190 +168,6 @@ include_directories(${LLVM_INCLUDE_DIRS})
 include_directories(${LLD_INCLUDE_DIRS})
 include_directories(${CLANG_INCLUDE_DIRS})

-# No patches have been applied to SoftFloat-3e
-set(EMBEDDED_SOFTFLOAT_SOURCES
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/f128M_isSignalingNaN.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/extF80M_isSignalingNaN.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/s_commonNaNToF128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/s_commonNaNToExtF80M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/s_commonNaNToF16UI.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/s_commonNaNToF32UI.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/s_commonNaNToF64UI.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/s_f128MToCommonNaN.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/s_extF80MToCommonNaN.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/s_f16UIToCommonNaN.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/s_f32UIToCommonNaN.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/s_f64UIToCommonNaN.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/s_propagateNaNF128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/s_propagateNaNExtF80M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/s_propagateNaNF16UI.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086/softfloat_raiseFlags.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_add.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_div.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_eq.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_eq_signaling.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_le.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_le_quiet.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_lt.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_lt_quiet.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_mul.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_mulAdd.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_rem.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_roundToInt.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_sqrt.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_sub.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_to_f16.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_to_f32.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_to_f64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_to_extF80M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_to_i32.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_to_i32_r_minMag.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_to_i64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_to_i64_r_minMag.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_to_ui32.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_to_ui32_r_minMag.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_to_ui64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_to_ui64_r_minMag.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/extF80M_add.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/extF80M_div.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/extF80M_eq.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/extF80M_le.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/extF80M_lt.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/extF80M_mul.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/extF80M_rem.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/extF80M_roundToInt.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/extF80M_sqrt.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/extF80M_sub.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/extF80M_to_f16.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/extF80M_to_f32.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/extF80M_to_f64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/extF80M_to_f128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f16_add.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f16_div.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f16_eq.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f16_isSignalingNaN.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f16_lt.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f16_mul.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f16_rem.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f16_roundToInt.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f16_sqrt.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f16_sub.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f16_to_extF80M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f16_to_f128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f16_to_f64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f32_to_extF80M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f32_to_f128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f64_to_extF80M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f64_to_f128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f64_to_f16.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/i32_to_f128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_add256M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_addCarryM.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_addComplCarryM.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_addF128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_addExtF80M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_addM.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_addMagsF16.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_addMagsF32.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_addMagsF64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_approxRecip32_1.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_approxRecipSqrt32_1.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_approxRecipSqrt_1Ks.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_approxRecip_1Ks.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_compare128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_compare96M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_compareNonnormExtF80M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_countLeadingZeros16.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_countLeadingZeros32.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_countLeadingZeros64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_countLeadingZeros8.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_eq128.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_invalidF128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_invalidExtF80M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_isNaNF128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_le128.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_lt128.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_mul128MTo256M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_mul64To128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_mulAddF128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_mulAddF16.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_mulAddF32.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_mulAddF64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_negXM.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_normExtF80SigM.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_normRoundPackMToF128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_normRoundPackMToExtF80M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_normRoundPackToF16.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_normRoundPackToF32.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_normRoundPackToF64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_normSubnormalF128SigM.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_normSubnormalF16Sig.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_normSubnormalF32Sig.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_normSubnormalF64Sig.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_remStepMBy32.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_roundMToI64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_roundMToUI64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_roundPackMToExtF80M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_roundPackMToF128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_roundPackToF16.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_roundPackToF32.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_roundPackToF64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_roundToI32.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_roundToI64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_roundToUI32.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_roundToUI64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_shiftLeftM.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_shiftNormSigF128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_shiftRightJam256M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_shiftRightJam32.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_shiftRightJam64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_shiftRightJamM.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_shiftRightM.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_shortShiftLeft64To96M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_shortShiftLeftM.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_shortShiftRightExtendM.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_shortShiftRightJam64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_shortShiftRightJamM.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_shortShiftRightM.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_sub1XM.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_sub256M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_subM.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_subMagsF16.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_subMagsF32.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_subMagsF64.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_tryPropagateNaNF128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/s_tryPropagateNaNExtF80M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f16_mulAdd.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/f128M_mulAdd.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/softfloat_state.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/ui32_to_f128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/ui64_to_f128M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/ui32_to_extF80M.c"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/ui64_to_extF80M.c"
-)
-add_library(embedded_softfloat STATIC ${EMBEDDED_SOFTFLOAT_SOURCES})
-if(MSVC)
-    set(SOFTFLOAT_CFLAGS "/w")
-
-    if(NOT "${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
-        set(SOFTFLOAT_CFLAGS "${SOFTFLOAT_CFLAGS} /O2")
-    endif()
-
-    set_target_properties(embedded_softfloat PROPERTIES
-        COMPILE_FLAGS ${SOFTFLOAT_CFLAGS}
-    )
-else()
-    set_target_properties(embedded_softfloat PROPERTIES
-        COMPILE_FLAGS "-std=c99 -O3"
-    )
-endif()
-target_include_directories(embedded_softfloat PUBLIC
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e-prebuilt"
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/8086"
-)
-include_directories("${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e/source/include")
-set(SOFTFLOAT_LIBRARIES embedded_softfloat)
-
 find_package(Threads)

 set(ZIG_LIB_DIR "lib/zig")
@@ -374,35 +179,8 @@ set(ZIG_STD_DEST "${ZIG_LIB_DIR}/std")
 set(ZIG_CONFIG_H_OUT "${CMAKE_BINARY_DIR}/config.h")
 set(ZIG_CONFIG_ZIG_OUT "${CMAKE_BINARY_DIR}/config.zig")

-# This is our shim which will be replaced by stage1.zig.
-set(ZIG1_SOURCES
-    "${CMAKE_SOURCE_DIR}/src/stage1/zig0.cpp"
-)
-
 set(STAGE1_SOURCES
-    "${CMAKE_SOURCE_DIR}/src/stage1/analyze.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/astgen.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/bigfloat.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/bigint.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/buffer.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/codegen.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/errmsg.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/error.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/heap.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/ir.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/ir_print.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/mem.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/os.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/parser.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/range_set.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/softfloat_ext.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/stage1.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/target.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/tokenizer.cpp"
-    "${CMAKE_SOURCE_DIR}/src/stage1/util.cpp"
-)
-set(OPTIMIZED_C_SOURCES
-    "${CMAKE_SOURCE_DIR}/src/stage1/parse_f128.c"
+    "${CMAKE_SOURCE_DIR}/stage1/zig1.c"
 )
 set(ZIG_CPP_SOURCES
    # These are planned to stay even when we are self-hosted.
@@ -416,11 +194,7 @@ set(ZIG_CPP_SOURCES
    "${CMAKE_SOURCE_DIR}/src/windows_sdk.cpp"
 )
 # Needed because we use cmake, not the zig build system, to build zig2.o.
-# This list is generated by building zig and then clearing the zig-cache directory,
-# then manually running the build-obj command (see BUILD_ZIG2_ARGS), and then looking
-# in the zig-cache directory for the compiler-generated list of zig file dependencies.
 set(ZIG_STAGE2_SOURCES
-    "${ZIG_CONFIG_ZIG_OUT}"
    "${CMAKE_SOURCE_DIR}/lib/std/array_hash_map.zig"
    "${CMAKE_SOURCE_DIR}/lib/std/array_list.zig"
    "${CMAKE_SOURCE_DIR}/lib/std/ascii.zig"
@@ -828,7 +602,6 @@ set(ZIG_STAGE2_SOURCES
    "${CMAKE_SOURCE_DIR}/src/print_targets.zig"
    "${CMAKE_SOURCE_DIR}/src/print_zir.zig"
    "${CMAKE_SOURCE_DIR}/src/register_manager.zig"
-    "${CMAKE_SOURCE_DIR}/src/stage1.zig"
    "${CMAKE_SOURCE_DIR}/src/target.zig"
    "${CMAKE_SOURCE_DIR}/src/tracy.zig"
    "${CMAKE_SOURCE_DIR}/src/translate_c.zig"
@@ -847,24 +620,12 @@ if(MSVC)
    endif()
 endif()

-if(ZIG_OMIT_STAGE2)
-  set(ZIG_OMIT_STAGE2_BOOL "true")
-else()
-  set(ZIG_OMIT_STAGE2_BOOL "false")
-endif()
-
-if(ZIG_ENABLE_LOGGING)
-  set(ZIG_ENABLE_LOGGING_BOOL "true")
-else()
-  set(ZIG_ENABLE_LOGGING_BOOL "false")
-endif()
-
 configure_file (
-    "${CMAKE_SOURCE_DIR}/src/stage1/config.h.in"
+    "${CMAKE_SOURCE_DIR}/stage1/config.h.in"
    "${ZIG_CONFIG_H_OUT}"
 )
 configure_file (
-    "${CMAKE_SOURCE_DIR}/src/config.zig.in"
+    "${CMAKE_SOURCE_DIR}/stage1/config.zig.in"
    "${ZIG_CONFIG_ZIG_OUT}"
 )

@@ -872,55 +633,40 @@ include_directories(
    ${CMAKE_SOURCE_DIR}
    ${CMAKE_BINARY_DIR}
    "${CMAKE_SOURCE_DIR}/src"
-    "${CMAKE_SOURCE_DIR}/src/stage1"
 )

 # These have to go before the -Wno- flags
 if(MSVC)
-  set(EXE_CFLAGS "/std:c++14")
+  set(EXE_CXX_FLAGS "/std:c++14")
 else(MSVC)
-  set(EXE_CFLAGS "-std=c++14")
+  set(EXE_CXX_FLAGS "-std=c++14")
 endif(MSVC)

-if(ZIG_STATIC)
-    set(EXE_CFLAGS "${EXE_CFLAGS} -DZIG_LINK_MODE=Static")
-else()
-    set(EXE_CFLAGS "${EXE_CFLAGS} -DZIG_LINK_MODE=Dynamic")
-endif()
-
 if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
    if(MSVC)
-        set(EXE_CFLAGS "${EXE_CFLAGS} /w")
+      set(EXE_CXX_FLAGS "${EXE_CXX_FLAGS} /w")
    else()
-        set(EXE_CFLAGS "${EXE_CFLAGS} -Werror -Wall")
+      set(EXE_CXX_FLAGS "${EXE_CXX_FLAGS} -Werror -Wall")
        # fallthrough support was added in GCC 7.0
        if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 7.0)
-            set(EXE_CFLAGS "${EXE_CFLAGS} -Werror=implicit-fallthrough")
+          set(EXE_CXX_FLAGS "${EXE_CXX_FLAGS} -Werror=implicit-fallthrough")
        endif()
        # GCC 9.2 and older are unable to detect valid variable initialization in some cases
        if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS_EQUAL 9.2)
-            set(EXE_CFLAGS "${EXE_CFLAGS} -Wno-maybe-uninitialized")
+          set(EXE_CXX_FLAGS "${EXE_CXX_FLAGS} -Wno-maybe-uninitialized")
        endif()
    endif()
 endif()

 if(MSVC)
-    set(EXE_CFLAGS "${EXE_CFLAGS}")
+  set(EXE_CXX_FLAGS "${EXE_CXX_FLAGS}")
 else()
-    set(EXE_CFLAGS "${EXE_CFLAGS} -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D_GNU_SOURCE -fvisibility-inlines-hidden -fno-exceptions -fno-rtti -Werror=type-limits -Wno-missing-braces -Wno-comment")
+  set(EXE_CXX_FLAGS "${EXE_CXX_FLAGS} -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D_GNU_SOURCE -fvisibility-inlines-hidden -fno-exceptions -fno-rtti -Werror=type-limits -Wno-missing-braces -Wno-comment")
    if(MINGW)
-        set(EXE_CFLAGS "${EXE_CFLAGS} -Wno-format")
+      set(EXE_CXX_FLAGS "${EXE_CXX_FLAGS} -Wno-format")
    endif()
 endif()

-if(MSVC)
-  if(NOT "${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
-    set(OPTIMIZED_C_FLAGS "/O2")
-  endif()
-else(MSVC)
-  set(OPTIMIZED_C_FLAGS "-std=c99 -O3")
-endif(MSVC)
-
 set(EXE_LDFLAGS " ")
 if(MSVC)
    set(EXE_LDFLAGS "${EXE_LDFLAGS} /STACK:16777216")
@@ -939,21 +685,10 @@ if(ZIG_STATIC)
    elseif(NOT MSVC)
        set(EXE_LDFLAGS "${EXE_LDFLAGS} -static")
    endif()
-else()
-    if(MINGW)
-        set(EXE_LDFLAGS "${EXE_LDFLAGS}")
-    endif()
-endif()
-
-if(ZIG_TEST_COVERAGE)
-    set(EXE_CFLAGS "${EXE_CFLAGS} -fprofile-arcs -ftest-coverage")
-    set(EXE_LDFLAGS "${EXE_LDFLAGS} -fprofile-arcs -ftest-coverage")
 endif()

 add_library(zigcpp STATIC ${ZIG_CPP_SOURCES})
-set_target_properties(zigcpp PROPERTIES
-    COMPILE_FLAGS ${EXE_CFLAGS}
-)
+set_target_properties(zigcpp PROPERTIES COMPILE_FLAGS ${EXE_CXX_FLAGS})

 target_link_libraries(zigcpp LINK_PUBLIC
    ${CLANG_LIBRARIES}
@@ -962,146 +697,73 @@ target_link_libraries(zigcpp LINK_PUBLIC
    ${CMAKE_THREAD_LIBS_INIT}
 )

-add_library(opt_c_util STATIC ${OPTIMIZED_C_SOURCES})
-set_target_properties(opt_c_util PROPERTIES
-    COMPILE_FLAGS "${OPTIMIZED_C_FLAGS}"
-)
-target_include_directories(opt_c_util PRIVATE
-    "${CMAKE_SOURCE_DIR}/deps/SoftFloat-3e-prebuilt"
-)
-
-add_library(zigstage1 STATIC ${STAGE1_SOURCES})
-set_target_properties(zigstage1 PROPERTIES
-    COMPILE_FLAGS ${EXE_CFLAGS}
-    LINK_FLAGS ${EXE_LDFLAGS}
-)
-target_link_libraries(zigstage1 LINK_PUBLIC
-    opt_c_util
-    ${SOFTFLOAT_LIBRARIES}
-    zigcpp
-)
-if(NOT MSVC)
-    target_link_libraries(zigstage1 LINK_PUBLIC ${LIBXML2})
-endif()
-
-if(ZIG_DIA_GUIDS_LIB)
-    target_link_libraries(zigstage1 LINK_PUBLIC ${ZIG_DIA_GUIDS_LIB})
-endif()
-
-if(MSVC OR MINGW)
-    target_link_libraries(zigstage1 LINK_PUBLIC version)
-endif()
-
-if("${ZIG_EXECUTABLE}" STREQUAL "")
-  add_executable(zig1 ${ZIG1_SOURCES})
-  set_target_properties(zig1 PROPERTIES
-      COMPILE_FLAGS ${EXE_CFLAGS}
-      LINK_FLAGS ${EXE_LDFLAGS}
-  )
-  target_link_libraries(zig1 zigstage1)
-endif()
-
 if(MSVC)
-  set(ZIG2_OBJECT "${CMAKE_BINARY_DIR}/zig2.obj")
+  set(ZIG1_COMPILE_FLAGS "/std:c99")
+  set(ZIG2_COMPILE_FLAGS "/std:c99")
+  set(ZIG2_LINK_FLAGS "/STACK:16777216")
 else()
-  set(ZIG2_OBJECT "${CMAKE_BINARY_DIR}/zig2.o")
-endif()
-if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
-  set(ZIG_RELEASE_ARG "")
-elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo")
-  set(ZIG_RELEASE_ARG -Drelease)
-else()
-  set(ZIG_RELEASE_ARG -Drelease -Dstrip)
-endif()
-if(ZIG_NO_LIB)
-  set(ZIG_NO_LIB_ARG "-Dno-lib")
-else()
-  set(ZIG_NO_LIB_ARG "")
-endif()
-if(ZIG_SINGLE_THREADED)
-  set(ZIG_SINGLE_THREADED_ARG "-fsingle-threaded")
-else()
-  set(ZIG_SINGLE_THREADED_ARG "")
-endif()
-if(ZIG_STATIC)
-  set(ZIG_STATIC_ARG "-Duse-zig-libcxx")
-else()
-  set(ZIG_STATIC_ARG "")
+  #set(ZIG1_COMPILE_FLAGS "-std=c99 -O2 -march=native")
+  set(ZIG1_COMPILE_FLAGS "-std=c99 -march=native")
+  set(ZIG2_COMPILE_FLAGS "-std=c99 -O2 -march=native")
+  set(ZIG2_LINK_FLAGS "-Wl,-z,stack-size=0x10000000")
 endif()

+add_executable(zig1 ${STAGE1_SOURCES})
+set_target_properties(zig1 PROPERTIES COMPILE_FLAGS ${ZIG1_COMPILE_FLAGS})
+#target_include_directories(zig1 PUBLIC "${CMAKE_SOURCE_DIR}/lib")
+target_link_libraries(zig1 LINK_PUBLIC m)
+
+
+set(ZIG2_C_SOURCE "${CMAKE_BINARY_DIR}/zig2.c")
 set(BUILD_ZIG2_ARGS
-    "src/stage1.zig"
-    --name zig2
-    --zig-lib-dir "${CMAKE_SOURCE_DIR}/lib"
-    "-femit-bin=${ZIG2_OBJECT}"
-    -fcompiler-rt
-    ${ZIG_SINGLE_THREADED_ARG}
-    -target native
-    -mcpu native
-    -lc
-    --pkg-begin build_options "${ZIG_CONFIG_ZIG_OUT}"
-    --pkg-end
+  "${CMAKE_SOURCE_DIR}/lib"
+  "${CMAKE_BINARY_DIR}/zig1-cache"
+  "${CMAKE_SOURCE_DIR}/stage1/zig1.wasm"
+  build-exe src/main.zig -ofmt=c -lc
+  --name zig2
+  --pkg-begin build_options "${ZIG_CONFIG_ZIG_OUT}"
+  --pkg-end
+  -target x86_64-linux-musl # TODO: autodetect in zig1.c
+  --color on # TODO: autodetect in zig1.c
+  -OReleaseFast
+)
+ 
+add_custom_command(
+  OUTPUT "${ZIG2_C_SOURCE}"
+  COMMAND zig1 ${BUILD_ZIG2_ARGS}
+  DEPENDS zig1 "${ZIG_STAGE2_SOURCES}"
+  COMMENT STATUS "Interpreting zig1.wasm to produce ${ZIG2_C_SOURCE}"
+  WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
 )

-if("${ZIG_EXECUTABLE}" STREQUAL "")
-  add_custom_command(
-    OUTPUT "${ZIG2_OBJECT}"
-    COMMAND zig1 ${BUILD_ZIG2_ARGS}
-    DEPENDS zig1 "${ZIG_STAGE2_SOURCES}"
-    COMMENT STATUS "Building stage2 object ${ZIG2_OBJECT}"
-    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
-  )
-  if (WIN32)
-    set(ZIG_EXECUTABLE "${CMAKE_BINARY_DIR}/zig2.exe")
-  else()
-    set(ZIG_EXECUTABLE "${CMAKE_BINARY_DIR}/zig2")
-  endif()
-else()
-  add_custom_command(
-    OUTPUT "${ZIG2_OBJECT}"
-    COMMAND "${ZIG_EXECUTABLE}" "build-obj" ${BUILD_ZIG2_ARGS}
-    DEPENDS ${ZIG_STAGE2_SOURCES}
-    COMMENT STATUS "Building stage2 component ${ZIG2_OBJECT}"
-    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
-  )
-endif()
+set(ZIG_COMPILER_RT_C_SOURCE "${CMAKE_BINARY_DIR}/compiler_rt.c")
+set(BUILD_COMPILER_RT_ARGS
+  "${CMAKE_SOURCE_DIR}/lib"
+  "${CMAKE_BINARY_DIR}/zig1-cache"
+  "${CMAKE_SOURCE_DIR}/stage1/zig1.wasm"
+  build-obj lib/compiler_rt.zig -ofmt=c
+  --name compiler_rt
+  -target x86_64-linux-musl # TODO: autodetect in zig1.c
+  --color on # TODO: autodetect in zig1.c
+  -OReleaseFast
+)
+ 
+add_custom_command(
+  OUTPUT "${ZIG_COMPILER_RT_C_SOURCE}"
+  COMMAND zig1 ${BUILD_COMPILER_RT_ARGS}
+  DEPENDS zig1 "${ZIG_STAGE2_SOURCES}"
+  COMMENT STATUS "Interpreting zig1.wasm to produce ${ZIG_COMPILER_RT_C_SOURCE}"
+  WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+)

-# cmake won't let us configure an executable without C sources.
-add_executable(zig2 "${CMAKE_SOURCE_DIR}/src/stage1/empty.cpp" "${ZIG2_OBJECT}")

+add_executable(zig2 ${ZIG2_C_SOURCE})
 set_target_properties(zig2 PROPERTIES
-    COMPILE_FLAGS ${EXE_CFLAGS}
-    LINK_FLAGS ${EXE_LDFLAGS}
-)
-target_link_libraries(zig2 zigstage1)
-if(MSVC)
-  target_link_libraries(zig2 ntdll.lib)
-elseif(MINGW)
-  target_link_libraries(zig2 ntdll)
-endif()
-
-set(ZIG_BUILD_ARGS
-    --zig-lib-dir "${CMAKE_SOURCE_DIR}/lib"
-    "-Dconfig_h=${ZIG_CONFIG_H_OUT}"
-    "-Denable-llvm"
-    ${ZIG_RELEASE_ARG}
-    ${ZIG_STATIC_ARG}
-    ${ZIG_NO_LIB_ARG}
-    ${ZIG_SINGLE_THREADED_ARG}
-    "-Dtarget=${ZIG_TARGET_TRIPLE}"
-    "-Dcpu=${ZIG_TARGET_MCPU}"
-    "-Dversion-string=${RESOLVED_ZIG_VERSION}"
+  COMPILE_FLAGS ${ZIG2_COMPILE_FLAGS}
+  LINK_FLAGS ${ZIG2_LINK_FLAGS}
 )

-add_custom_target(stage3 ALL
-    COMMAND zig2 build compile ${ZIG_BUILD_ARGS}
-    DEPENDS zig2
-    COMMENT STATUS "Building stage3"
-    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
-)

-install(CODE "set(ZIG_EXECUTABLE \"${ZIG_EXECUTABLE}\")")
-install(CODE "set(ZIG_BUILD_ARGS \"${ZIG_BUILD_ARGS}\")")
-install(CODE "set(CMAKE_INSTALL_PREFIX \"${CMAKE_INSTALL_PREFIX}\")")
-install(CODE "set(CMAKE_SOURCE_DIR \"${CMAKE_SOURCE_DIR}\")")
-install(SCRIPT "${CMAKE_SOURCE_DIR}/cmake/install.cmake")
+
+
+
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2016 Andrew Kelley
+ *
+ * This file is part of zig, which is MIT licensed.
+ * See http://opensource.org/licenses/MIT
+ */
+
+#ifndef ZIG_CONFIG_H
+#define ZIG_CONFIG_H
+
+// Used by zig0.cpp
+#define ZIG_VERSION_MAJOR @ZIG_VERSION_MAJOR@
+#define ZIG_VERSION_MINOR @ZIG_VERSION_MINOR@
+#define ZIG_VERSION_PATCH @ZIG_VERSION_PATCH@
+#define ZIG_VERSION_STRING "@ZIG_VERSION@"
+
+// Used by build.zig for communicating build information to self hosted build.
+#define ZIG_CMAKE_BINARY_DIR "@CMAKE_BINARY_DIR@"
+#define ZIG_LLVM_LINK_MODE "@LLVM_LINK_MODE@"
+#define ZIG_CMAKE_PREFIX_PATH "@ZIG_CMAKE_PREFIX_PATH@"
+#define ZIG_CXX_COMPILER "@CMAKE_CXX_COMPILER@"
+#define ZIG_LLD_INCLUDE_PATH "@LLD_INCLUDE_DIRS@"
+#define ZIG_LLD_LIBRARIES "@LLD_LIBRARIES@"
+#define ZIG_CLANG_LIBRARIES "@CLANG_LIBRARIES@"
+#define ZIG_LLVM_INCLUDE_PATH "@LLVM_INCLUDE_DIRS@"
+#define ZIG_LLVM_LIB_PATH "@LLVM_LIBDIRS@"
+#define ZIG_LLVM_LIBRARIES "@LLVM_LIBRARIES@"
+#define ZIG_DIA_GUIDS_LIB "@ZIG_DIA_GUIDS_LIB_ESCAPED@"
+
+#endif
@@ -1,13 +1,13 @@
-pub const have_llvm = true;
+pub const have_llvm = false;
 pub const llvm_has_m68k = false;
 pub const llvm_has_csky = false;
 pub const llvm_has_arc = false;
 pub const version: [:0]const u8 = "@RESOLVED_ZIG_VERSION@";
 pub const semver = @import("std").SemanticVersion.parse(version) catch unreachable;
-pub const enable_logging: bool = @ZIG_ENABLE_LOGGING_BOOL@;
+pub const enable_logging: bool = false;
 pub const enable_link_snapshots: bool = false;
 pub const enable_tracy = false;
 pub const value_tracing = false;
-pub const have_stage1 = true;
+pub const have_stage1 = false;
 pub const skip_non_native = false;
-pub const only_c = false;
+pub const only_c = true;
@@ -0,0 +1,4220 @@
+// TODO get rid of _GNU_SOURCE
+#define _GNU_SOURCE
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <math.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+enum wasi_errno_t {
+    WASI_ESUCCESS = 0,
+    WASI_E2BIG = 1,
+    WASI_EACCES = 2,
+    WASI_EADDRINUSE = 3,
+    WASI_EADDRNOTAVAIL = 4,
+    WASI_EAFNOSUPPORT = 5,
+    WASI_EAGAIN = 6,
+    WASI_EALREADY = 7,
+    WASI_EBADF = 8,
+    WASI_EBADMSG = 9,
+    WASI_EBUSY = 10,
+    WASI_ECANCELED = 11,
+    WASI_ECHILD = 12,
+    WASI_ECONNABORTED = 13,
+    WASI_ECONNREFUSED = 14,
+    WASI_ECONNRESET = 15,
+    WASI_EDEADLK = 16,
+    WASI_EDESTADDRREQ = 17,
+    WASI_EDOM = 18,
+    WASI_EDQUOT = 19,
+    WASI_EEXIST = 20,
+    WASI_EFAULT = 21,
+    WASI_EFBIG = 22,
+    WASI_EHOSTUNREACH = 23,
+    WASI_EIDRM = 24,
+    WASI_EILSEQ = 25,
+    WASI_EINPROGRESS = 26,
+    WASI_EINTR = 27,
+    WASI_EINVAL = 28,
+    WASI_EIO = 29,
+    WASI_EISCONN = 30,
+    WASI_EISDIR = 31,
+    WASI_ELOOP = 32,
+    WASI_EMFILE = 33,
+    WASI_EMLINK = 34,
+    WASI_EMSGSIZE = 35,
+    WASI_EMULTIHOP = 36,
+    WASI_ENAMETOOLONG = 37,
+    WASI_ENETDOWN = 38,
+    WASI_ENETRESET = 39,
+    WASI_ENETUNREACH = 40,
+    WASI_ENFILE = 41,
+    WASI_ENOBUFS = 42,
+    WASI_ENODEV = 43,
+    WASI_ENOENT = 44,
+    WASI_ENOEXEC = 45,
+    WASI_ENOLCK = 46,
+    WASI_ENOLINK = 47,
+    WASI_ENOMEM = 48,
+    WASI_ENOMSG = 49,
+    WASI_ENOPROTOOPT = 50,
+    WASI_ENOSPC = 51,
+    WASI_ENOSYS = 52,
+    WASI_ENOTCONN = 53,
+    WASI_ENOTDIR = 54,
+    WASI_ENOTEMPTY = 55,
+    WASI_ENOTRECOVERABLE = 56,
+    WASI_ENOTSOCK = 57,
+    WASI_EOPNOTSUPP = 58,
+    WASI_ENOTTY = 59,
+    WASI_ENXIO = 60,
+    WASI_EOVERFLOW = 61,
+    WASI_EOWNERDEAD = 62,
+    WASI_EPERM = 63,
+    WASI_EPIPE = 64,
+    WASI_EPROTO = 65,
+    WASI_EPROTONOSUPPORT = 66,
+    WASI_EPROTOTYPE = 67,
+    WASI_ERANGE = 68,
+    WASI_EROFS = 69,
+    WASI_ESPIPE = 70,
+    WASI_ESRCH = 71,
+    WASI_ESTALE = 72,
+    WASI_ETIMEDOUT = 73,
+    WASI_ETXTBSY = 74,
+    WASI_EXDEV = 75,
+    WASI_ENOTCAPABLE = 76,
+};
+
+static void panic(const char *msg) {
+    fprintf(stderr, "%s\n", msg);
+    abort();
+}
+
+static uint32_t min_u32(uint32_t a, uint32_t b) {
+    return (a < b) ? a : b;
+}
+
+static uint32_t rotl32(uint32_t n, unsigned c) {
+    const unsigned mask = CHAR_BIT * sizeof(n) - 1;
+    c &= mask & 31;
+    return (n << c) | (n >> ((-c) & mask));
+}
+
+static uint32_t rotr32(uint32_t n, unsigned c) {
+    const unsigned mask = CHAR_BIT * sizeof(n) - 1;
+    c &= mask & 31;
+    return (n >> c) | (n << ((-c) & mask));
+}
+
+static uint64_t rotl64(uint64_t n, unsigned c) {
+    const unsigned mask = CHAR_BIT * sizeof(n) - 1;
+    c &= mask & 63;
+    return (n << c) | (n >> ((-c) & mask));
+}
+
+static uint64_t rotr64(uint64_t n, unsigned c) {
+    const unsigned mask = CHAR_BIT * sizeof(n) - 1;
+    c &= mask & 63;
+    return (n >> c) | (n << ((-c) & mask));
+}
+
+static void *arena_alloc(size_t n) {
+    void *ptr = malloc(n);
+    if (!ptr) panic("out of memory");
+    return ptr;
+}
+
+static void *arena_realloc(void *ptr, size_t new_n) {
+    void *new_ptr = realloc(ptr, new_n);
+    if (!new_ptr) panic("out of memory");
+    return new_ptr;
+}
+
+static int err_wrap(const char *prefix, int rc) {
+    if (rc == -1) {
+        perror(prefix);
+        abort();
+    }
+    return rc;
+}
+
+static bool bs_isSet(const uint32_t *bitset, uint32_t index) {
+    return (bitset[index >> 5] >> (index & 0x1f)) & 1;
+}
+static void bs_set(uint32_t *bitset, uint32_t index) {
+    bitset[index >> 5] |=  ((uint32_t)1 << (index & 0x1f));
+}
+static void bs_unset(uint32_t *bitset, uint32_t index) {
+    bitset[index >> 5] &= ~((uint32_t)1 << (index & 0x1f));
+}
+static void bs_setValue(uint32_t *bitset, uint32_t index, bool value) {
+    if (value) bs_set(bitset, index); else bs_unset(bitset, index);
+}
+
+struct ByteSlice {
+    char *ptr;
+    size_t len;
+};
+
+static struct ByteSlice read_file_alloc(const char *file_path) {
+    FILE *f = fopen(file_path, "rb");
+    if (!f) {
+        fprintf(stderr, "failed to read %s: ", file_path);
+        perror("");
+        abort();
+    }
+    if (fseek(f, 0L, SEEK_END) == -1) panic("failed to seek");
+    struct ByteSlice res;
+    res.len = ftell(f);
+    res.ptr = malloc(res.len);
+    rewind(f);
+    size_t amt_read = fread(res.ptr, 1, res.len, f);
+    if (amt_read != res.len) panic("short read");
+    fclose(f);
+    return res;
+}
+
+
+struct Preopen {
+    int wasi_fd; 
+    int host_fd;
+    const char *name;
+    size_t name_len;
+};
+
+static struct Preopen preopens_buffer[10];
+static size_t preopens_len = 0;
+
+static void add_preopen(int wasi_fd, const char *name, int host_fd) {
+    preopens_buffer[preopens_len].wasi_fd = wasi_fd;
+    preopens_buffer[preopens_len].host_fd = host_fd;
+    preopens_buffer[preopens_len].name = name;
+    preopens_buffer[preopens_len].name_len = strlen(name);
+    preopens_len += 1;
+}
+
+static const struct Preopen *find_preopen(int32_t wasi_fd) {
+    for (size_t i = 0; i < preopens_len; i += 1) {
+        const struct Preopen *preopen = &preopens_buffer[i];
+        if (preopen->wasi_fd == wasi_fd) {
+            return preopen;
+        }
+    }
+    return NULL;
+}
+
+static const size_t max_memory = 2ul * 1024ul * 1024ul * 1024ul; // 2 GiB
+
+static uint16_t read_u16_le(const char *ptr) {
+    const uint8_t *u8_ptr = (const uint8_t *)ptr;
+    return
+        (((uint64_t)u8_ptr[0]) << 0x00) |
+        (((uint64_t)u8_ptr[1]) << 0x08);
+}
+
+static int16_t read_i16_le(const char *ptr) {
+    return read_u16_le(ptr);
+}
+
+static uint32_t read_u32_le(const char *ptr) {
+    const uint8_t *u8_ptr = (const uint8_t *)ptr;
+    return
+        (((uint64_t)u8_ptr[0]) << 0x00) |
+        (((uint64_t)u8_ptr[1]) << 0x08) |
+        (((uint64_t)u8_ptr[2]) << 0x10) |
+        (((uint64_t)u8_ptr[3]) << 0x18);
+}
+
+static uint32_t read_i32_le(const char *ptr) {
+    return read_u32_le(ptr);
+}
+
+static uint64_t read_u64_le(const char *ptr) {
+    const uint8_t *u8_ptr = (const uint8_t *)ptr;
+    return
+        (((uint64_t)u8_ptr[0]) << 0x00) |
+        (((uint64_t)u8_ptr[1]) << 0x08) |
+        (((uint64_t)u8_ptr[2]) << 0x10) |
+        (((uint64_t)u8_ptr[3]) << 0x18) |
+        (((uint64_t)u8_ptr[4]) << 0x20) |
+        (((uint64_t)u8_ptr[5]) << 0x28) |
+        (((uint64_t)u8_ptr[6]) << 0x30) |
+        (((uint64_t)u8_ptr[7]) << 0x38);
+}
+
+static void write_u16_le(char *ptr, uint16_t x) {
+    uint8_t *u8_ptr = (uint8_t*)ptr;
+    u8_ptr[0] = (x >> 0x00);
+    u8_ptr[1] = (x >> 0x08);
+}
+
+static void write_u32_le(char *ptr, uint32_t x) {
+    uint8_t *u8_ptr = (uint8_t*)ptr;
+    u8_ptr[0] = (x >> 0x00);
+    u8_ptr[1] = (x >> 0x08);
+    u8_ptr[2] = (x >> 0x10);
+    u8_ptr[3] = (x >> 0x18);
+}
+
+static void write_u64_le(char *ptr, uint64_t x) {
+    uint8_t *u8_ptr = (uint8_t*)ptr;
+    u8_ptr[0] = (x >> 0x00);
+    u8_ptr[1] = (x >> 0x08);
+    u8_ptr[2] = (x >> 0x10);
+    u8_ptr[3] = (x >> 0x18);
+    u8_ptr[4] = (x >> 0x20);
+    u8_ptr[5] = (x >> 0x28);
+    u8_ptr[6] = (x >> 0x30);
+    u8_ptr[7] = (x >> 0x38);
+}
+
+static uint32_t read32_uleb128(const char *ptr, uint32_t *i) {
+    uint32_t result = 0;
+    uint32_t shift = 0;
+
+    for (;;) {
+        uint32_t byte = ptr[*i];
+        *i += 1;
+        result |= ((byte & 0x7f) << shift);
+        shift += 7;
+        if ((byte & 0x80) == 0) return result;
+        if (shift >= 32) panic("read32_uleb128 failed");
+    }
+}
+
+static int64_t read64_ileb128(const char *ptr, uint32_t *i) {
+    int64_t result = 0;
+    uint32_t shift = 0;
+
+    for (;;) {
+        uint64_t byte = ptr[*i];
+        *i += 1;
+        result |= ((byte & 0x7f) << shift);
+        shift += 7;
+        if ((byte & 0x80) == 0) {
+            if ((byte & 0x40) && (shift < 64)) {
+                uint64_t extend = 0;
+                result |= (~extend << shift);
+            }
+            return result;
+        }
+        if (shift >= 64) panic("read64_ileb128 failed");
+    }
+}
+
+static int32_t read32_ileb128(const char *ptr, uint32_t *i) {
+    return read64_ileb128(ptr, i);
+}
+
+static struct ByteSlice read_name(char *ptr, uint32_t *i) {
+    uint32_t len = read32_uleb128(ptr, i);
+    struct ByteSlice res;
+    res.ptr = ptr + *i;
+    res.len = len;
+    *i += len;
+    return res;
+}
+
+enum Section {
+    Section_custom,
+    Section_type,
+    Section_import,
+    Section_function,
+    Section_table,
+    Section_memory,
+    Section_global,
+    Section_export,
+    Section_start,
+    Section_element,
+    Section_code,
+    Section_data,
+    Section_data_count,
+};
+
+enum Op {
+    Op_unreachable,
+    Op_br_void,
+    Op_br_32,
+    Op_br_64,
+    Op_br_if_nez_void,
+    Op_br_if_nez_32,
+    Op_br_if_nez_64,
+    Op_br_if_eqz_void,
+    Op_br_if_eqz_32,
+    Op_br_if_eqz_64,
+    Op_br_table_void,
+    Op_br_table_32,
+    Op_br_table_64,
+    Op_return_void,
+    Op_return_32,
+    Op_return_64,
+    Op_call,
+    Op_drop_32,
+    Op_drop_64,
+    Op_select_32,
+    Op_select_64,
+    Op_local_get_32,
+    Op_local_get_64,
+    Op_local_set_32,
+    Op_local_set_64,
+    Op_local_tee_32,
+    Op_local_tee_64,
+    Op_global_get_0_32,
+    Op_global_get_32,
+    Op_global_set_0_32,
+    Op_global_set_32,
+    Op_const_32,
+    Op_const_64,
+    Op_add_32,
+    Op_and_32,
+    Op_wasm,
+    Op_wasm_prefixed,
+};
+
+enum WasmOp {
+    WasmOp_unreachable = 0x00,
+    WasmOp_nop = 0x01,
+    WasmOp_block = 0x02,
+    WasmOp_loop = 0x03,
+    WasmOp_if = 0x04,
+    WasmOp_else = 0x05,
+    WasmOp_end = 0x0B,
+    WasmOp_br = 0x0C,
+    WasmOp_br_if = 0x0D,
+    WasmOp_br_table = 0x0E,
+    WasmOp_return = 0x0F,
+    WasmOp_call = 0x10,
+    WasmOp_call_indirect = 0x11,
+    WasmOp_drop = 0x1A,
+    WasmOp_select = 0x1B,
+    WasmOp_local_get = 0x20,
+    WasmOp_local_set = 0x21,
+    WasmOp_local_tee = 0x22,
+    WasmOp_global_get = 0x23,
+    WasmOp_global_set = 0x24,
+    WasmOp_i32_load = 0x28,
+    WasmOp_i64_load = 0x29,
+    WasmOp_f32_load = 0x2A,
+    WasmOp_f64_load = 0x2B,
+    WasmOp_i32_load8_s = 0x2C,
+    WasmOp_i32_load8_u = 0x2D,
+    WasmOp_i32_load16_s = 0x2E,
+    WasmOp_i32_load16_u = 0x2F,
+    WasmOp_i64_load8_s = 0x30,
+    WasmOp_i64_load8_u = 0x31,
+    WasmOp_i64_load16_s = 0x32,
+    WasmOp_i64_load16_u = 0x33,
+    WasmOp_i64_load32_s = 0x34,
+    WasmOp_i64_load32_u = 0x35,
+    WasmOp_i32_store = 0x36,
+    WasmOp_i64_store = 0x37,
+    WasmOp_f32_store = 0x38,
+    WasmOp_f64_store = 0x39,
+    WasmOp_i32_store8 = 0x3A,
+    WasmOp_i32_store16 = 0x3B,
+    WasmOp_i64_store8 = 0x3C,
+    WasmOp_i64_store16 = 0x3D,
+    WasmOp_i64_store32 = 0x3E,
+    WasmOp_memory_size = 0x3F,
+    WasmOp_memory_grow = 0x40,
+    WasmOp_i32_const = 0x41,
+    WasmOp_i64_const = 0x42,
+    WasmOp_f32_const = 0x43,
+    WasmOp_f64_const = 0x44,
+    WasmOp_i32_eqz = 0x45,
+    WasmOp_i32_eq = 0x46,
+    WasmOp_i32_ne = 0x47,
+    WasmOp_i32_lt_s = 0x48,
+    WasmOp_i32_lt_u = 0x49,
+    WasmOp_i32_gt_s = 0x4A,
+    WasmOp_i32_gt_u = 0x4B,
+    WasmOp_i32_le_s = 0x4C,
+    WasmOp_i32_le_u = 0x4D,
+    WasmOp_i32_ge_s = 0x4E,
+    WasmOp_i32_ge_u = 0x4F,
+    WasmOp_i64_eqz = 0x50,
+    WasmOp_i64_eq = 0x51,
+    WasmOp_i64_ne = 0x52,
+    WasmOp_i64_lt_s = 0x53,
+    WasmOp_i64_lt_u = 0x54,
+    WasmOp_i64_gt_s = 0x55,
+    WasmOp_i64_gt_u = 0x56,
+    WasmOp_i64_le_s = 0x57,
+    WasmOp_i64_le_u = 0x58,
+    WasmOp_i64_ge_s = 0x59,
+    WasmOp_i64_ge_u = 0x5A,
+    WasmOp_f32_eq = 0x5B,
+    WasmOp_f32_ne = 0x5C,
+    WasmOp_f32_lt = 0x5D,
+    WasmOp_f32_gt = 0x5E,
+    WasmOp_f32_le = 0x5F,
+    WasmOp_f32_ge = 0x60,
+    WasmOp_f64_eq = 0x61,
+    WasmOp_f64_ne = 0x62,
+    WasmOp_f64_lt = 0x63,
+    WasmOp_f64_gt = 0x64,
+    WasmOp_f64_le = 0x65,
+    WasmOp_f64_ge = 0x66,
+    WasmOp_i32_clz = 0x67,
+    WasmOp_i32_ctz = 0x68,
+    WasmOp_i32_popcnt = 0x69,
+    WasmOp_i32_add = 0x6A,
+    WasmOp_i32_sub = 0x6B,
+    WasmOp_i32_mul = 0x6C,
+    WasmOp_i32_div_s = 0x6D,
+    WasmOp_i32_div_u = 0x6E,
+    WasmOp_i32_rem_s = 0x6F,
+    WasmOp_i32_rem_u = 0x70,
+    WasmOp_i32_and = 0x71,
+    WasmOp_i32_or = 0x72,
+    WasmOp_i32_xor = 0x73,
+    WasmOp_i32_shl = 0x74,
+    WasmOp_i32_shr_s = 0x75,
+    WasmOp_i32_shr_u = 0x76,
+    WasmOp_i32_rotl = 0x77,
+    WasmOp_i32_rotr = 0x78,
+    WasmOp_i64_clz = 0x79,
+    WasmOp_i64_ctz = 0x7A,
+    WasmOp_i64_popcnt = 0x7B,
+    WasmOp_i64_add = 0x7C,
+    WasmOp_i64_sub = 0x7D,
+    WasmOp_i64_mul = 0x7E,
+    WasmOp_i64_div_s = 0x7F,
+    WasmOp_i64_div_u = 0x80,
+    WasmOp_i64_rem_s = 0x81,
+    WasmOp_i64_rem_u = 0x82,
+    WasmOp_i64_and = 0x83,
+    WasmOp_i64_or = 0x84,
+    WasmOp_i64_xor = 0x85,
+    WasmOp_i64_shl = 0x86,
+    WasmOp_i64_shr_s = 0x87,
+    WasmOp_i64_shr_u = 0x88,
+    WasmOp_i64_rotl = 0x89,
+    WasmOp_i64_rotr = 0x8A,
+    WasmOp_f32_abs = 0x8B,
+    WasmOp_f32_neg = 0x8C,
+    WasmOp_f32_ceil = 0x8D,
+    WasmOp_f32_floor = 0x8E,
+    WasmOp_f32_trunc = 0x8F,
+    WasmOp_f32_nearest = 0x90,
+    WasmOp_f32_sqrt = 0x91,
+    WasmOp_f32_add = 0x92,
+    WasmOp_f32_sub = 0x93,
+    WasmOp_f32_mul = 0x94,
+    WasmOp_f32_div = 0x95,
+    WasmOp_f32_min = 0x96,
+    WasmOp_f32_max = 0x97,
+    WasmOp_f32_copysign = 0x98,
+    WasmOp_f64_abs = 0x99,
+    WasmOp_f64_neg = 0x9A,
+    WasmOp_f64_ceil = 0x9B,
+    WasmOp_f64_floor = 0x9C,
+    WasmOp_f64_trunc = 0x9D,
+    WasmOp_f64_nearest = 0x9E,
+    WasmOp_f64_sqrt = 0x9F,
+    WasmOp_f64_add = 0xA0,
+    WasmOp_f64_sub = 0xA1,
+    WasmOp_f64_mul = 0xA2,
+    WasmOp_f64_div = 0xA3,
+    WasmOp_f64_min = 0xA4,
+    WasmOp_f64_max = 0xA5,
+    WasmOp_f64_copysign = 0xA6,
+    WasmOp_i32_wrap_i64 = 0xA7,
+    WasmOp_i32_trunc_f32_s = 0xA8,
+    WasmOp_i32_trunc_f32_u = 0xA9,
+    WasmOp_i32_trunc_f64_s = 0xAA,
+    WasmOp_i32_trunc_f64_u = 0xAB,
+    WasmOp_i64_extend_i32_s = 0xAC,
+    WasmOp_i64_extend_i32_u = 0xAD,
+    WasmOp_i64_trunc_f32_s = 0xAE,
+    WasmOp_i64_trunc_f32_u = 0xAF,
+    WasmOp_i64_trunc_f64_s = 0xB0,
+    WasmOp_i64_trunc_f64_u = 0xB1,
+    WasmOp_f32_convert_i32_s = 0xB2,
+    WasmOp_f32_convert_i32_u = 0xB3,
+    WasmOp_f32_convert_i64_s = 0xB4,
+    WasmOp_f32_convert_i64_u = 0xB5,
+    WasmOp_f32_demote_f64 = 0xB6,
+    WasmOp_f64_convert_i32_s = 0xB7,
+    WasmOp_f64_convert_i32_u = 0xB8,
+    WasmOp_f64_convert_i64_s = 0xB9,
+    WasmOp_f64_convert_i64_u = 0xBA,
+    WasmOp_f64_promote_f32 = 0xBB,
+    WasmOp_i32_reinterpret_f32 = 0xBC,
+    WasmOp_i64_reinterpret_f64 = 0xBD,
+    WasmOp_f32_reinterpret_i32 = 0xBE,
+    WasmOp_f64_reinterpret_i64 = 0xBF,
+    WasmOp_i32_extend8_s = 0xC0,
+    WasmOp_i32_extend16_s = 0xC1,
+    WasmOp_i64_extend8_s = 0xC2,
+    WasmOp_i64_extend16_s = 0xC3,
+    WasmOp_i64_extend32_s = 0xC4,
+
+    WasmOp_prefixed = 0xFC,
+};
+
+enum WasmPrefixedOp {
+    WasmPrefixedOp_i32_trunc_sat_f32_s = 0x00,
+    WasmPrefixedOp_i32_trunc_sat_f32_u = 0x01,
+    WasmPrefixedOp_i32_trunc_sat_f64_s = 0x02,
+    WasmPrefixedOp_i32_trunc_sat_f64_u = 0x03,
+    WasmPrefixedOp_i64_trunc_sat_f32_s = 0x04,
+    WasmPrefixedOp_i64_trunc_sat_f32_u = 0x05,
+    WasmPrefixedOp_i64_trunc_sat_f64_s = 0x06,
+    WasmPrefixedOp_i64_trunc_sat_f64_u = 0x07,
+    WasmPrefixedOp_memory_init = 0x08,
+    WasmPrefixedOp_data_drop = 0x09,
+    WasmPrefixedOp_memory_copy = 0x0A,
+    WasmPrefixedOp_memory_fill = 0x0B,
+    WasmPrefixedOp_table_init = 0x0C,
+    WasmPrefixedOp_elem_drop = 0x0D,
+    WasmPrefixedOp_table_copy = 0x0E,
+    WasmPrefixedOp_table_grow = 0x0F,
+    WasmPrefixedOp_table_size = 0x10,
+    WasmPrefixedOp_table_fill = 0x11,
+};
+
+static const uint32_t wasm_page_size = 64 * 1024;
+
+struct ProgramCounter {
+    uint32_t opcode;
+    uint32_t operand;
+};
+
+struct TypeInfo {
+    uint32_t param_count;
+    // bitset with param_count bits, indexed from lsb, 0 -> 32-bit, 1 -> 64-bit
+    uint32_t param_types;
+    uint32_t result_count;
+    // bitset with result_count bits, indexed from lsb, 0 -> 32-bit, 1 -> 64-bit
+    uint32_t result_types;
+};
+
+struct Function {
+    // Index to start of code in opcodes/operands.
+    struct ProgramCounter entry_pc;
+    uint32_t type_idx;
+    uint32_t locals_count;
+    // multi-word bitset with vm->types[type_idx].param_count + locals_count bits
+    // indexed from lsb of the first element, 0 -> 32-bit, 1 -> 64-bit
+    uint32_t *local_types;
+};
+
+enum ImpMod {
+    ImpMod_wasi_snapshot_preview1,
+};
+
+enum ImpName {
+    ImpName_args_get,
+    ImpName_args_sizes_get,
+    ImpName_clock_time_get,
+    ImpName_debug,
+    ImpName_debug_slice,
+    ImpName_environ_get,
+    ImpName_environ_sizes_get,
+    ImpName_fd_close,
+    ImpName_fd_fdstat_get,
+    ImpName_fd_filestat_get,
+    ImpName_fd_filestat_set_size,
+    ImpName_fd_filestat_set_times,
+    ImpName_fd_pread,
+    ImpName_fd_prestat_dir_name,
+    ImpName_fd_prestat_get,
+    ImpName_fd_pwrite,
+    ImpName_fd_read,
+    ImpName_fd_readdir,
+    ImpName_fd_write,
+    ImpName_path_create_directory,
+    ImpName_path_filestat_get,
+    ImpName_path_open,
+    ImpName_path_remove_directory,
+    ImpName_path_rename,
+    ImpName_path_unlink_file,
+    ImpName_proc_exit,
+    ImpName_random_get,
+};
+
+struct Import {
+    enum ImpMod mod;
+    enum ImpName name;
+    uint32_t type_idx;
+};
+
+struct VirtualMachine {
+    uint64_t *stack;
+    /// Points to one after the last stack item.
+    uint32_t stack_top;
+    struct ProgramCounter pc;
+    uint32_t memory_len;
+    const char *mod_ptr;
+    uint8_t *opcodes;
+    uint32_t *operands;
+    struct Function *functions;
+    /// Type index to start of type in module_bytes.
+    struct TypeInfo *types;
+    uint64_t *globals;
+    char *memory;
+    struct Import *imports;
+    uint32_t imports_len;
+    char **args;
+    uint32_t *table;
+};
+
+static int to_host_fd(int32_t wasi_fd) {
+    const struct Preopen *preopen = find_preopen(wasi_fd);
+    if (!preopen) return wasi_fd;
+    return preopen->host_fd;
+}
+
+static enum wasi_errno_t to_wasi_err(int err) {
+    switch (err) {
+        case EACCES: return WASI_EACCES;
+        case EDQUOT: return WASI_EDQUOT;
+        case EIO: return WASI_EIO;
+        case EFBIG: return WASI_EFBIG;
+        case ENOSPC: return WASI_ENOSPC;
+        case EPIPE: return WASI_EPIPE;
+        case EBADF: return WASI_EBADF;
+        case ENOMEM: return WASI_ENOMEM;
+        case ENOENT: return WASI_ENOENT;
+        case EEXIST: return WASI_EEXIST;
+        default:
+        fprintf(stderr, "unexpected errno: %s\n", strerror(err));
+        abort();
+    };
+}
+
+/// fn args_sizes_get(argc: *usize, argv_buf_size: *usize) errno_t;
+static enum wasi_errno_t wasi_args_sizes_get(struct VirtualMachine *vm,
+    uint32_t argc, uint32_t argv_buf_size)
+{
+    uint32_t args_len = 0;
+    size_t buf_size = 0;
+    while (vm->args[args_len]) {
+        buf_size += strlen(vm->args[args_len]) + 1;
+        args_len += 1;
+    }
+    write_u32_le(vm->memory + argc, args_len);
+    write_u32_le(vm->memory + argv_buf_size, buf_size);
+    return WASI_ESUCCESS;
+}
+
+/// extern fn args_get(argv: [*][*:0]u8, argv_buf: [*]u8) errno_t;
+static enum wasi_errno_t wasi_args_get(struct VirtualMachine *vm,
+    uint32_t argv, uint32_t argv_buf) 
+{
+    panic("TODO implement wasi_args_get");
+    //var argv_buf_i: usize = 0;
+    //for (vm->args) |arg, arg_i| {
+    //    // Write the arg to the buffer.
+    //    const argv_ptr = argv_buf + argv_buf_i;
+    //    const arg_len = mem.span(arg).len + 1;
+    //    mem.copy(u8, vm->memory[argv_buf + argv_buf_i ..], arg[0..arg_len]);
+    //    argv_buf_i += arg_len;
+
+    //    write_u32_le(vm->memory[argv + 4 * arg_i ..][0..4], @intCast(u32, argv_ptr));
+    //}
+    return WASI_ESUCCESS;
+}
+
+/// extern fn random_get(buf: [*]u8, buf_len: usize) errno_t;
+static enum wasi_errno_t wasi_random_get(struct VirtualMachine *vm,
+    uint32_t buf, uint32_t buf_len) 
+{
+    panic("TODO implement wasi_random_get");
+    //const host_buf = vm->memory[buf..][0..buf_len];
+    //std.crypto.random.bytes(host_buf);
+    return WASI_ESUCCESS;
+}
+
+/// fn fd_prestat_get(fd: fd_t, buf: *prestat_t) errno_t;
+/// const prestat_t = extern struct {
+///     pr_type: u8,
+///     u: usize,
+/// };
+static enum wasi_errno_t wasi_fd_prestat_get(struct VirtualMachine *vm,
+    int32_t fd, uint32_t buf)
+{
+    panic("TODO implement wasi_fd_prestat_get");
+    //const preopen = findPreopen(fd) orelse return .BADF;
+    //write_u32_le(vm->memory[buf + 0 ..][0..4], 0);
+    //write_u32_le(vm->memory[buf + 4 ..][0..4], @intCast(u32, preopen.name.len));
+    return WASI_ESUCCESS;
+}
+
+/// fn fd_prestat_dir_name(fd: fd_t, path: [*]u8, path_len: usize) errno_t;
+static enum wasi_errno_t wasi_fd_prestat_dir_name(struct VirtualMachine *vm,
+        int32_t fd, uint32_t path, uint32_t path_len)
+{
+    panic("TODO implement wasi_fd_prestat_dir_name");
+    //const preopen = findPreopen(fd) orelse return .BADF;
+    //assert(path_len == preopen.name.len);
+    //mem.copy(u8, vm->memory[path..], preopen.name);
+    return WASI_ESUCCESS;
+}
+
+/// extern fn fd_close(fd: fd_t) errno_t;
+static enum wasi_errno_t wasi_fd_close(struct VirtualMachine *vm, int32_t fd) {
+    panic("TODO implement wasi_fd_close");
+    //_ = vm;
+    //const host_fd = toHostFd(fd);
+    //os.close(host_fd);
+    return WASI_ESUCCESS;
+}
+
+static enum wasi_errno_t wasi_fd_read(
+    struct VirtualMachine *vm,
+    int32_t fd,
+    uint32_t iovs, // [*]const iovec_t
+    uint32_t iovs_len, // usize
+    uint32_t nread // *usize
+) {
+    panic("TODO implement wasi_fd_read");
+    //const host_fd = toHostFd(fd);
+    //var i: u32 = 0;
+    //var total_read: usize = 0;
+    //while (i < iovs_len) : (i += 1) {
+    //    uint32_t ptr = read_u32_le(vm->memory + iovs + i * 8 + 0);
+    //    uint32_t len = read_u32_le(vm->memory + iovs + i * 8 + 4);
+    //    const buf = vm->memory[ptr..][0..len];
+    //    const read = os.read(host_fd, buf) catch |err| return toWasiError(err);
+    //    trace_log.debug("read {d} bytes out of {d}", .{ read, buf.len });
+    //    total_read += read;
+    //    if (read != buf.len) break;
+    //}
+    //write_u32_le(vm->memory[nread..][0..4], @intCast(u32, total_read));
+    return WASI_ESUCCESS;
+}
+
+/// extern fn fd_write(fd: fd_t, iovs: [*]const ciovec_t, iovs_len: usize, nwritten: *usize) errno_t;
+/// const ciovec_t = extern struct {
+///     base: [*]const u8,
+///     len: usize,
+/// };
+static enum wasi_errno_t wasi_fd_write(struct VirtualMachine *vm,
+        int32_t fd, uint32_t iovs, uint32_t iovs_len, uint32_t nwritten)
+{
+    int host_fd = to_host_fd(fd);
+    size_t total_written = 0;
+    for (uint32_t i = 0; i < iovs_len; i += 1) {
+        uint32_t ptr = read_u32_le(vm->memory + iovs + i * 8 + 0);
+        uint32_t len = read_u32_le(vm->memory + iovs + i * 8 + 4);
+        ssize_t written = write(host_fd, vm->memory + ptr, len);
+        if (written < 0) return to_wasi_err(errno);
+        total_written += written;
+        if (written != len) break;
+    }
+    write_u32_le(vm->memory + nwritten, total_written);
+    return WASI_ESUCCESS;
+}
+
+static enum wasi_errno_t wasi_fd_pwrite(
+    struct VirtualMachine *vm,
+    int32_t fd,
+    uint32_t iovs, // [*]const ciovec_t
+    uint32_t iovs_len, // usize
+    uint64_t offset, // wasi.filesize_t,
+    uint32_t written_ptr // *usize
+) {
+    panic("TODO implement wasi_fd_pwrite");
+    //const host_fd = toHostFd(fd);
+    //var i: u32 = 0;
+    //var written: usize = 0;
+    //while (i < iovs_len) : (i += 1) {
+    //    uint32_t ptr = read_u32_le(vm->memory + iovs + i * 8 + 0);
+    //    uint32_t len = read_u32_le(vm->memory + iovs + i * 8 + 4);
+    //    const buf = vm->memory[ptr..][0..len];
+    //    const w = os.pwrite(host_fd, buf, offset + written) catch |err| return toWasiError(err);
+    //    written += w;
+    //    if (w != buf.len) break;
+    //}
+    //write_u32_le(vm->memory[written_ptr..][0..4], @intCast(u32, written));
+    return WASI_ESUCCESS;
+}
+
+///extern fn path_open(
+///    dirfd: fd_t,
+///    dirflags: lookupflags_t,
+///    path: [*]const u8,
+///    path_len: usize,
+///    oflags: oflags_t,
+///    fs_rights_base: rights_t,
+///    fs_rights_inheriting: rights_t,
+///    fs_flags: fdflags_t,
+///    fd: *fd_t,
+///) errno_t;
+static enum wasi_errno_t wasi_path_open(
+    struct VirtualMachine *vm,
+    int32_t dirfd,
+    uint32_t dirflags, // wasi.lookupflags_t,
+    uint32_t path,
+    uint32_t path_len,
+    uint16_t oflags, // wasi.oflags_t,
+    uint64_t fs_rights_base, // wasi.rights_t,
+    uint64_t fs_rights_inheriting, // wasi.rights_t,
+    uint16_t fs_flags, // wasi.fdflags_t,
+    uint32_t fd
+) {
+    panic("TODO implement wasi_path_open");
+    //const sub_path = vm->memory[path..][0..path_len];
+    //const host_fd = toHostFd(dirfd);
+    //var flags: u32 = @as(u32, if (oflags & wasi.O.CREAT != 0) os.O.CREAT else 0) |
+    //    @as(u32, if (oflags & wasi.O.DIRECTORY != 0) os.O.DIRECTORY else 0) |
+    //    @as(u32, if (oflags & wasi.O.EXCL != 0) os.O.EXCL else 0) |
+    //    @as(u32, if (oflags & wasi.O.TRUNC != 0) os.O.TRUNC else 0) |
+    //    @as(u32, if (fs_flags & wasi.FDFLAG.APPEND != 0) os.O.APPEND else 0) |
+    //    @as(u32, if (fs_flags & wasi.FDFLAG.DSYNC != 0) os.O.DSYNC else 0) |
+    //    @as(u32, if (fs_flags & wasi.FDFLAG.NONBLOCK != 0) os.O.NONBLOCK else 0) |
+    //    @as(u32, if (fs_flags & wasi.FDFLAG.SYNC != 0) os.O.SYNC else 0);
+    //if ((fs_rights_base & wasi.RIGHT.FD_READ != 0) and
+    //    (fs_rights_base & wasi.RIGHT.FD_WRITE != 0))
+    //{
+    //    flags |= os.O.RDWR;
+    //} else if (fs_rights_base & wasi.RIGHT.FD_WRITE != 0) {
+    //    flags |= os.O.WRONLY;
+    //} else if (fs_rights_base & wasi.RIGHT.FD_READ != 0) {
+    //    flags |= os.O.RDONLY; // no-op because O_RDONLY is 0
+    //}
+    //const mode = 0o644;
+    //const res_fd = os.openat(host_fd, sub_path, flags, mode) catch |err| return toWasiError(err);
+    //mem.writeIntLittle(i32, vm->memory[fd..][0..4], res_fd);
+    return WASI_ESUCCESS;
+}
+
+static enum wasi_errno_t wasi_path_filestat_get(
+    struct VirtualMachine *vm,
+    int32_t fd,
+    uint32_t flags, // wasi.lookupflags_t,
+    uint32_t path, // [*]const u8
+    uint32_t path_len, // usize
+    uint32_t buf // *filestat_t
+) {
+    panic("TODO implement wasi_path_filestat_get");
+    //const sub_path = vm->memory[path..][0..path_len];
+    //const host_fd = toHostFd(fd);
+    //const dir: fs.Dir = .{ .fd = host_fd };
+    //const stat = dir.statFile(sub_path) catch |err| return toWasiError(err);
+    //return finishWasiStat(vm, buf, stat);
+    return WASI_ESUCCESS;
+}
+
+/// extern fn path_create_directory(fd: fd_t, path: [*]const u8, path_len: usize) errno_t;
+static enum wasi_errno_t wasi_path_create_directory(struct VirtualMachine *vm, int32_t fd, uint32_t path, uint32_t path_len) {
+    panic("TODO implement wasi_path_create_directory");
+    //const sub_path = vm->memory[path..][0..path_len];
+    //trace_log.debug("wasi_path_create_directory fd={d} path={s}", .{ fd, sub_path });
+    //const host_fd = toHostFd(fd);
+    //const dir: fs.Dir = .{ .fd = host_fd };
+    //dir.makeDir(sub_path) catch |err| return toWasiError(err);
+    return WASI_ESUCCESS;
+}
+
+static enum wasi_errno_t wasi_path_rename(
+    struct VirtualMachine *vm,
+    int32_t old_fd,
+    uint32_t old_path_ptr, // [*]const u8
+    uint32_t old_path_len, // usize
+    int32_t new_fd,
+    uint32_t new_path_ptr, // [*]const u8
+    uint32_t new_path_len // usize
+) {
+    panic("TODO implement wasi_path_rename");
+    //const old_path = vm->memory[old_path_ptr..][0..old_path_len];
+    //const new_path = vm->memory[new_path_ptr..][0..new_path_len];
+    //trace_log.debug("wasi_path_rename old_fd={d} old_path={s} new_fd={d} new_path={s}", .{
+    //    old_fd, old_path, new_fd, new_path,
+    //});
+    //const old_host_fd = toHostFd(old_fd);
+    //const new_host_fd = toHostFd(new_fd);
+    //os.renameat(old_host_fd, old_path, new_host_fd, new_path) catch |err| return toWasiError(err);
+    return WASI_ESUCCESS;
+}
+
+/// extern fn fd_filestat_get(fd: fd_t, buf: *filestat_t) errno_t;
+static enum wasi_errno_t wasi_fd_filestat_get(struct VirtualMachine *vm, int32_t fd, uint32_t buf) {
+    panic("TODO implement wasi_fd_filestat_get");
+    //const host_fd = toHostFd(fd);
+    //const file = fs.File{ .handle = host_fd };
+    //const stat = file.stat() catch |err| return toWasiError(err);
+    //return finishWasiStat(vm, buf, stat);
+    return WASI_ESUCCESS;
+}
+
+static enum wasi_errno_t wasi_fd_filestat_set_size( struct VirtualMachine *vm,
+        int32_t fd, uint64_t size)
+{
+    panic("TODO implement wasi_fd_filestat_set_size");
+    //_ = vm;
+    //const host_fd = toHostFd(fd);
+    //os.ftruncate(host_fd, size) catch |err| return toWasiError(err);
+    return WASI_ESUCCESS;
+}
+
+/// pub extern "wasi_snapshot_preview1" fn fd_fdstat_get(fd: fd_t, buf: *fdstat_t) errno_t;
+/// pub const fdstat_t = extern struct {
+///     fs_filetype: filetype_t, u8
+///     fs_flags: fdflags_t, u16
+///     fs_rights_base: rights_t, u64
+///     fs_rights_inheriting: rights_t, u64
+/// };
+static enum wasi_errno_t wasi_fd_fdstat_get(struct VirtualMachine *vm, int32_t fd, uint32_t buf) {
+    panic("TODO implement wasi_fd_fdstat_get");
+    //const host_fd = toHostFd(fd);
+    //const file = fs.File{ .handle = host_fd };
+    //const stat = file.stat() catch |err| return toWasiError(err);
+    //mem.writeIntLittle(u16, vm->memory[buf + 0x00 ..][0..2], @enumToInt(toWasiFileType(stat.kind)));
+    //mem.writeIntLittle(u16, vm->memory[buf + 0x02 ..][0..2], 0); // flags
+    //mem.writeIntLittle(u64, vm->memory[buf + 0x08 ..][0..8], math.maxInt(u64)); // rights_base
+    //mem.writeIntLittle(u64, vm->memory[buf + 0x10 ..][0..8], math.maxInt(u64)); // rights_inheriting
+    return WASI_ESUCCESS;
+}
+
+/// extern fn clock_time_get(clock_id: clockid_t, precision: timestamp_t, timestamp: *timestamp_t) errno_t;
+static enum wasi_errno_t wasi_clock_time_get(struct VirtualMachine *vm,
+        uint32_t clock_id, uint64_t precision, uint32_t timestamp)
+{
+    panic("TODO implement wasi_clock_time_get");
+    ////const host_clock_id = toHostClockId(clock_id);
+    //_ = precision;
+    //_ = clock_id;
+    //const wasi_ts = toWasiTimestamp(std.time.nanoTimestamp());
+    //mem.writeIntLittle(u64, vm->memory[timestamp..][0..8], wasi_ts);
+    return WASI_ESUCCESS;
+}
+
+///pub extern "wasi_snapshot_preview1" fn debug(string: [*:0]const u8, x: u64) void;
+void wasi_debug(struct VirtualMachine *vm, uint32_t text, uint64_t n) {
+    panic("TODO implement wasi_debug");
+    //const s = mem.sliceTo(vm->memory[text..], 0);
+    //trace_log.debug("wasi_debug: '{s}' number={d} {x}", .{ s, n, n });
+}
+
+/// pub extern "wasi_snapshot_preview1" fn debug_slice(ptr: [*]const u8, len: usize) void;
+void wasi_debug_slice(struct VirtualMachine *vm, uint32_t ptr, uint32_t len) {
+    panic("TODO implement wasi_debug_slice");
+    //const s = vm->memory[ptr..][0..len];
+    //trace_log.debug("wasi_debug_slice: '{s}'", .{s});
+}
+
+
+
+struct Label {
+    enum WasmOp opcode;
+    uint32_t stack_depth;
+    struct TypeInfo type_info;
+    // this is a UINT32_MAX terminated linked list that is stored in the operands array
+    uint32_t ref_list;
+    union {
+        struct ProgramCounter loop_pc;
+        uint32_t else_ref;
+    } extra;
+};
+
+static uint32_t Label_operandCount(const struct Label *label) {
+    if (label->opcode == WasmOp_loop) {
+        return label->type_info.param_count;
+    } else {
+        return label->type_info.result_count;
+    }
+}
+
+static bool Label_operandType(const struct Label *label, uint32_t index) {
+    if (label->opcode == WasmOp_loop) {
+        return bs_isSet(&label->type_info.param_types, index);
+    } else {
+        return bs_isSet(&label->type_info.result_types, index);
+    }
+}
+
+static void vm_decodeCode(struct VirtualMachine *vm, struct Function *func, uint32_t *code_i,
+    struct ProgramCounter *pc)
+{
+    const char *mod_ptr = vm->mod_ptr;
+    uint8_t *opcodes = vm->opcodes;
+    uint32_t *operands = vm->operands;
+    struct TypeInfo *func_type_info = &vm->types[func->type_idx];
+
+    uint32_t unreachable_depth = 0;
+    uint32_t stack_depth = func_type_info->param_count + func->locals_count + 2;
+    static uint32_t stack_types[1 << (12 - 3)];
+
+    static struct Label labels[1 << 9];
+    uint32_t label_i = 0;
+    labels[label_i].opcode = WasmOp_block;
+    labels[label_i].stack_depth = stack_depth;
+    labels[label_i].type_info = vm->types[func->type_idx];
+    labels[label_i].ref_list = UINT32_MAX;
+
+    for (;;) {
+        enum WasmOp opcode = (uint8_t)mod_ptr[*code_i];
+        *code_i += 1;
+        enum WasmPrefixedOp prefixed_opcode;
+        if (opcode == WasmOp_prefixed) prefixed_opcode = read32_uleb128(mod_ptr, code_i);
+
+        uint32_t initial_stack_depth = stack_depth;
+        if (unreachable_depth == 0) {
+            switch (opcode) {
+                case WasmOp_unreachable:
+                case WasmOp_nop:
+                case WasmOp_block:
+                case WasmOp_loop:
+                case WasmOp_else:
+                case WasmOp_end:
+                case WasmOp_br:
+                case WasmOp_call:
+                case WasmOp_return:
+                break;
+
+                case WasmOp_if:
+                case WasmOp_br_if:
+                case WasmOp_br_table:
+                case WasmOp_call_indirect:
+                case WasmOp_drop:
+                case WasmOp_local_set:
+                case WasmOp_global_set:
+                stack_depth -= 1;
+                break;
+
+                case WasmOp_select:
+                stack_depth -= 2;
+                break;
+
+                case WasmOp_local_get:
+                case WasmOp_global_get:
+                case WasmOp_memory_size:
+                case WasmOp_i32_const:
+                case WasmOp_i64_const:
+                case WasmOp_f32_const:
+                case WasmOp_f64_const:
+                stack_depth += 1;
+                break;
+
+                case WasmOp_local_tee:
+                case WasmOp_i32_load:
+                case WasmOp_i64_load:
+                case WasmOp_f32_load:
+                case WasmOp_f64_load:
+                case WasmOp_i32_load8_s:
+                case WasmOp_i32_load8_u:
+                case WasmOp_i32_load16_s:
+                case WasmOp_i32_load16_u:
+                case WasmOp_i64_load8_s:
+                case WasmOp_i64_load8_u:
+                case WasmOp_i64_load16_s:
+                case WasmOp_i64_load16_u:
+                case WasmOp_i64_load32_s:
+                case WasmOp_i64_load32_u:
+                case WasmOp_memory_grow:
+                case WasmOp_i32_eqz:
+                case WasmOp_i32_clz:
+                case WasmOp_i32_ctz:
+                case WasmOp_i32_popcnt:
+                case WasmOp_i64_eqz:
+                case WasmOp_i64_clz:
+                case WasmOp_i64_ctz:
+                case WasmOp_i64_popcnt:
+                case WasmOp_f32_abs:
+                case WasmOp_f32_neg:
+                case WasmOp_f32_ceil:
+                case WasmOp_f32_floor:
+                case WasmOp_f32_trunc:
+                case WasmOp_f32_nearest:
+                case WasmOp_f32_sqrt:
+                case WasmOp_f64_abs:
+                case WasmOp_f64_neg:
+                case WasmOp_f64_ceil:
+                case WasmOp_f64_floor:
+                case WasmOp_f64_trunc:
+                case WasmOp_f64_nearest:
+                case WasmOp_f64_sqrt:
+                case WasmOp_i32_wrap_i64:
+                case WasmOp_i32_trunc_f32_s:
+                case WasmOp_i32_trunc_f32_u:
+                case WasmOp_i32_trunc_f64_s:
+                case WasmOp_i32_trunc_f64_u:
+                case WasmOp_i64_extend_i32_s:
+                case WasmOp_i64_extend_i32_u:
+                case WasmOp_i64_trunc_f32_s:
+                case WasmOp_i64_trunc_f32_u:
+                case WasmOp_i64_trunc_f64_s:
+                case WasmOp_i64_trunc_f64_u:
+                case WasmOp_f32_convert_i32_s:
+                case WasmOp_f32_convert_i32_u:
+                case WasmOp_f32_convert_i64_s:
+                case WasmOp_f32_convert_i64_u:
+                case WasmOp_f32_demote_f64:
+                case WasmOp_f64_convert_i32_s:
+                case WasmOp_f64_convert_i32_u:
+                case WasmOp_f64_convert_i64_s:
+                case WasmOp_f64_convert_i64_u:
+                case WasmOp_f64_promote_f32:
+                case WasmOp_i32_reinterpret_f32:
+                case WasmOp_i64_reinterpret_f64:
+                case WasmOp_f32_reinterpret_i32:
+                case WasmOp_f64_reinterpret_i64:
+                case WasmOp_i32_extend8_s:
+                case WasmOp_i32_extend16_s:
+                case WasmOp_i64_extend8_s:
+                case WasmOp_i64_extend16_s:
+                case WasmOp_i64_extend32_s:
+                break;
+
+                case WasmOp_i32_store:
+                case WasmOp_i64_store:
+                case WasmOp_f32_store:
+                case WasmOp_f64_store:
+                case WasmOp_i32_store8:
+                case WasmOp_i32_store16:
+                case WasmOp_i64_store8:
+                case WasmOp_i64_store16:
+                case WasmOp_i64_store32:
+                stack_depth -= 2;
+                break;
+
+                case WasmOp_i32_eq:
+                case WasmOp_i32_ne:
+                case WasmOp_i32_lt_s:
+                case WasmOp_i32_lt_u:
+                case WasmOp_i32_gt_s:
+                case WasmOp_i32_gt_u:
+                case WasmOp_i32_le_s:
+                case WasmOp_i32_le_u:
+                case WasmOp_i32_ge_s:
+                case WasmOp_i32_ge_u:
+                case WasmOp_i64_eq:
+                case WasmOp_i64_ne:
+                case WasmOp_i64_lt_s:
+                case WasmOp_i64_lt_u:
+                case WasmOp_i64_gt_s:
+                case WasmOp_i64_gt_u:
+                case WasmOp_i64_le_s:
+                case WasmOp_i64_le_u:
+                case WasmOp_i64_ge_s:
+                case WasmOp_i64_ge_u:
+                case WasmOp_f32_eq:
+                case WasmOp_f32_ne:
+                case WasmOp_f32_lt:
+                case WasmOp_f32_gt:
+                case WasmOp_f32_le:
+                case WasmOp_f32_ge:
+                case WasmOp_f64_eq:
+                case WasmOp_f64_ne:
+                case WasmOp_f64_lt:
+                case WasmOp_f64_gt:
+                case WasmOp_f64_le:
+                case WasmOp_f64_ge:
+                case WasmOp_i32_add:
+                case WasmOp_i32_sub:
+                case WasmOp_i32_mul:
+                case WasmOp_i32_div_s:
+                case WasmOp_i32_div_u:
+                case WasmOp_i32_rem_s:
+                case WasmOp_i32_rem_u:
+                case WasmOp_i32_and:
+                case WasmOp_i32_or:
+                case WasmOp_i32_xor:
+                case WasmOp_i32_shl:
+                case WasmOp_i32_shr_s:
+                case WasmOp_i32_shr_u:
+                case WasmOp_i32_rotl:
+                case WasmOp_i32_rotr:
+                case WasmOp_i64_add:
+                case WasmOp_i64_sub:
+                case WasmOp_i64_mul:
+                case WasmOp_i64_div_s:
+                case WasmOp_i64_div_u:
+                case WasmOp_i64_rem_s:
+                case WasmOp_i64_rem_u:
+                case WasmOp_i64_and:
+                case WasmOp_i64_or:
+                case WasmOp_i64_xor:
+                case WasmOp_i64_shl:
+                case WasmOp_i64_shr_s:
+                case WasmOp_i64_shr_u:
+                case WasmOp_i64_rotl:
+                case WasmOp_i64_rotr:
+                case WasmOp_f32_add:
+                case WasmOp_f32_sub:
+                case WasmOp_f32_mul:
+                case WasmOp_f32_div:
+                case WasmOp_f32_min:
+                case WasmOp_f32_max:
+                case WasmOp_f32_copysign:
+                case WasmOp_f64_add:
+                case WasmOp_f64_sub:
+                case WasmOp_f64_mul:
+                case WasmOp_f64_div:
+                case WasmOp_f64_min:
+                case WasmOp_f64_max:
+                case WasmOp_f64_copysign:
+                stack_depth -= 1;
+                break;
+
+                case WasmOp_prefixed:
+                switch (prefixed_opcode) {
+                    case WasmPrefixedOp_i32_trunc_sat_f32_s:
+                    case WasmPrefixedOp_i32_trunc_sat_f32_u:
+                    case WasmPrefixedOp_i32_trunc_sat_f64_s:
+                    case WasmPrefixedOp_i32_trunc_sat_f64_u:
+                    case WasmPrefixedOp_i64_trunc_sat_f32_s:
+                    case WasmPrefixedOp_i64_trunc_sat_f32_u:
+                    case WasmPrefixedOp_i64_trunc_sat_f64_s:
+                    case WasmPrefixedOp_i64_trunc_sat_f64_u:
+                    break;
+
+                    case WasmPrefixedOp_memory_init:
+                    case WasmPrefixedOp_memory_copy:
+                    case WasmPrefixedOp_memory_fill:
+                    case WasmPrefixedOp_table_init:
+                    case WasmPrefixedOp_table_copy:
+                    case WasmPrefixedOp_table_fill:
+                    stack_depth -= 3;
+                    break;
+
+                    case WasmPrefixedOp_data_drop:
+                    case WasmPrefixedOp_elem_drop:
+                    break;
+
+                    case WasmPrefixedOp_table_grow:
+                    stack_depth -= 1;
+                    break;
+
+                    case WasmPrefixedOp_table_size:
+                    stack_depth += 1;
+                    break;
+
+                    default: panic("unexpected prefixed opcode");
+                }
+                break;
+
+                default: panic("unexpected opcode");
+            }
+            switch (opcode) {
+                case WasmOp_unreachable:
+                case WasmOp_nop:
+                case WasmOp_block:
+                case WasmOp_loop:
+                case WasmOp_else:
+                case WasmOp_end:
+                case WasmOp_br:
+                case WasmOp_call:
+                case WasmOp_return:
+                case WasmOp_if:
+                case WasmOp_br_if:
+                case WasmOp_br_table:
+                case WasmOp_call_indirect:
+                case WasmOp_drop:
+                case WasmOp_select:
+                case WasmOp_local_set:
+                case WasmOp_local_get:
+                case WasmOp_local_tee:
+                case WasmOp_global_set:
+                case WasmOp_global_get:
+                case WasmOp_i32_store:
+                case WasmOp_i64_store:
+                case WasmOp_f32_store:
+                case WasmOp_f64_store:
+                case WasmOp_i32_store8:
+                case WasmOp_i32_store16:
+                case WasmOp_i64_store8:
+                case WasmOp_i64_store16:
+                case WasmOp_i64_store32:
+                break;
+
+                case WasmOp_i32_const:
+                case WasmOp_f32_const:
+                case WasmOp_memory_size:
+                case WasmOp_i32_load:
+                case WasmOp_f32_load:
+                case WasmOp_i32_load8_s:
+                case WasmOp_i32_load8_u:
+                case WasmOp_i32_load16_s:
+                case WasmOp_i32_load16_u:
+                case WasmOp_memory_grow:
+                case WasmOp_i32_eqz:
+                case WasmOp_i32_clz:
+                case WasmOp_i32_ctz:
+                case WasmOp_i32_popcnt:
+                case WasmOp_i64_eqz:
+                case WasmOp_f32_abs:
+                case WasmOp_f32_neg:
+                case WasmOp_f32_ceil:
+                case WasmOp_f32_floor:
+                case WasmOp_f32_trunc:
+                case WasmOp_f32_nearest:
+                case WasmOp_f32_sqrt:
+                case WasmOp_i32_wrap_i64:
+                case WasmOp_i32_trunc_f32_s:
+                case WasmOp_i32_trunc_f32_u:
+                case WasmOp_i32_trunc_f64_s:
+                case WasmOp_i32_trunc_f64_u:
+                case WasmOp_f32_convert_i32_s:
+                case WasmOp_f32_convert_i32_u:
+                case WasmOp_f32_convert_i64_s:
+                case WasmOp_f32_convert_i64_u:
+                case WasmOp_f32_demote_f64:
+                case WasmOp_i32_reinterpret_f32:
+                case WasmOp_f32_reinterpret_i32:
+                case WasmOp_i32_extend8_s:
+                case WasmOp_i32_extend16_s:
+                case WasmOp_i32_eq:
+                case WasmOp_i32_ne:
+                case WasmOp_i32_lt_s:
+                case WasmOp_i32_lt_u:
+                case WasmOp_i32_gt_s:
+                case WasmOp_i32_gt_u:
+                case WasmOp_i32_le_s:
+                case WasmOp_i32_le_u:
+                case WasmOp_i32_ge_s:
+                case WasmOp_i32_ge_u:
+                case WasmOp_i64_eq:
+                case WasmOp_i64_ne:
+                case WasmOp_i64_lt_s:
+                case WasmOp_i64_lt_u:
+                case WasmOp_i64_gt_s:
+                case WasmOp_i64_gt_u:
+                case WasmOp_i64_le_s:
+                case WasmOp_i64_le_u:
+                case WasmOp_i64_ge_s:
+                case WasmOp_i64_ge_u:
+                case WasmOp_f32_eq:
+                case WasmOp_f32_ne:
+                case WasmOp_f32_lt:
+                case WasmOp_f32_gt:
+                case WasmOp_f32_le:
+                case WasmOp_f32_ge:
+                case WasmOp_f64_eq:
+                case WasmOp_f64_ne:
+                case WasmOp_f64_lt:
+                case WasmOp_f64_gt:
+                case WasmOp_f64_le:
+                case WasmOp_f64_ge:
+                case WasmOp_i32_add:
+                case WasmOp_i32_sub:
+                case WasmOp_i32_mul:
+                case WasmOp_i32_div_s:
+                case WasmOp_i32_div_u:
+                case WasmOp_i32_rem_s:
+                case WasmOp_i32_rem_u:
+                case WasmOp_i32_and:
+                case WasmOp_i32_or:
+                case WasmOp_i32_xor:
+                case WasmOp_i32_shl:
+                case WasmOp_i32_shr_s:
+                case WasmOp_i32_shr_u:
+                case WasmOp_i32_rotl:
+                case WasmOp_i32_rotr:
+                case WasmOp_f32_add:
+                case WasmOp_f32_sub:
+                case WasmOp_f32_mul:
+                case WasmOp_f32_div:
+                case WasmOp_f32_min:
+                case WasmOp_f32_max:
+                case WasmOp_f32_copysign:
+                bs_unset(stack_types, stack_depth - 1);
+                break;
+
+                case WasmOp_i64_const:
+                case WasmOp_f64_const:
+                case WasmOp_i64_load:
+                case WasmOp_f64_load:
+                case WasmOp_i64_load8_s:
+                case WasmOp_i64_load8_u:
+                case WasmOp_i64_load16_s:
+                case WasmOp_i64_load16_u:
+                case WasmOp_i64_load32_s:
+                case WasmOp_i64_load32_u:
+                case WasmOp_i64_clz:
+                case WasmOp_i64_ctz:
+                case WasmOp_i64_popcnt:
+                case WasmOp_f64_abs:
+                case WasmOp_f64_neg:
+                case WasmOp_f64_ceil:
+                case WasmOp_f64_floor:
+                case WasmOp_f64_trunc:
+                case WasmOp_f64_nearest:
+                case WasmOp_f64_sqrt:
+                case WasmOp_i64_extend_i32_s:
+                case WasmOp_i64_extend_i32_u:
+                case WasmOp_i64_trunc_f32_s:
+                case WasmOp_i64_trunc_f32_u:
+                case WasmOp_i64_trunc_f64_s:
+                case WasmOp_i64_trunc_f64_u:
+                case WasmOp_f64_convert_i32_s:
+                case WasmOp_f64_convert_i32_u:
+                case WasmOp_f64_convert_i64_s:
+                case WasmOp_f64_convert_i64_u:
+                case WasmOp_f64_promote_f32:
+                case WasmOp_i64_reinterpret_f64:
+                case WasmOp_f64_reinterpret_i64:
+                case WasmOp_i64_extend8_s:
+                case WasmOp_i64_extend16_s:
+                case WasmOp_i64_extend32_s:
+                case WasmOp_i64_add:
+                case WasmOp_i64_sub:
+                case WasmOp_i64_mul:
+                case WasmOp_i64_div_s:
+                case WasmOp_i64_div_u:
+                case WasmOp_i64_rem_s:
+                case WasmOp_i64_rem_u:
+                case WasmOp_i64_and:
+                case WasmOp_i64_or:
+                case WasmOp_i64_xor:
+                case WasmOp_i64_shl:
+                case WasmOp_i64_shr_s:
+                case WasmOp_i64_shr_u:
+                case WasmOp_i64_rotl:
+                case WasmOp_i64_rotr:
+                case WasmOp_f64_add:
+                case WasmOp_f64_sub:
+                case WasmOp_f64_mul:
+                case WasmOp_f64_div:
+                case WasmOp_f64_min:
+                case WasmOp_f64_max:
+                case WasmOp_f64_copysign:
+                bs_set(stack_types, stack_depth - 1);
+                break;
+
+                case WasmOp_prefixed:
+                switch (prefixed_opcode) {
+                    case WasmPrefixedOp_memory_init:
+                    case WasmPrefixedOp_memory_copy:
+                    case WasmPrefixedOp_memory_fill:
+                    case WasmPrefixedOp_table_init:
+                    case WasmPrefixedOp_table_copy:
+                    case WasmPrefixedOp_table_fill:
+                    case WasmPrefixedOp_data_drop:
+                    case WasmPrefixedOp_elem_drop:
+                    break;
+
+                    case WasmPrefixedOp_i32_trunc_sat_f32_s:
+                    case WasmPrefixedOp_i32_trunc_sat_f32_u:
+                    case WasmPrefixedOp_i32_trunc_sat_f64_s:
+                    case WasmPrefixedOp_i32_trunc_sat_f64_u:
+                    case WasmPrefixedOp_table_grow:
+                    case WasmPrefixedOp_table_size:
+                    bs_unset(stack_types, stack_depth - 1);
+                    break;
+
+                    case WasmPrefixedOp_i64_trunc_sat_f32_s:
+                    case WasmPrefixedOp_i64_trunc_sat_f32_u:
+                    case WasmPrefixedOp_i64_trunc_sat_f64_s:
+                    case WasmPrefixedOp_i64_trunc_sat_f64_u:
+                    bs_set(stack_types, stack_depth - 1);
+                    break;
+
+                    default: panic("unexpected prefixed opcode");
+                }
+                break;
+
+                default: panic("unexpected opcode");
+            }
+        }
+
+        switch (opcode) {
+            case WasmOp_unreachable:
+            if (unreachable_depth == 0) {
+                opcodes[pc->opcode] = Op_unreachable;
+                pc->opcode += 1;
+            }
+            break;
+
+            case WasmOp_nop:
+            case WasmOp_i32_reinterpret_f32:
+            case WasmOp_i64_reinterpret_f64:
+            case WasmOp_f32_reinterpret_i32:
+            case WasmOp_f64_reinterpret_i64:
+            break;
+
+            case WasmOp_block:
+            case WasmOp_loop:
+            case WasmOp_if:
+            {
+                int64_t block_type = read64_ileb128(mod_ptr, code_i);
+                if (unreachable_depth == 0) {
+                    label_i += 1;
+                    struct Label *label = &labels[label_i];
+                    label->opcode = opcode;
+                    if (block_type < 0) {
+                        label->type_info.param_count = 0;
+                        label->type_info.param_types = 0;
+                        label->type_info.result_count = block_type != -0x40;
+                        label->type_info.result_types = 0;
+                        switch (block_type) {
+                            case -0x40: break;
+                            case -1: case -3: bs_unset(&label->type_info.param_types, 0); break;
+                            case -2: case -4:   bs_set(&label->type_info.param_types, 0); break;
+                            default: panic("unexpected param type");
+                        }
+                    } else {
+                        label->type_info = vm->types[block_type];
+                    }
+                    label->stack_depth = stack_depth - label->type_info.param_count;
+                    label->ref_list = UINT32_MAX;
+                    switch (opcode) {
+                        case WasmOp_block:
+                        break;
+
+                        case WasmOp_loop:
+                        label->extra.loop_pc = *pc;
+                        break;
+
+                        case WasmOp_if:
+                        opcodes[pc->opcode] = Op_br_if_eqz_void;
+                        pc->opcode += 1;
+                        operands[pc->operand] = 0;
+                        label->extra.else_ref = pc->operand + 1;
+                        pc->operand += 3;
+                        break;
+
+                        default: panic("unexpected label opcode");
+                    }
+                }
+            }
+            break;
+
+            case WasmOp_else:
+            {
+                struct Label *label = &labels[label_i];
+                assert(label->opcode == WasmOp_if);
+                label->opcode = WasmOp_else;
+                if (unreachable_depth == 0) {
+                    uint32_t operand_count = Label_operandCount(label);
+                    switch (operand_count) {
+                        case 0:
+                        opcodes[pc->opcode] = Op_br_void;
+                        break;
+
+                        case 1:
+                        switch ((int)Label_operandType(label, 0)) {
+                            case false: opcodes[pc->opcode] = Op_br_32; break;
+                            case  true: opcodes[pc->opcode] = Op_br_64; break;
+                        }
+                        break;
+
+                        default: panic("unexpected operand count");
+                    }
+                    pc->opcode += 1;
+                    operands[pc->operand + 0] = stack_depth - operand_count - label->stack_depth;
+                    operands[pc->operand + 1] = label->ref_list;
+                    label->ref_list = pc->operand + 1;
+                    pc->operand += 3;
+                    assert(stack_depth - label->type_info.result_count == label->stack_depth);
+                } else unreachable_depth = 0;
+                operands[label->extra.else_ref + 0] = pc->opcode;
+                operands[label->extra.else_ref + 1] = pc->operand;
+                stack_depth = label->stack_depth + label->type_info.param_count;
+            };
+            break;
+
+            case WasmOp_end:
+            if (unreachable_depth <= 1) {
+                unreachable_depth = 0;
+                struct Label *label = &labels[label_i];
+                struct ProgramCounter *target_pc = (label->opcode == WasmOp_loop) ? &label->extra.loop_pc : pc;
+                if (label->opcode == WasmOp_if) {
+                    operands[label->extra.else_ref + 0] = target_pc->opcode;
+                    operands[label->extra.else_ref + 1] = target_pc->operand;
+                }
+                uint32_t ref = label->ref_list;
+                while (ref != UINT32_MAX) {
+                    uint32_t next_ref = operands[ref];
+                    operands[ref + 0] = target_pc->opcode;
+                    operands[ref + 1] = target_pc->operand;
+                    ref = next_ref;
+                }
+                stack_depth = label->stack_depth + label->type_info.result_count;
+
+                if (label_i == 0) {
+                    uint32_t operand_count = Label_operandCount(&labels[0]);
+                    switch (operand_count) {
+                        case 0:
+                        opcodes[pc->opcode] = Op_return_void;
+                        break;
+
+                        case 1:
+                        switch ((int)Label_operandType(&labels[0], 0)) {
+                            case false: opcodes[pc->opcode] = Op_return_32; break;
+                            case  true: opcodes[pc->opcode] = Op_return_64; break;
+                        }
+                        break;
+
+                        default: panic("unexpected operand count");
+                    }
+                    pc->opcode += 1;
+                    operands[pc->operand + 0] = 2 + operand_count;
+                    stack_depth -= operand_count;
+                    assert(stack_depth == labels[0].stack_depth);
+                    operands[pc->operand + 1] = stack_depth;
+                    pc->operand += 2;
+                    return;
+                }
+                label_i -= 1;
+            } else unreachable_depth -= 1;
+            break;
+
+            case WasmOp_br:
+            case WasmOp_br_if:
+            {
+                uint32_t label_idx = read32_uleb128(mod_ptr, code_i);
+                if (unreachable_depth == 0) {
+                    struct Label *label = &labels[label_i - label_idx];
+                    uint32_t operand_count = Label_operandCount(label);
+                    switch (opcode) {
+                        case WasmOp_br:
+                        switch (operand_count) {
+                            case 0:
+                            opcodes[pc->opcode] = Op_br_void;
+                            break;
+
+                            case 1:
+                            switch ((int)Label_operandType(label, 0)) {
+                                case false: opcodes[pc->opcode] = Op_br_32; break;
+                                case  true: opcodes[pc->opcode] = Op_br_64; break;
+                            }
+                            break;
+
+                            default: panic("unexpected operand count");
+                        }
+                        break;
+
+                        case WasmOp_br_if:
+                        switch (operand_count) {
+                            case 0:
+                            opcodes[pc->opcode] = Op_br_if_nez_void;
+                            break;
+
+                            case 1:
+                            switch ((int)Label_operandType(label, 0)) {
+                                case false: opcodes[pc->opcode] = Op_br_if_nez_32; break;
+                                case  true: opcodes[pc->opcode] = Op_br_if_nez_64; break;
+                            }
+                            break;
+
+                            default: panic("unexpected operand count");
+                        }
+                        break;
+
+                        default: panic("unexpected opcode");
+                    }
+                    pc->opcode += 1;
+                    operands[pc->operand + 0] = stack_depth - operand_count - label->stack_depth;
+                    operands[pc->operand + 1] = label->ref_list;
+                    label->ref_list = pc->operand + 1;
+                    pc->operand += 3;
+                }
+            }
+            break;
+
+            case WasmOp_br_table:
+            {
+                uint32_t labels_len = read32_uleb128(mod_ptr, code_i);
+                for (uint32_t i = 0; i <= labels_len; i += 1) {
+                    uint32_t label_idx = read32_uleb128(mod_ptr, code_i);
+                    if (unreachable_depth != 0) continue;
+                    struct Label *label = &labels[label_i - label_idx];
+                    uint32_t operand_count = Label_operandCount(label);
+                    if (i == 0) {
+                        switch (operand_count) {
+                            case 0:
+                            opcodes[pc->opcode] = Op_br_table_void;
+                            break;
+
+                            case 1:
+                            switch ((int)Label_operandType(label, 0)) {
+                                case false: opcodes[pc->opcode] = Op_br_table_32; break;
+                                case  true: opcodes[pc->opcode] = Op_br_table_64; break;
+                            }
+                            break;
+
+                            default: panic("unexpected operand count");
+                        }
+                        pc->opcode += 1;
+                        operands[pc->operand] = labels_len;
+                        pc->operand += 1;
+                    }
+                    operands[pc->operand + 0] = stack_depth - operand_count - label->stack_depth;
+                    operands[pc->operand + 1] = label->ref_list;
+                    label->ref_list = pc->operand + 1;
+                    pc->operand += 3;
+                }
+
+                opcodes[pc->opcode] = opcode;
+                pc->opcode += 1;
+                operands[pc->operand] = labels_len;
+                pc->operand += 1;
+            }
+            break;
+
+            case WasmOp_call:
+            {
+                uint32_t fn_id = read32_uleb128(mod_ptr, code_i);
+                if (unreachable_depth == 0) {
+                    opcodes[pc->opcode] = Op_call;
+                    pc->opcode += 1;
+                    operands[pc->operand] = fn_id;
+                    pc->operand += 1;
+                    uint32_t type_idx = (fn_id < vm->imports_len) ?
+                        vm->imports[fn_id].type_idx :
+                        vm->functions[fn_id - vm->imports_len].type_idx;
+                    struct TypeInfo *type_info = &vm->types[type_idx];
+                    stack_depth -= type_info->param_count;
+                    for (uint32_t result_i = 0; result_i < type_info->result_count; result_i += 1)
+                        bs_setValue(stack_types, stack_depth + result_i,
+                                    bs_isSet(&type_info->result_types, result_i));
+                    stack_depth += type_info->result_count;
+                }
+            }
+            break;
+
+            case WasmOp_call_indirect:
+            {
+                uint32_t type_idx = read32_uleb128(mod_ptr, code_i);
+                if (read32_uleb128(mod_ptr, code_i) != 0) panic("unexpected table index");
+                if (unreachable_depth == 0) {
+                    opcodes[pc->opcode + 0] = Op_wasm;
+                    opcodes[pc->opcode + 1] = opcode;
+                    pc->opcode += 2;
+                    struct TypeInfo *type_info = &vm->types[type_idx];
+                    stack_depth -= type_info->param_count;
+                    for (uint32_t result_i = 0; result_i < type_info->result_count; result_i += 1)
+                        bs_setValue(stack_types, stack_depth + result_i,
+                                    bs_isSet(&type_info->result_types, result_i));
+                    stack_depth += type_info->result_count;
+                }
+            }
+            break;
+
+            case WasmOp_return:
+            {
+                uint32_t operand_count = Label_operandCount(&labels[0]);
+                switch (operand_count) {
+                    case 0:
+                    opcodes[pc->opcode] = Op_return_void;
+                    break;
+
+                    case 1:
+                    switch ((int)Label_operandType(&labels[0], 0)) {
+                        case false: opcodes[pc->opcode] = Op_return_32; break;
+                        case  true: opcodes[pc->opcode] = Op_return_64; break;
+                    }
+                    break;
+
+                    default: panic("unexpected operand count");
+                }
+                pc->opcode += 1;
+                operands[pc->operand + 0] = 2 + stack_depth - labels[0].stack_depth;
+                stack_depth -= operand_count;
+                operands[pc->operand + 1] = stack_depth;
+                pc->operand += 2;
+            }
+            break;
+
+            case WasmOp_select:
+            case WasmOp_drop:
+            if (unreachable_depth == 0) {
+                switch ((int)bs_isSet(stack_types, stack_depth)) {
+                    case false:
+                    switch (opcode) {
+                        case WasmOp_select:
+                        opcodes[pc->opcode] = Op_select_32;
+                        break;
+
+                        case WasmOp_drop:
+                        opcodes[pc->opcode] = Op_drop_32;
+                        break;
+
+                        default: panic("unexpected opcode");
+                    }
+                    break;
+
+                    case true:
+                    switch (opcode) {
+                        case WasmOp_select:
+                        opcodes[pc->opcode] = Op_select_64;
+                        break;
+
+                        case WasmOp_drop:
+                        opcodes[pc->opcode] = Op_drop_64;
+                        break;
+
+                        default: panic("unexpected opcode");
+                    }
+                    break;
+                }
+                pc->opcode += 1;
+            }
+            break;
+
+            case WasmOp_local_get:
+            case WasmOp_local_set:
+            case WasmOp_local_tee:
+            {
+                uint32_t local_idx = read32_uleb128(mod_ptr, code_i);
+                if (unreachable_depth == 0) {
+                    bool local_type = bs_isSet(func->local_types, local_idx);
+                    switch ((int)local_type) {
+                        case false:
+                        switch (opcode) {
+                            case WasmOp_local_get:
+                            opcodes[pc->opcode] = Op_local_get_32;
+                            break;
+
+                            case WasmOp_local_set:
+                            opcodes[pc->opcode] = Op_local_set_32;
+                            break;
+
+                            case WasmOp_local_tee:
+                            opcodes[pc->opcode] = Op_local_tee_32;
+                            break;
+
+                            default: panic("unexpected opcode");
+                        }
+                        break;
+
+                        case true:
+                        switch (opcode) {
+                            case WasmOp_local_get:
+                            opcodes[pc->opcode] = Op_local_get_64;
+                            break;
+
+                            case WasmOp_local_set:
+                            opcodes[pc->opcode] = Op_local_set_64;
+                            break;
+
+                            case WasmOp_local_tee:
+                            opcodes[pc->opcode] = Op_local_tee_64;
+                            break;
+
+                            default: panic("unexpected opcode");
+                        }
+                        break;
+                    }
+                    pc->opcode += 1;
+                    operands[pc->operand] = initial_stack_depth - local_idx;
+                    pc->operand += 1;
+                    if (opcode == WasmOp_local_get) bs_setValue(stack_types, stack_depth - 1, local_type);
+                }
+            }
+            break;
+
+            case WasmOp_global_get:
+            case WasmOp_global_set:
+            {
+                uint32_t global_idx = read32_uleb128(mod_ptr, code_i);
+                if (unreachable_depth == 0) {
+                    switch (global_idx) {
+                        case 0:
+                        switch (opcode) {
+                            case WasmOp_global_get:
+                            opcodes[pc->opcode] = Op_global_get_0_32;
+                            break;
+
+                            case WasmOp_global_set:
+                            opcodes[pc->opcode] = Op_global_set_0_32;
+                            break;
+
+                            default: panic("unexpected opcode");
+                        }
+                        break;
+
+                        default:
+                        switch (opcode) {
+                            case WasmOp_global_get:
+                            opcodes[pc->opcode] = Op_global_get_32;
+                            break;
+
+                            case WasmOp_global_set:
+                            opcodes[pc->opcode] = Op_global_set_32;
+                            break;
+
+                            default: panic("unexpected opcode");
+                        }
+                        break;
+                    }
+                    pc->opcode += 1;
+                    if (global_idx != 0) {
+                        operands[pc->operand] = global_idx;
+                        pc->operand += 1;
+                    }
+                }
+            }
+            break;
+
+            case WasmOp_i32_load:
+            case WasmOp_i64_load:
+            case WasmOp_f32_load:
+            case WasmOp_f64_load:
+            case WasmOp_i32_load8_s:
+            case WasmOp_i32_load8_u:
+            case WasmOp_i32_load16_s:
+            case WasmOp_i32_load16_u:
+            case WasmOp_i64_load8_s:
+            case WasmOp_i64_load8_u:
+            case WasmOp_i64_load16_s:
+            case WasmOp_i64_load16_u:
+            case WasmOp_i64_load32_s:
+            case WasmOp_i64_load32_u:
+            case WasmOp_i32_store:
+            case WasmOp_i64_store:
+            case WasmOp_f32_store:
+            case WasmOp_f64_store:
+            case WasmOp_i32_store8:
+            case WasmOp_i32_store16:
+            case WasmOp_i64_store8:
+            case WasmOp_i64_store16:
+            case WasmOp_i64_store32:
+            {
+                uint32_t alignment = read32_uleb128(mod_ptr, code_i);
+                uint32_t offset = read32_uleb128(mod_ptr, code_i);
+                (void)alignment;
+                if (unreachable_depth == 0) {
+                    opcodes[pc->opcode + 0] = Op_wasm;
+                    opcodes[pc->opcode + 1] = opcode;
+                    pc->opcode += 2;
+                    operands[pc->operand] = offset;
+                    pc->operand += 1;
+                }
+            }
+            break;
+
+            case WasmOp_memory_size:
+            case WasmOp_memory_grow:
+            {
+                if (mod_ptr[*code_i] != 0) panic("unexpected memory index");
+                *code_i += 1;
+                if (unreachable_depth == 0) {
+                    opcodes[pc->opcode + 0] = Op_wasm;
+                    opcodes[pc->opcode + 1] = opcode;
+                    pc->opcode += 2;
+                }
+            }
+            break;
+
+            case WasmOp_i32_const:
+            {
+                uint32_t x = read32_ileb128(mod_ptr, code_i);
+                if (unreachable_depth == 0) {
+                    opcodes[pc->opcode] = Op_const_32;
+                    pc->opcode += 1;
+                    operands[pc->operand] = x;
+                    pc->operand += 1;
+                }
+            }
+            break;
+
+            case WasmOp_i64_const:
+            {
+                uint64_t x = read64_ileb128(mod_ptr, code_i);
+                if (unreachable_depth == 0) {
+                    opcodes[pc->opcode] = Op_const_64;
+                    pc->opcode += 1;
+                    operands[pc->operand + 0] = x & UINT32_MAX;
+                    operands[pc->operand + 1] = (x >> 32) & UINT32_MAX;
+                    pc->operand += 2;
+                }
+            }
+            break;
+
+            case WasmOp_f32_const:
+            {
+                uint32_t x;
+                memcpy(&x, mod_ptr + *code_i, 4);
+                *code_i += 4;
+                if (unreachable_depth == 0) {
+                    opcodes[pc->opcode] = Op_const_32;
+                    pc->opcode += 1;
+                    operands[pc->operand] = x;
+                    pc->operand += 1;
+                }
+            }
+            break;
+
+            case WasmOp_f64_const:
+            {
+                uint64_t x;
+                memcpy(&x, mod_ptr + *code_i, 8);
+                *code_i += 8;
+                if (unreachable_depth == 0) {
+                    opcodes[pc->opcode] = Op_const_64;
+                    pc->opcode += 1;
+                    operands[pc->operand + 0] = x & UINT32_MAX;
+                    operands[pc->operand + 1] = (x >> 32) & UINT32_MAX;
+                    pc->operand += 2;
+                }
+            }
+            break;
+
+            case WasmOp_i32_add:
+            opcodes[pc->opcode] = Op_add_32;
+            pc->opcode += 1;
+            break;
+
+            case WasmOp_i32_and:
+            opcodes[pc->opcode] = Op_and_32;
+            pc->opcode += 1;
+            break;
+
+            default:
+            opcodes[pc->opcode + 0] = Op_wasm;
+            opcodes[pc->opcode + 1] = opcode;
+            pc->opcode += 2;
+            break;
+
+            case WasmOp_prefixed:
+            switch (prefixed_opcode) {
+                case WasmPrefixedOp_i32_trunc_sat_f32_s:
+                case WasmPrefixedOp_i32_trunc_sat_f32_u:
+                case WasmPrefixedOp_i32_trunc_sat_f64_s:
+                case WasmPrefixedOp_i32_trunc_sat_f64_u:
+                case WasmPrefixedOp_i64_trunc_sat_f32_s:
+                case WasmPrefixedOp_i64_trunc_sat_f32_u:
+                case WasmPrefixedOp_i64_trunc_sat_f64_s:
+                case WasmPrefixedOp_i64_trunc_sat_f64_u:
+                if (unreachable_depth == 0) {
+                    opcodes[pc->opcode + 0] = Op_wasm_prefixed;
+                    opcodes[pc->opcode + 1] = prefixed_opcode;
+                    pc->opcode += 2;
+                }
+                break;
+
+                case WasmPrefixedOp_memory_copy:
+                if (mod_ptr[*code_i + 0] != 0 || mod_ptr[*code_i + 1] != 0)
+                    panic("unexpected memory index");
+                *code_i += 2;
+                if (unreachable_depth == 0) {
+                    opcodes[pc->opcode + 0] = Op_wasm_prefixed;
+                    opcodes[pc->opcode + 1] = prefixed_opcode;
+                    pc->opcode += 2;
+                }
+                break;
+
+                case WasmPrefixedOp_memory_fill:
+                if (mod_ptr[*code_i] != 0) panic("unexpected memory index");
+                *code_i += 1;
+                if (unreachable_depth == 0) {
+                    opcodes[pc->opcode + 0] = Op_wasm_prefixed;
+                    opcodes[pc->opcode + 1] = prefixed_opcode;
+                    pc->opcode += 2;
+                }
+                break;
+
+                default: panic("unreachable");
+            }
+            break;
+        }
+
+        switch (opcode) {
+            case WasmOp_unreachable:
+            case WasmOp_return:
+            case WasmOp_br:
+            case WasmOp_br_table:
+            if (unreachable_depth == 0) unreachable_depth = 1;
+            break;
+
+            default:
+            break;
+        }
+    }
+}
+
+static void vm_push_u32(struct VirtualMachine *vm, uint32_t value) {
+    vm->stack[vm->stack_top] = value;
+    vm->stack_top += 1;
+}
+
+static void vm_push_i32(struct VirtualMachine *vm, int32_t value) {
+    return vm_push_u32(vm, value);
+}
+
+static void vm_push_u64(struct VirtualMachine *vm, uint64_t value) {
+    vm->stack[vm->stack_top] = value;
+    vm->stack_top += 1;
+}
+
+static void vm_push_i64(struct VirtualMachine *vm, int64_t value) {
+    return vm_push_u64(vm, value);
+}
+
+static void vm_push_f32(struct VirtualMachine *vm, float value) {
+    uint32_t integer;
+    memcpy(&integer, &value, 4);
+    return vm_push_u32(vm, integer);
+}
+
+static void vm_push_f64(struct VirtualMachine *vm, double value) {
+    uint64_t integer;
+    memcpy(&integer, &value, 8);
+    return vm_push_u64(vm, integer);
+}
+
+static uint32_t vm_pop_u32(struct VirtualMachine *vm) {
+    vm->stack_top -= 1;
+    return vm->stack[vm->stack_top];
+}
+
+static int32_t vm_pop_i32(struct VirtualMachine *vm) {
+    return vm_pop_u32(vm);
+}
+
+static uint64_t vm_pop_u64(struct VirtualMachine *vm) {
+    vm->stack_top -= 1;
+    return vm->stack[vm->stack_top];
+}
+
+static int64_t vm_pop_i64(struct VirtualMachine *vm) {
+    return vm_pop_u64(vm);
+}
+
+static float vm_pop_f32(struct VirtualMachine *vm) {
+    uint32_t integer = vm_pop_u32(vm);
+    float result;
+    memcpy(&result, &integer, 4);
+    return result;
+}
+
+static double vm_pop_f64(struct VirtualMachine *vm) {
+    uint32_t integer = vm_pop_u64(vm);
+    double result;
+    memcpy(&result, &integer, 8);
+    return result;
+}
+
+static void vm_callImport(struct VirtualMachine *vm, struct Import import) {
+    switch (import.mod) {
+        case ImpMod_wasi_snapshot_preview1: switch (import.name) {
+            case ImpName_fd_prestat_get:
+            {
+                uint32_t buf = vm_pop_u32(vm);
+                int32_t fd = vm_pop_i32(vm);
+                vm_push_u32(vm, wasi_fd_prestat_get(vm, fd, buf));
+            }
+            break;
+            case ImpName_fd_prestat_dir_name:
+            {
+                uint32_t path_len = vm_pop_u32(vm);
+                uint32_t path = vm_pop_u32(vm);
+                int32_t fd = vm_pop_i32(vm);
+                vm_push_u32(vm, wasi_fd_prestat_dir_name(vm, fd, path, path_len));
+            }
+            break;
+            case ImpName_fd_close:
+            {
+                int32_t fd = vm_pop_i32(vm);
+                vm_push_u32(vm, wasi_fd_close(vm, fd));
+            }
+            break;
+            case ImpName_fd_read:
+            {
+                uint32_t nread = vm_pop_u32(vm);
+                uint32_t iovs_len = vm_pop_u32(vm);
+                uint32_t iovs = vm_pop_u32(vm);
+                int32_t fd = vm_pop_i32(vm);
+                vm_push_u32(vm, wasi_fd_read(vm, fd, iovs, iovs_len, nread));
+            }
+            break;
+            case ImpName_fd_filestat_get:
+            {
+                uint32_t buf = vm_pop_u32(vm);
+                int32_t fd = vm_pop_i32(vm);
+                vm_push_u32(vm, wasi_fd_filestat_get(vm, fd, buf));
+            }
+            break;
+            case ImpName_fd_filestat_set_size:
+            {
+                uint64_t size = vm_pop_u64(vm);
+                int32_t fd = vm_pop_i32(vm);
+                vm_push_u32(vm, wasi_fd_filestat_set_size(vm, fd, size));
+            }
+            break;
+            case ImpName_fd_filestat_set_times:
+            {
+                panic("unexpected call to fd_filestat_set_times");
+            }
+            break;
+            case ImpName_fd_fdstat_get:
+            {
+                uint32_t buf = vm_pop_u32(vm);
+                int32_t fd = vm_pop_i32(vm);
+                vm_push_u32(vm, wasi_fd_fdstat_get(vm, fd, buf));
+            }
+            break;
+            case ImpName_fd_readdir:
+            {
+                panic("TODO implement fd_readdir");
+            }
+            break;
+            case ImpName_fd_write:
+            {
+                uint32_t nwritten = vm_pop_u32(vm);
+                uint32_t iovs_len = vm_pop_u32(vm);
+                uint32_t iovs = vm_pop_u32(vm);
+                int32_t fd = vm_pop_i32(vm);
+                vm_push_u32(vm, wasi_fd_write(vm, fd, iovs, iovs_len, nwritten));
+            }
+            break;
+            case ImpName_fd_pwrite:
+            {
+                uint32_t nwritten = vm_pop_u32(vm);
+                uint64_t offset = vm_pop_u64(vm);
+                uint32_t iovs_len = vm_pop_u32(vm);
+                uint32_t iovs = vm_pop_u32(vm);
+                int32_t fd = vm_pop_i32(vm);
+                vm_push_u32(vm, wasi_fd_pwrite(vm, fd, iovs, iovs_len, offset, nwritten));
+            }
+            break;
+            case ImpName_proc_exit:
+            {
+                uint32_t code = vm_pop_u32(vm);
+                exit(code);
+            }
+            break;
+            case ImpName_args_sizes_get:
+            {
+                uint32_t argv_buf_size = vm_pop_u32(vm);
+                uint32_t argc = vm_pop_u32(vm);
+                vm_push_u32(vm, wasi_args_sizes_get(vm, argc, argv_buf_size));
+            }
+            break;
+            case ImpName_args_get:
+            {
+                uint32_t argv_buf = vm_pop_u32(vm);
+                uint32_t argv = vm_pop_u32(vm);
+                vm_push_u32(vm, wasi_args_get(vm, argv, argv_buf));
+            }
+            break;
+            case ImpName_random_get:
+            {
+                uint32_t buf_len = vm_pop_u32(vm);
+                uint32_t buf = vm_pop_u32(vm);
+                vm_push_u32(vm, wasi_random_get(vm, buf, buf_len));
+            }
+            break;
+            case ImpName_environ_sizes_get:
+            {
+                panic("unexpected call to environ_sizes_get");
+            }
+            break;
+            case ImpName_environ_get:
+            {
+                panic("unexpected call to environ_get");
+            }
+            break;
+            case ImpName_path_filestat_get:
+            {
+                uint32_t buf = vm_pop_u32(vm);
+                uint32_t path_len = vm_pop_u32(vm);
+                uint32_t path = vm_pop_u32(vm);
+                uint32_t flags = vm_pop_u32(vm);
+                int32_t fd = vm_pop_i32(vm);
+                vm_push_u32(vm, wasi_path_filestat_get(vm, fd, flags, path, path_len, buf));
+            }
+            break;
+            case ImpName_path_create_directory:
+            {
+                uint32_t path_len = vm_pop_u32(vm);
+                uint32_t path = vm_pop_u32(vm);
+                int32_t fd = vm_pop_i32(vm);
+                vm_push_u32(vm, wasi_path_create_directory(vm, fd, path, path_len));
+            }
+            break;
+            case ImpName_path_rename:
+            {
+                uint32_t new_path_len = vm_pop_u32(vm);
+                uint32_t new_path = vm_pop_u32(vm);
+                int32_t new_fd = vm_pop_i32(vm);
+                uint32_t old_path_len = vm_pop_u32(vm);
+                uint32_t old_path = vm_pop_u32(vm);
+                int32_t old_fd = vm_pop_i32(vm);
+                vm_push_u32(vm, wasi_path_rename(
+                    vm,
+                    old_fd,
+                    old_path,
+                    old_path_len,
+                    new_fd,
+                    new_path,
+                    new_path_len
+                ));
+            }
+            break;
+            case ImpName_path_open:
+            {
+                uint32_t fd = vm_pop_u32(vm);
+                uint32_t fs_flags = vm_pop_u32(vm);
+                uint64_t fs_rights_inheriting = vm_pop_u64(vm);
+                uint64_t fs_rights_base = vm_pop_u64(vm);
+                uint32_t oflags = vm_pop_u32(vm);
+                uint32_t path_len = vm_pop_u32(vm);
+                uint32_t path = vm_pop_u32(vm);
+                uint32_t dirflags = vm_pop_u32(vm);
+                int32_t dirfd = vm_pop_i32(vm);
+                vm_push_u32(vm, wasi_path_open(
+                    vm,
+                    dirfd,
+                    dirflags,
+                    path,
+                    path_len,
+                    oflags,
+                    fs_rights_base,
+                    fs_rights_inheriting,
+                    fs_flags,
+                    fd
+                ));
+            }
+            break;
+            case ImpName_path_remove_directory:
+            {
+                panic("unexpected call to path_remove_directory");
+            }
+            break;
+            case ImpName_path_unlink_file:
+            {
+                panic("unexpected call to path_unlink_file");
+            }
+            break;
+            case ImpName_clock_time_get:
+            {
+                uint32_t timestamp = vm_pop_u32(vm);
+                uint64_t precision = vm_pop_u64(vm);
+                uint32_t clock_id = vm_pop_u32(vm);
+                vm_push_u32(vm, wasi_clock_time_get(vm, clock_id, precision, timestamp));
+            }
+            break;
+            case ImpName_fd_pread:
+            {
+                panic("unexpected call to fd_pread");
+            }
+            break;
+            case ImpName_debug:
+            {
+                uint64_t number = vm_pop_u64(vm);
+                uint32_t text = vm_pop_u32(vm);
+                wasi_debug(vm, text, number);
+            }
+            break;
+            case ImpName_debug_slice:
+            {
+                uint32_t len = vm_pop_u32(vm);
+                uint32_t ptr = vm_pop_u32(vm);
+                wasi_debug_slice(vm, ptr, len);
+            }
+            break;
+        }
+        break;
+    }
+}
+
+static void vm_call(struct VirtualMachine *vm, uint32_t fn_id) {
+    if (fn_id < vm->imports_len) {
+        struct Import imp = vm->imports[fn_id];
+        return vm_callImport(vm, imp);
+    }
+    uint32_t fn_idx = fn_id - vm->imports_len;
+    struct Function *func = &vm->functions[fn_idx];
+
+    // Push zeroed locals to stack
+    memset(&vm->stack[vm->stack_top], 0, func->locals_count * sizeof(uint64_t));
+    vm->stack_top += func->locals_count;
+
+    vm_push_u32(vm, vm->pc.opcode);
+    vm_push_u32(vm, vm->pc.operand);
+
+    vm->pc = func->entry_pc;
+}
+
+static void vm_br_void(struct VirtualMachine *vm) {
+    uint32_t stack_adjust = vm->operands[vm->pc.operand];
+
+    vm->stack_top -= stack_adjust;
+
+    vm->pc.opcode = vm->operands[vm->pc.operand + 1];
+    vm->pc.operand = vm->operands[vm->pc.operand + 2];
+}
+
+static void vm_br_u32(struct VirtualMachine *vm) {
+    uint32_t stack_adjust = vm->operands[vm->pc.operand];
+
+    uint32_t result = vm_pop_u32(vm);
+    vm->stack_top -= stack_adjust;
+    vm_push_u32(vm, result);
+
+    vm->pc.opcode = vm->operands[vm->pc.operand + 1];
+    vm->pc.operand = vm->operands[vm->pc.operand + 2];
+}
+
+static void vm_br_u64(struct VirtualMachine *vm) {
+    uint32_t stack_adjust = vm->operands[vm->pc.operand];
+
+    uint64_t result = vm_pop_u64(vm);
+    vm->stack_top -= stack_adjust;
+    vm_push_u64(vm, result);
+
+    vm->pc.opcode = vm->operands[vm->pc.operand + 1];
+    vm->pc.operand = vm->operands[vm->pc.operand + 2];
+}
+
+static void vm_return_void(struct VirtualMachine *vm) {
+    uint32_t ret_pc_offset = vm->operands[vm->pc.operand + 0];
+    uint32_t stack_adjust = vm->operands[vm->pc.operand + 1];
+
+    vm->pc.opcode = vm->stack[vm->stack_top - ret_pc_offset];
+    vm->pc.operand = vm->stack[vm->stack_top - ret_pc_offset + 1];
+
+    vm->stack_top -= stack_adjust;
+}
+
+static void vm_return_u32(struct VirtualMachine *vm) {
+    uint32_t ret_pc_offset = vm->operands[vm->pc.operand + 0];
+    uint32_t stack_adjust = vm->operands[vm->pc.operand + 1];
+
+    vm->pc.opcode = vm->stack[vm->stack_top - ret_pc_offset];
+    vm->pc.operand = vm->stack[vm->stack_top - ret_pc_offset + 1];
+
+    uint32_t result = vm_pop_u32(vm);
+    vm->stack_top -= stack_adjust;
+    vm_push_u32(vm, result);
+}
+
+static void vm_return_u64(struct VirtualMachine *vm) {
+    uint32_t ret_pc_offset = vm->operands[vm->pc.operand + 0];
+    uint32_t stack_adjust = vm->operands[vm->pc.operand + 1];
+
+    vm->pc.opcode = vm->stack[vm->stack_top - ret_pc_offset];
+    vm->pc.operand = vm->stack[vm->stack_top - ret_pc_offset + 1];
+
+    uint64_t result = vm_pop_u64(vm);
+    vm->stack_top -= stack_adjust;
+    vm_push_u64(vm, result);
+}
+
+static void vm_run(struct VirtualMachine *vm) {
+    uint8_t *opcodes = vm->opcodes;
+    uint32_t *operands = vm->operands;
+    struct ProgramCounter *pc = &vm->pc;
+    for (;;) {
+        enum Op op = opcodes[pc->opcode];
+        pc->opcode += 1;
+        switch (op) {
+            case Op_unreachable:
+                panic("unreachable reached");
+
+            case Op_br_void:
+                vm_br_void(vm);
+                break;
+
+            case Op_br_32:
+                vm_br_u32(vm);
+                break;
+
+            case Op_br_64:
+                vm_br_u64(vm);
+                break;
+
+            case Op_br_if_nez_void:
+                if (vm_pop_u32(vm) != 0) {
+                    vm_br_void(vm);
+                } else {
+                    pc->operand += 3;
+                }
+                break;
+
+            case Op_br_if_nez_32:
+                if (vm_pop_u32(vm) != 0) {
+                    vm_br_u32(vm);
+                } else {
+                    pc->operand += 3;
+                }
+                break;
+
+            case Op_br_if_nez_64:
+                if (vm_pop_u32(vm) != 0) {
+                    vm_br_u64(vm);
+                } else {
+                    pc->operand += 3;
+                }
+                break;
+
+            case Op_br_if_eqz_void:
+                if (vm_pop_u32(vm) == 0) {
+                    vm_br_void(vm);
+                } else {
+                    pc->operand += 3;
+                }
+                break;
+
+            case Op_br_if_eqz_32:
+                if (vm_pop_u32(vm) == 0) {
+                    vm_br_u32(vm);
+                } else {
+                    pc->operand += 3;
+                }
+                break;
+
+            case Op_br_if_eqz_64:
+                if (vm_pop_u32(vm) == 0) {
+                    vm_br_u64(vm);
+                } else {
+                    pc->operand += 3;
+                }
+                break;
+
+            case Op_br_table_void:
+                {
+                    uint32_t index = min_u32(vm_pop_u32(vm), operands[pc->operand]);
+                    pc->operand += 1 + index * 3;
+                    vm_br_void(vm);
+                }
+                break;
+
+            case Op_br_table_32:
+                {
+                    uint32_t index = min_u32(vm_pop_u32(vm), operands[pc->operand]);
+                    pc->operand += 1 + index * 3;
+                    vm_br_u32(vm);
+                }
+                break;
+
+            case Op_br_table_64:
+                {
+                    uint32_t index = min_u32(vm_pop_u32(vm), operands[pc->operand]);
+                    pc->operand += 1 + index * 3;
+                    vm_br_u64(vm);
+                }
+                break;
+
+            case Op_return_void:
+                vm_return_void(vm);
+                break;
+
+            case Op_return_32:
+                vm_return_u32(vm);
+                break;
+
+            case Op_return_64:
+                vm_return_u64(vm);
+                break;
+
+            case Op_call:
+                {
+                    uint32_t fn_id = operands[pc->operand];
+                    pc->operand += 1;
+                    vm_call(vm, fn_id);
+                }
+                break;
+
+            case Op_drop_32:
+            case Op_drop_64:
+                vm->stack_top -= 1;
+                break;
+
+            case Op_select_32:
+                {
+                    uint32_t c = vm_pop_u32(vm);
+                    uint32_t b = vm_pop_u32(vm);
+                    uint32_t a = vm_pop_u32(vm);
+                    uint32_t result = (c != 0) ? a : b;
+                    vm_push_u32(vm, result);
+                }
+                break;
+
+            case Op_select_64:
+                {
+                    uint32_t c = vm_pop_u32(vm);
+                    uint64_t b = vm_pop_u64(vm);
+                    uint64_t a = vm_pop_u64(vm);
+                    uint64_t result = (c != 0) ? a : b;
+                    vm_push_u64(vm, result);
+                }
+                break;
+
+            case Op_local_get_32:
+                {
+                    uint64_t *local = &vm->stack[vm->stack_top - operands[pc->operand]];
+                    pc->operand += 1;
+                    vm_push_u32(vm, *local);
+                }
+                break;
+
+            case Op_local_get_64:
+                {
+                    uint64_t *local = &vm->stack[vm->stack_top - operands[pc->operand]];
+                    pc->operand += 1;
+                    vm_push_u64(vm, *local);
+                }
+                break;
+
+            case Op_local_set_32:
+                {
+                    uint64_t *local = &vm->stack[vm->stack_top - operands[pc->operand]];
+                    pc->operand += 1;
+                    *local = vm_pop_u32(vm);
+                }
+                break;
+
+            case Op_local_set_64:
+                {
+                    uint64_t *local = &vm->stack[vm->stack_top - operands[pc->operand]];
+                    pc->operand += 1;
+                    *local = vm_pop_u64(vm);
+                }
+                break;
+
+            case Op_local_tee_32:
+            case Op_local_tee_64:
+                {
+                    uint64_t *local = &vm->stack[vm->stack_top - operands[pc->operand]];
+                    pc->operand += 1;
+                    *local = vm->stack[vm->stack_top - 1];
+                }
+                break;
+
+            case Op_global_get_0_32:
+                vm_push_u32(vm, vm->globals[0]);
+                break;
+
+            case Op_global_get_32:
+                {
+                    uint32_t idx = operands[pc->operand];
+                    pc->operand += 1;
+                    vm_push_u32(vm, vm->globals[idx]);
+                }
+                break;
+
+            case Op_global_set_0_32:
+                vm->globals[0] = vm_pop_u32(vm);
+                break;
+
+            case Op_global_set_32:
+                {
+                    uint32_t idx = operands[pc->operand];
+                    pc->operand += 1;
+                    vm->globals[idx] = vm_pop_u32(vm);
+                }
+                break;
+
+            case Op_const_32:
+                {
+                    uint32_t x = operands[pc->operand];
+                    pc->operand += 1;
+                    vm_push_i32(vm, x);
+                }
+                break;
+
+            case Op_const_64:
+                {
+                    uint64_t x = ((uint64_t)operands[pc->operand]) |
+                        (((uint64_t)operands[pc->operand + 1]) << 32);
+                    pc->operand += 2;
+                    vm_push_i64(vm, x);
+                }
+                break;
+
+            case Op_add_32:
+                {
+                    uint32_t rhs = vm_pop_u32(vm);
+                    uint32_t lhs = vm_pop_u32(vm);
+                    vm_push_u32(vm, lhs + rhs);
+                }
+                break;
+
+            case Op_and_32:
+                {
+                    uint32_t rhs = vm_pop_u32(vm);
+                    uint32_t lhs = vm_pop_u32(vm);
+                    vm_push_u32(vm, lhs & rhs);
+                }
+                break;
+
+            case Op_wasm:
+                {
+                    enum WasmOp wasm_op = opcodes[pc->opcode];
+                    pc->opcode += 1;
+                    switch (wasm_op) {
+                        case WasmOp_unreachable:
+                        case WasmOp_nop:
+                        case WasmOp_block:
+                        case WasmOp_loop:
+                        case WasmOp_if:
+                        case WasmOp_else:
+                        case WasmOp_end:
+                        case WasmOp_br:
+                        case WasmOp_br_if:
+                        case WasmOp_br_table:
+                        case WasmOp_return:
+                        case WasmOp_call:
+                        case WasmOp_drop:
+                        case WasmOp_select:
+                        case WasmOp_local_get:
+                        case WasmOp_local_set:
+                        case WasmOp_local_tee:
+                        case WasmOp_global_get:
+                        case WasmOp_global_set:
+                        case WasmOp_i32_const:
+                        case WasmOp_i64_const:
+                        case WasmOp_f32_const:
+                        case WasmOp_f64_const:
+                        case WasmOp_i32_add:
+                        case WasmOp_i32_and:
+                        case WasmOp_i32_reinterpret_f32:
+                        case WasmOp_i64_reinterpret_f64:
+                        case WasmOp_f32_reinterpret_i32:
+                        case WasmOp_f64_reinterpret_i64:
+                        case WasmOp_prefixed:
+                            panic("not produced by decodeCode");
+                            break;
+
+                        case WasmOp_call_indirect:
+                            {
+                                uint32_t fn_id = vm->table[vm_pop_u32(vm)];
+                                vm_call(vm, fn_id);
+                            }
+                            break;
+                        case WasmOp_i32_load:
+                            {
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                vm_push_u32(vm, read_u32_le(vm->memory + offset));
+                            }
+                            break;
+                        case WasmOp_i64_load:
+                            {
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                vm_push_u64(vm, read_u64_le(vm->memory + offset));
+                            }
+                            break;
+                        case WasmOp_f32_load:
+                            {
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                uint32_t integer = read_u32_le(vm->memory + offset);
+                                vm_push_u32(vm, integer);
+                            }
+                            break;
+                        case WasmOp_f64_load:
+                            {
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                uint64_t integer = read_u64_le(vm->memory + offset);
+                                vm_push_u64(vm, integer);
+                            }
+                            break;
+                        case WasmOp_i32_load8_s:
+                            {
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                vm_push_i32(vm, (int8_t)vm->memory[offset]);
+                            }
+                            break;
+                        case WasmOp_i32_load8_u:
+                            {
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                vm_push_u32(vm, vm->memory[offset]);
+                            }
+                            break;
+                        case WasmOp_i32_load16_s:
+                            {
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                int16_t integer = read_i16_le(vm->memory + offset);
+                                vm_push_i32(vm, integer);
+                            }
+                            break;
+                        case WasmOp_i32_load16_u:
+                            {
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                uint16_t integer = read_u16_le(vm->memory + offset);
+                                vm_push_u32(vm, integer);
+                            }
+                            break;
+                        case WasmOp_i64_load8_s:
+                            {
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                vm_push_i64(vm, (int8_t)vm->memory[offset]);
+                            }
+                            break;
+                        case WasmOp_i64_load8_u:
+                            {
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                vm_push_u64(vm, vm->memory[offset]);
+                            }
+                            break;
+                        case WasmOp_i64_load16_s:
+                            {
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                int16_t integer = read_i16_le(vm->memory + offset);
+                                vm_push_i64(vm, integer);
+                            }
+                            break;
+                        case WasmOp_i64_load16_u:
+                            {
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                uint16_t integer = read_u16_le(vm->memory + offset);
+                                vm_push_u64(vm, integer);
+                            }
+                            break;
+                        case WasmOp_i64_load32_s:
+                            {
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                int32_t integer = read_i32_le(vm->memory + offset);
+                                vm_push_i64(vm, integer);
+                            }
+                            break;
+                        case WasmOp_i64_load32_u:
+                            {
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                uint32_t integer = read_u32_le(vm->memory + offset);
+                                vm_push_u64(vm, integer);
+                            }
+                            break;
+                        case WasmOp_i32_store:
+                            {
+                                uint32_t operand = vm_pop_u32(vm);
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                write_u32_le(vm->memory + offset, operand);
+                            }
+                            break;
+                        case WasmOp_i64_store:
+                            {
+                                uint64_t operand = vm_pop_u64(vm);
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                write_u64_le(vm->memory + offset, operand);
+                            }
+                            break;
+                        case WasmOp_f32_store:
+                            {
+                                uint32_t integer = vm_pop_u32(vm);
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                write_u32_le(vm->memory + offset, integer);
+                            }
+                            break;
+                        case WasmOp_f64_store:
+                            {
+                                uint64_t integer = vm_pop_u64(vm);
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                write_u64_le(vm->memory + offset, integer);
+                            }
+                            break;
+                        case WasmOp_i32_store8:
+                            {
+                                uint8_t small = vm_pop_u32(vm);
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                vm->memory[offset] = small;
+                            }
+                            break;
+                        case WasmOp_i32_store16:
+                            {
+                                uint16_t small = vm_pop_u32(vm);
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                write_u16_le(vm->memory + offset, small);
+                            }
+                            break;
+                        case WasmOp_i64_store8:
+                            {
+                                uint8_t operand = vm_pop_u64(vm);
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                vm->memory[offset] = operand;
+                            }
+                            break;
+                        case WasmOp_i64_store16:
+                            {
+                                uint16_t small = vm_pop_u64(vm);
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                write_u16_le(vm->memory + offset, small);
+                            }
+                            break;
+                        case WasmOp_i64_store32:
+                            {
+                                uint32_t small = vm_pop_u64(vm);
+                                uint32_t offset = operands[pc->operand] + vm_pop_u32(vm);
+                                pc->operand += 1;
+                                write_u32_le(vm->memory + offset, small);
+                            }
+                            break;
+                        case WasmOp_memory_size:
+                            {
+                                uint32_t page_count = vm->memory_len / wasm_page_size;
+                                vm_push_u32(vm, page_count);
+                            }
+                            break;
+                        case WasmOp_memory_grow:
+                            {
+                                uint32_t page_count = vm_pop_u32(vm);
+                                uint32_t old_page_count = vm->memory_len / wasm_page_size;
+                                uint32_t new_len = vm->memory_len + page_count * wasm_page_size;
+                                if (new_len > vm->memory_len) {
+                                    vm_push_i32(vm, -1);
+                                } else {
+                                    vm->memory_len = new_len;
+                                    vm_push_u32(vm, old_page_count);
+                                }
+                            }
+                            break;
+                        case WasmOp_i32_eqz:
+                            {
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, lhs == 0);
+                            }
+                            break;
+                        case WasmOp_i32_eq:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, lhs == rhs);
+                            }
+                            break;
+                        case WasmOp_i32_ne:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, lhs != rhs);
+                            }
+                            break;
+                        case WasmOp_i32_lt_s:
+                            {
+                                int32_t rhs = vm_pop_i32(vm);
+                                int32_t lhs = vm_pop_i32(vm);
+                                vm_push_u32(vm, lhs < rhs);
+                            }
+                            break;
+                        case WasmOp_i32_lt_u:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, lhs < rhs);
+                            }
+                            break;
+                        case WasmOp_i32_gt_s:
+                            {
+                                int32_t rhs = vm_pop_i32(vm);
+                                int32_t lhs = vm_pop_i32(vm);
+                                vm_push_u32(vm, lhs > rhs);
+                            }
+                            break;
+                        case WasmOp_i32_gt_u:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, lhs > rhs);
+                            }
+                            break;
+                        case WasmOp_i32_le_s:
+                            {
+                                int32_t rhs = vm_pop_i32(vm);
+                                int32_t lhs = vm_pop_i32(vm);
+                                vm_push_u32(vm, lhs <= rhs);
+                            }
+                            break;
+                        case WasmOp_i32_le_u:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, lhs <= rhs);
+                            }
+                            break;
+                        case WasmOp_i32_ge_s:
+                            {
+                                int32_t rhs = vm_pop_i32(vm);
+                                int32_t lhs = vm_pop_i32(vm);
+                                vm_push_u32(vm, lhs >= rhs);
+                            }
+                            break;
+                        case WasmOp_i32_ge_u:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, lhs >= rhs);
+                            }
+                            break;
+                        case WasmOp_i64_eqz:
+                            {
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u32(vm, lhs == 0);
+                            }
+                            break;
+                        case WasmOp_i64_eq:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u32(vm, lhs == rhs);
+                            }
+                            break;
+                        case WasmOp_i64_ne:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u32(vm, lhs != rhs);
+                            }
+                            break;
+                        case WasmOp_i64_lt_s:
+                            {
+                                int64_t rhs = vm_pop_i64(vm);
+                                int64_t lhs = vm_pop_i64(vm);
+                                vm_push_u32(vm, lhs < rhs);
+                            }
+                            break;
+                        case WasmOp_i64_lt_u:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u32(vm, lhs < rhs);
+                            }
+                            break;
+                        case WasmOp_i64_gt_s:
+                            {
+                                int64_t rhs = vm_pop_i64(vm);
+                                int64_t lhs = vm_pop_i64(vm);
+                                vm_push_u32(vm, lhs > rhs);
+                            }
+                            break;
+                        case WasmOp_i64_gt_u:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u32(vm, lhs > rhs);
+                            }
+                            break;
+                        case WasmOp_i64_le_s:
+                            {
+                                int64_t rhs = vm_pop_i64(vm);
+                                int64_t lhs = vm_pop_i64(vm);
+                                vm_push_u32(vm, lhs <= rhs);
+                            }
+                            break;
+                        case WasmOp_i64_le_u:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u32(vm, lhs <= rhs);
+                            }
+                            break;
+                        case WasmOp_i64_ge_s:
+                            {
+                                int64_t rhs = vm_pop_i64(vm);
+                                int64_t lhs = vm_pop_i64(vm);
+                                vm_push_u32(vm, lhs >= rhs);
+                            }
+                            break;
+                        case WasmOp_i64_ge_u:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u32(vm, lhs >= rhs);
+                            }
+                            break;
+                        case WasmOp_f32_eq:
+                            {
+                                float rhs = vm_pop_f32(vm);
+                                float lhs = vm_pop_f32(vm);
+                                vm_push_u32(vm, lhs == rhs);
+                            }
+                            break;
+                        case WasmOp_f32_ne:
+                            {
+                                float rhs = vm_pop_f32(vm);
+                                float lhs = vm_pop_f32(vm);
+                                vm_push_u32(vm, lhs != rhs);
+                            }
+                            break;
+                        case WasmOp_f32_lt:
+                            {
+                                float rhs = vm_pop_f32(vm);
+                                float lhs = vm_pop_f32(vm);
+                                vm_push_u32(vm, lhs < rhs);
+                            }
+                            break;
+                        case WasmOp_f32_gt:
+                            {
+                                float rhs = vm_pop_f32(vm);
+                                float lhs = vm_pop_f32(vm);
+                                vm_push_u32(vm, lhs > rhs);
+                            }
+                            break;
+                        case WasmOp_f32_le:
+                            {
+                                float rhs = vm_pop_f32(vm);
+                                float lhs = vm_pop_f32(vm);
+                                vm_push_u32(vm, lhs <= rhs);
+                            }
+                            break;
+                        case WasmOp_f32_ge:
+                            {
+                                float rhs = vm_pop_f32(vm);
+                                float lhs = vm_pop_f32(vm);
+                                vm_push_u32(vm, lhs >= rhs);
+                            }
+                            break;
+                        case WasmOp_f64_eq:
+                            {
+                                double rhs = vm_pop_f64(vm);
+                                double lhs = vm_pop_f64(vm);
+                                vm_push_u32(vm, lhs == rhs);
+                            }
+                            break;
+                        case WasmOp_f64_ne:
+                            {
+                                double rhs = vm_pop_f64(vm);
+                                double lhs = vm_pop_f64(vm);
+                                vm_push_u32(vm, lhs != rhs);
+                            }
+                            break;
+                        case WasmOp_f64_lt:
+                            {
+                                double rhs = vm_pop_f64(vm);
+                                double lhs = vm_pop_f64(vm);
+                                vm_push_u32(vm, lhs <= rhs);
+                            }
+                            break;
+                        case WasmOp_f64_gt:
+                            {
+                                double rhs = vm_pop_f64(vm);
+                                double lhs = vm_pop_f64(vm);
+                                vm_push_u32(vm, lhs > rhs);
+                            }
+                            break;
+                        case WasmOp_f64_le:
+                            {
+                                double rhs = vm_pop_f64(vm);
+                                double lhs = vm_pop_f64(vm);
+                                vm_push_u32(vm, lhs <= rhs);
+                            }
+                            break;
+                        case WasmOp_f64_ge:
+                            {
+                                double rhs = vm_pop_f64(vm);
+                                double lhs = vm_pop_f64(vm);
+                                vm_push_u32(vm, lhs >= rhs);
+                            }
+                            break;
+
+                        case WasmOp_i32_clz:
+                            {
+                                uint32_t operand = vm_pop_u32(vm);
+                                uint32_t result = (operand == 0) ? 32 : __builtin_clz(operand);
+                                vm_push_u32(vm, result);
+                            }
+                            break;
+                        case WasmOp_i32_ctz:
+                            {
+                                uint32_t operand = vm_pop_u32(vm);
+                                uint32_t result = (operand == 0) ? 32 : __builtin_ctz(operand);
+                                vm_push_u32(vm, result);
+                            }
+                            break;
+                        case WasmOp_i32_popcnt:
+                            {
+                                uint32_t operand = vm_pop_u32(vm);
+                                uint32_t result = __builtin_popcount(operand);
+                                vm_push_u32(vm, result);
+                            }
+                            break;
+                        case WasmOp_i32_sub:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, lhs - rhs);
+                            }
+                            break;
+                        case WasmOp_i32_mul:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, lhs * rhs);
+                            }
+                            break;
+                        case WasmOp_i32_div_s:
+                            {
+                                int32_t rhs = vm_pop_i32(vm);
+                                int32_t lhs = vm_pop_i32(vm);
+                                vm_push_i32(vm, lhs / rhs);
+                            }
+                            break;
+                        case WasmOp_i32_div_u:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, lhs / rhs);
+                            }
+                            break;
+                        case WasmOp_i32_rem_s:
+                            {
+                                int32_t rhs = vm_pop_i32(vm);
+                                int32_t lhs = vm_pop_i32(vm);
+                                vm_push_i32(vm, lhs % rhs);
+                            }
+                            break;
+                        case WasmOp_i32_rem_u:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, lhs % rhs);
+                            }
+                            break;
+                        case WasmOp_i32_or:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, lhs | rhs);
+                            }
+                            break;
+                        case WasmOp_i32_xor:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, lhs ^ rhs);
+                            }
+                            break;
+                        case WasmOp_i32_shl:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, lhs << rhs);
+                            }
+                            break;
+                        case WasmOp_i32_shr_s:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                int32_t lhs = vm_pop_i32(vm);
+                                vm_push_i32(vm, lhs >> rhs);
+                            }
+                            break;
+                        case WasmOp_i32_shr_u:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, lhs >> rhs);
+                            }
+                            break;
+                        case WasmOp_i32_rotl:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, rotl32(lhs, rhs));
+                            }
+                            break;
+                        case WasmOp_i32_rotr:
+                            {
+                                uint32_t rhs = vm_pop_u32(vm);
+                                uint32_t lhs = vm_pop_u32(vm);
+                                vm_push_u32(vm, rotr32(lhs, rhs ));
+                            }
+                            break;
+
+                        case WasmOp_i64_clz:
+                            {
+                                uint64_t operand = vm_pop_u64(vm);
+                                uint64_t result = (operand == 0) ? 64 : __builtin_clzll(operand);
+                                vm_push_u64(vm, result);
+                            }
+                            break;
+                        case WasmOp_i64_ctz:
+                            {
+                                uint64_t operand = vm_pop_u64(vm);
+                                uint64_t result = (operand == 0) ? 64 : __builtin_ctzll(operand);
+                                vm_push_u64(vm, result);
+                            }
+                            break;
+                        case WasmOp_i64_popcnt:
+                            {
+                                uint64_t operand = vm_pop_u64(vm);
+                                uint64_t result = __builtin_popcountll(operand);
+                                vm_push_u64(vm, result);
+                            }
+                            break;
+                        case WasmOp_i64_add:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u64(vm, lhs + rhs);
+                            }
+                            break;
+                        case WasmOp_i64_sub:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u64(vm, lhs - rhs);
+                            }
+                            break;
+                        case WasmOp_i64_mul:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u64(vm, lhs * rhs);
+                            }
+                            break;
+                        case WasmOp_i64_div_s:
+                            {
+                                int64_t rhs = vm_pop_i64(vm);
+                                int64_t lhs = vm_pop_i64(vm);
+                                vm_push_i64(vm, lhs / rhs);
+                            }
+                            break;
+                        case WasmOp_i64_div_u:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u64(vm, lhs / rhs);
+                            }
+                            break;
+                        case WasmOp_i64_rem_s:
+                            {
+                                int64_t rhs = vm_pop_i64(vm);
+                                int64_t lhs = vm_pop_i64(vm);
+                                vm_push_i64(vm, lhs % rhs);
+                            }
+                            break;
+                        case WasmOp_i64_rem_u:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u64(vm, lhs % rhs);
+                            }
+                            break;
+                        case WasmOp_i64_and:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u64(vm, lhs & rhs);
+                            }
+                            break;
+                        case WasmOp_i64_or:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u64(vm, lhs | rhs);
+                            }
+                            break;
+                        case WasmOp_i64_xor:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u64(vm, lhs ^ rhs);
+                            }
+                            break;
+                        case WasmOp_i64_shl:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u64(vm, lhs << rhs);
+                            }
+                            break;
+                        case WasmOp_i64_shr_s:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                int64_t lhs = vm_pop_i64(vm);
+                                vm_push_i64(vm, lhs >> rhs);
+                            }
+                            break;
+                        case WasmOp_i64_shr_u:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u64(vm, lhs >> rhs);
+                            }
+                            break;
+                        case WasmOp_i64_rotl:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u64(vm, rotl64(lhs, rhs ));
+                            }
+                            break;
+                        case WasmOp_i64_rotr:
+                            {
+                                uint64_t rhs = vm_pop_u64(vm);
+                                uint64_t lhs = vm_pop_u64(vm);
+                                vm_push_u64(vm, rotr64(lhs, rhs ));
+                            }
+                            break;
+
+                        case WasmOp_f32_abs:
+                            {
+                                vm_push_f32(vm, fabsf(vm_pop_f32(vm)));
+                            }
+                            break;
+                        case WasmOp_f32_neg:
+                            {
+                                vm_push_f32(vm, -vm_pop_f32(vm));
+                            }
+                            break;
+                        case WasmOp_f32_ceil:
+                            {
+                                vm_push_f32(vm, ceilf(vm_pop_f32(vm)));
+                            }
+                            break;
+                        case WasmOp_f32_floor:
+                            {
+                                vm_push_f32(vm, floorf(vm_pop_f32(vm)));
+                            }
+                            break;
+                        case WasmOp_f32_trunc:
+                            {
+                                vm_push_f32(vm, truncf(vm_pop_f32(vm)));
+                            }
+                            break;
+                        case WasmOp_f32_nearest:
+                            {
+                                vm_push_f32(vm, roundf(vm_pop_f32(vm)));
+                            }
+                            break;
+                        case WasmOp_f32_sqrt:
+                            {
+                                vm_push_f32(vm, sqrtf(vm_pop_f32(vm)));
+                            }
+                            break;
+                        case WasmOp_f32_add:
+                            {
+                                float rhs = vm_pop_f32(vm);
+                                float lhs = vm_pop_f32(vm);
+                                vm_push_f32(vm, lhs + rhs);
+                            }
+                            break;
+                        case WasmOp_f32_sub:
+                            {
+                                float rhs = vm_pop_f32(vm);
+                                float lhs = vm_pop_f32(vm);
+                                vm_push_f32(vm, lhs - rhs);
+                            }
+                            break;
+                        case WasmOp_f32_mul:
+                            {
+                                float rhs = vm_pop_f32(vm);
+                                float lhs = vm_pop_f32(vm);
+                                vm_push_f32(vm, lhs * rhs);
+                            }
+                            break;
+                        case WasmOp_f32_div:
+                            {
+                                float rhs = vm_pop_f32(vm);
+                                float lhs = vm_pop_f32(vm);
+                                vm_push_f32(vm, lhs / rhs);
+                            }
+                            break;
+                        case WasmOp_f32_min:
+                            {
+                                float rhs = vm_pop_f32(vm);
+                                float lhs = vm_pop_f32(vm);
+                                vm_push_f32(vm, (lhs < rhs) ? lhs : rhs);
+                            }
+                            break;
+                        case WasmOp_f32_max:
+                            {
+                                float rhs = vm_pop_f32(vm);
+                                float lhs = vm_pop_f32(vm);
+                                vm_push_f32(vm, (lhs > rhs) ? lhs : rhs);
+                            }
+                            break;
+                        case WasmOp_f32_copysign:
+                            {
+                                float rhs = vm_pop_f32(vm);
+                                float lhs = vm_pop_f32(vm);
+                                vm_push_f32(vm, copysignf(lhs, rhs));
+                            }
+                            break;
+                        case WasmOp_f64_abs:
+                            {
+                                vm_push_f64(vm, fabs(vm_pop_f64(vm)));
+                            }
+                            break;
+                        case WasmOp_f64_neg:
+                            {
+                                vm_push_f64(vm, -vm_pop_f64(vm));
+                            }
+                            break;
+                        case WasmOp_f64_ceil:
+                            {
+                                vm_push_f64(vm, ceil(vm_pop_f64(vm)));
+                            }
+                            break;
+                        case WasmOp_f64_floor:
+                            {
+                                vm_push_f64(vm, floor(vm_pop_f64(vm)));
+                            }
+                            break;
+                        case WasmOp_f64_trunc:
+                            {
+                                vm_push_f64(vm, trunc(vm_pop_f64(vm)));
+                            }
+                            break;
+                        case WasmOp_f64_nearest:
+                            {
+                                vm_push_f64(vm, round(vm_pop_f64(vm)));
+                            }
+                            break;
+                        case WasmOp_f64_sqrt:
+                            {
+                                vm_push_f64(vm, sqrt(vm_pop_f64(vm)));
+                            }
+                            break;
+                        case WasmOp_f64_add:
+                            {
+                                double rhs = vm_pop_f64(vm);
+                                double lhs = vm_pop_f64(vm);
+                                vm_push_f64(vm, lhs + rhs);
+                            }
+                            break;
+                        case WasmOp_f64_sub:
+                            {
+                                double rhs = vm_pop_f64(vm);
+                                double lhs = vm_pop_f64(vm);
+                                vm_push_f64(vm, lhs - rhs);
+                            }
+                            break;
+                        case WasmOp_f64_mul:
+                            {
+                                double rhs = vm_pop_f64(vm);
+                                double lhs = vm_pop_f64(vm);
+                                vm_push_f64(vm, lhs * rhs);
+                            }
+                            break;
+                        case WasmOp_f64_div:
+                            {
+                                double rhs = vm_pop_f64(vm);
+                                double lhs = vm_pop_f64(vm);
+                                vm_push_f64(vm, lhs / rhs);
+                            }
+                            break;
+                        case WasmOp_f64_min:
+                            {
+                                double rhs = vm_pop_f64(vm);
+                                double lhs = vm_pop_f64(vm);
+                                vm_push_f64(vm, (lhs < rhs) ? lhs : rhs);
+                            }
+                            break;
+                        case WasmOp_f64_max:
+                            {
+                                double rhs = vm_pop_f64(vm);
+                                double lhs = vm_pop_f64(vm);
+                                vm_push_f64(vm, (lhs > rhs) ? lhs : rhs);
+                            }
+                            break;
+                        case WasmOp_f64_copysign:
+                            {
+                                double rhs = vm_pop_f64(vm);
+                                double lhs = vm_pop_f64(vm);
+                                vm_push_f64(vm, copysign(lhs, rhs));
+                            }
+                            break;
+
+                        case WasmOp_i32_wrap_i64:
+                            {
+                                uint64_t operand = vm_pop_u64(vm);
+                                vm_push_u32(vm, operand);
+                            }
+                            break;
+                        case WasmOp_i32_trunc_f32_s:
+                            {
+                                float operand = vm_pop_f32(vm);
+                                vm_push_i32(vm, truncf(operand));
+                            }
+                            break;
+                        case WasmOp_i32_trunc_f32_u:
+                            {
+                                float operand = vm_pop_f32(vm);
+                                vm_push_u32(vm, truncf(operand));
+                            }
+                            break;
+                        case WasmOp_i32_trunc_f64_s:
+                            {
+                                double operand = vm_pop_f64(vm);
+                                vm_push_i32(vm, trunc(operand));
+                            }
+                            break;
+                        case WasmOp_i32_trunc_f64_u:
+                            {
+                                double operand = vm_pop_f64(vm);
+                                vm_push_u32(vm, trunc(operand));
+                            }
+                            break;
+                        case WasmOp_i64_extend_i32_s:
+                            {
+                                int32_t operand = vm_pop_i32(vm);
+                                vm_push_i64(vm, operand);
+                            }
+                            break;
+                        case WasmOp_i64_extend_i32_u:
+                            {
+                                uint64_t operand = vm_pop_u64(vm);
+                                vm_push_u64(vm, operand);
+                            }
+                            break;
+                        case WasmOp_i64_trunc_f32_s:
+                            {
+                                float operand = vm_pop_f32(vm);
+                                vm_push_i64(vm, truncf(operand));
+                            }
+                            break;
+                        case WasmOp_i64_trunc_f32_u:
+                            {
+                                float operand = vm_pop_f32(vm);
+                                vm_push_u64(vm, truncf(operand));
+                            }
+                            break;
+                        case WasmOp_i64_trunc_f64_s:
+                            {
+                                double operand = vm_pop_f64(vm);
+                                vm_push_i64(vm, trunc(operand));
+                            }
+                            break;
+                        case WasmOp_i64_trunc_f64_u:
+                            {
+                                double operand = vm_pop_f64(vm);
+                                vm_push_u64(vm, trunc(operand));
+                            }
+                            break;
+                        case WasmOp_f32_convert_i32_s:
+                            {
+                                vm_push_f32(vm, vm_pop_i32(vm));
+                            }
+                            break;
+                        case WasmOp_f32_convert_i32_u:
+                            {
+                                vm_push_f32(vm, vm_pop_u32(vm));
+                            }
+                            break;
+                        case WasmOp_f32_convert_i64_s:
+                            {
+                                vm_push_f32(vm, vm_pop_i64(vm));
+                            }
+                            break;
+                        case WasmOp_f32_convert_i64_u:
+                            {
+                                vm_push_f32(vm, vm_pop_u64(vm));
+                            }
+                            break;
+                        case WasmOp_f32_demote_f64:
+                            {
+                                vm_push_f32(vm, vm_pop_f64(vm));
+                            }
+                            break;
+                        case WasmOp_f64_convert_i32_s:
+                            {
+                                vm_push_f64(vm, vm_pop_i32(vm));
+                            }
+                            break;
+                        case WasmOp_f64_convert_i32_u:
+                            {
+                                vm_push_f64(vm, vm_pop_u32(vm));
+                            }
+                            break;
+                        case WasmOp_f64_convert_i64_s:
+                            {
+                                vm_push_f64(vm, vm_pop_i64(vm));
+                            }
+                            break;
+                        case WasmOp_f64_convert_i64_u:
+                            {
+                                vm_push_f64(vm, vm_pop_u64(vm));
+                            }
+                            break;
+                        case WasmOp_f64_promote_f32:
+                            {
+                                vm_push_f64(vm, vm_pop_f32(vm));
+                            }
+                            break;
+
+                        case WasmOp_i32_extend8_s:
+                            {
+                                int8_t operand = vm_pop_i32(vm);
+                                vm_push_i32(vm, operand);
+                            }
+                            break;
+                        case WasmOp_i32_extend16_s:
+                            {
+                                int16_t operand = vm_pop_i32(vm);
+                                vm_push_i32(vm, operand);
+                            }
+                            break;
+                        case WasmOp_i64_extend8_s:
+                            {
+                                int8_t operand = vm_pop_i64(vm);
+                                vm_push_i64(vm, operand);
+                            }
+                            break;
+                        case WasmOp_i64_extend16_s:
+                            {
+                                int16_t operand = vm_pop_i64(vm);
+                                vm_push_i64(vm, operand);
+                            }
+                            break;
+                        case WasmOp_i64_extend32_s:
+                            {
+                                int32_t operand = vm_pop_i64(vm);
+                                vm_push_i64(vm, operand);
+                            }
+                            break;
+
+                        default:
+                            panic("unreachable");
+                    }
+                }
+                break;
+
+            case Op_wasm_prefixed:
+                {
+                    enum WasmPrefixedOp wasm_prefixed_op = opcodes[pc->opcode];
+                    pc->opcode += 1;
+                    switch (wasm_prefixed_op) {
+                        case WasmPrefixedOp_i32_trunc_sat_f32_s:
+                            panic("unreachable");
+                        case WasmPrefixedOp_i32_trunc_sat_f32_u:
+                            panic("unreachable");
+                        case WasmPrefixedOp_i32_trunc_sat_f64_s:
+                            panic("unreachable");
+                        case WasmPrefixedOp_i32_trunc_sat_f64_u:
+                            panic("unreachable");
+                        case WasmPrefixedOp_i64_trunc_sat_f32_s:
+                            panic("unreachable");
+                        case WasmPrefixedOp_i64_trunc_sat_f32_u:
+                            panic("unreachable");
+                        case WasmPrefixedOp_i64_trunc_sat_f64_s:
+                            panic("unreachable");
+                        case WasmPrefixedOp_i64_trunc_sat_f64_u:
+                            panic("unreachable");
+                        case WasmPrefixedOp_memory_init:
+                            panic("unreachable");
+                        case WasmPrefixedOp_data_drop:
+                            panic("unreachable");
+
+                        case WasmPrefixedOp_memory_copy:
+                            {
+                                uint32_t n = vm_pop_u32(vm);
+                                uint32_t src = vm_pop_u32(vm);
+                                uint32_t dest = vm_pop_u32(vm);
+                                assert(dest + n <= vm->memory_len);
+                                assert(src + n <= vm->memory_len);
+                                assert(src + n <= dest || dest + n <= src); // overlapping
+                                memcpy(vm->memory + dest, vm->memory + src, n);
+                            }
+                            break;
+
+                        case WasmPrefixedOp_memory_fill:
+                            {
+                                uint32_t n = vm_pop_u32(vm);
+                                uint8_t value = vm_pop_u32(vm);
+                                uint32_t dest = vm_pop_u32(vm);
+                                assert(dest + n <= vm->memory_len);
+                                memset(vm->memory + dest, value, n);
+                            }
+                            break;
+
+                        case WasmPrefixedOp_table_init: panic("unreachable");
+                        case WasmPrefixedOp_elem_drop: panic("unreachable");
+                        case WasmPrefixedOp_table_copy: panic("unreachable");
+                        case WasmPrefixedOp_table_grow: panic("unreachable");
+                        case WasmPrefixedOp_table_size: panic("unreachable");
+                        case WasmPrefixedOp_table_fill: panic("unreachable");
+                        default: panic("unreachable");
+                    }
+                }
+                break;
+
+        }
+    }
+}
+
+int main(int argc, char **argv) {
+    char *memory = mmap( NULL, max_memory, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+
+    const char *zig_lib_dir_path = argv[1];
+    const char *zig_cache_dir_path = argv[2];
+    const size_t vm_argv_start = 3;
+    const char *wasm_file = argv[vm_argv_start];
+
+    const struct ByteSlice mod = read_file_alloc(wasm_file);
+
+    int cwd = err_wrap("opening cwd", open(".", O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_PATH));
+    mkdir(zig_cache_dir_path, 0666);
+    int cache_dir = err_wrap("opening cache dir", open(zig_cache_dir_path, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_PATH));
+    int zig_lib_dir = err_wrap("opening zig lib dir", open(zig_lib_dir_path, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_PATH));
+
+    add_preopen(0, "stdin", STDIN_FILENO);
+    add_preopen(1, "stdout", STDOUT_FILENO);
+    add_preopen(2, "stderr", STDERR_FILENO);
+    add_preopen(3, ".", cwd);
+    add_preopen(4, "/cache", cache_dir);
+    add_preopen(5, "/lib", zig_lib_dir);
+
+    uint32_t i = 0;
+
+    if (mod.ptr[0] != 0 || mod.ptr[1] != 'a' || mod.ptr[2] != 's' || mod.ptr[3] != 'm') {
+        panic("bad magic");
+    }
+    i += 4;
+
+    uint32_t version = read_u32_le(mod.ptr + i);
+    i += 4;
+    if (version != 1) panic("bad wasm version");
+
+    uint32_t section_starts[13];
+    memset(&section_starts, 0, 4 * 13);
+
+    while (i < mod.len) {
+        uint8_t section_id = mod.ptr[i];
+        i += 1;
+        uint32_t section_len = read32_uleb128(mod.ptr, &i);
+        section_starts[section_id] = i;
+        i += section_len;
+    }
+
+    // Map type indexes to offsets into the module.
+    struct TypeInfo *types;
+    {
+        i = section_starts[Section_type];
+        uint32_t types_len = read32_uleb128(mod.ptr, &i);
+        types = arena_alloc(sizeof(struct TypeInfo) * types_len);
+        for (size_t type_i = 0; type_i < types_len; type_i += 1) {
+            struct TypeInfo *info = &types[type_i];
+            if (mod.ptr[i] != 0x60) panic("bad type byte");
+            i += 1;
+
+            info->param_count = read32_uleb128(mod.ptr, &i);
+            info->param_types = 0;
+            for (uint32_t param_i = 0; param_i < info->param_count; param_i += 1) {
+                int64_t param_type = read64_ileb128(mod.ptr, &i);
+                switch (param_type) {
+                    case -1: case -3: bs_unset(&info->param_types, param_i); break;
+                    case -2: case -4:   bs_set(&info->param_types, param_i); break;
+                    default: panic("unexpected param type");
+                }
+            }
+
+            info->result_count = read32_uleb128(mod.ptr, &i);
+            info->result_types = 0;
+            for (uint32_t result_i = 0; result_i < info->result_count; result_i += 1) {
+                int64_t result_type = read64_ileb128(mod.ptr, &i);
+                switch (result_type) {
+                    case -1: case -3: bs_unset(&info->result_types, result_i); break;
+                    case -2: case -4:   bs_set(&info->result_types, result_i); break;
+                    default: panic("unexpected result type");
+                }
+            }
+        }
+    }
+
+    // Count the imported functions so we can correct function references.
+    struct Import *imports;
+    uint32_t imports_len;
+    {
+        i = section_starts[Section_import];
+        imports_len = read32_uleb128(mod.ptr, &i);
+        imports = arena_alloc(sizeof(struct Import) * imports_len);
+        for (size_t imp_i = 0; imp_i < imports_len; imp_i += 1) {
+            struct Import *imp = &imports[imp_i];
+
+            struct ByteSlice mod_name = read_name(mod.ptr, &i);
+            if (mod_name.len == strlen("wasi_snapshot_preview1") &&
+                memcmp(mod_name.ptr, "wasi_snapshot_preview1", mod_name.len) == 0) {
+                imp->mod = ImpMod_wasi_snapshot_preview1;
+            } else panic("unknown import module");
+
+            struct ByteSlice sym_name = read_name(mod.ptr, &i);
+            if (sym_name.len == strlen("args_get") &&
+                memcmp(sym_name.ptr, "args_get", sym_name.len) == 0) {
+                imp->name = ImpName_args_get;
+            } else if (sym_name.len == strlen("args_sizes_get") &&
+                memcmp(sym_name.ptr, "args_sizes_get", sym_name.len) == 0) {
+                imp->name = ImpName_args_sizes_get;
+            } else if (sym_name.len == strlen("clock_time_get") &&
+                memcmp(sym_name.ptr, "clock_time_get", sym_name.len) == 0) {
+                imp->name = ImpName_clock_time_get;
+            } else if (sym_name.len == strlen("debug") &&
+                memcmp(sym_name.ptr, "debug", sym_name.len) == 0) {
+                imp->name = ImpName_debug;
+            } else if (sym_name.len == strlen("debug_slice") &&
+                memcmp(sym_name.ptr, "debug_slice", sym_name.len) == 0) {
+                imp->name = ImpName_debug_slice;
+            } else if (sym_name.len == strlen("environ_get") &&
+                memcmp(sym_name.ptr, "environ_get", sym_name.len) == 0) {
+                imp->name = ImpName_environ_get;
+            } else if (sym_name.len == strlen("environ_sizes_get") &&
+                memcmp(sym_name.ptr, "environ_sizes_get", sym_name.len) == 0) {
+                imp->name = ImpName_environ_sizes_get;
+            } else if (sym_name.len == strlen("fd_close") &&
+                memcmp(sym_name.ptr, "fd_close", sym_name.len) == 0) {
+                imp->name = ImpName_fd_close;
+            } else if (sym_name.len == strlen("fd_fdstat_get") &&
+                memcmp(sym_name.ptr, "fd_fdstat_get", sym_name.len) == 0) {
+                imp->name = ImpName_fd_fdstat_get;
+            } else if (sym_name.len == strlen("fd_filestat_get") &&
+                memcmp(sym_name.ptr, "fd_filestat_get", sym_name.len) == 0) {
+                imp->name = ImpName_fd_filestat_get;
+            } else if (sym_name.len == strlen("fd_filestat_set_size") &&
+                memcmp(sym_name.ptr, "fd_filestat_set_size", sym_name.len) == 0) {
+                imp->name = ImpName_fd_filestat_set_size;
+            } else if (sym_name.len == strlen("fd_filestat_set_times") &&
+                memcmp(sym_name.ptr, "fd_filestat_set_times", sym_name.len) == 0) {
+                imp->name = ImpName_fd_filestat_set_times;
+            } else if (sym_name.len == strlen("fd_pread") &&
+                memcmp(sym_name.ptr, "fd_pread", sym_name.len) == 0) {
+                imp->name = ImpName_fd_pread;
+            } else if (sym_name.len == strlen("fd_prestat_dir_name") &&
+                memcmp(sym_name.ptr, "fd_prestat_dir_name", sym_name.len) == 0) {
+                imp->name = ImpName_fd_prestat_dir_name;
+            } else if (sym_name.len == strlen("fd_prestat_get") &&
+                memcmp(sym_name.ptr, "fd_prestat_get", sym_name.len) == 0) {
+                imp->name = ImpName_fd_prestat_get;
+            } else if (sym_name.len == strlen("fd_pwrite") &&
+                memcmp(sym_name.ptr, "fd_pwrite", sym_name.len) == 0) {
+                imp->name = ImpName_fd_pwrite;
+            } else if (sym_name.len == strlen("fd_read") &&
+                memcmp(sym_name.ptr, "fd_read", sym_name.len) == 0) {
+                imp->name = ImpName_fd_read;
+            } else if (sym_name.len == strlen("fd_readdir") &&
+                memcmp(sym_name.ptr, "fd_readdir", sym_name.len) == 0) {
+                imp->name = ImpName_fd_readdir;
+            } else if (sym_name.len == strlen("fd_write") &&
+                memcmp(sym_name.ptr, "fd_write", sym_name.len) == 0) {
+                imp->name = ImpName_fd_write;
+            } else if (sym_name.len == strlen("path_create_directory") &&
+                memcmp(sym_name.ptr, "path_create_directory", sym_name.len) == 0) {
+                imp->name = ImpName_path_create_directory;
+            } else if (sym_name.len == strlen("path_filestat_get") &&
+                memcmp(sym_name.ptr, "path_filestat_get", sym_name.len) == 0) {
+                imp->name = ImpName_path_filestat_get;
+            } else if (sym_name.len == strlen("path_open") &&
+                memcmp(sym_name.ptr, "path_open", sym_name.len) == 0) {
+                imp->name = ImpName_path_open;
+            } else if (sym_name.len == strlen("path_remove_directory") &&
+                memcmp(sym_name.ptr, "path_remove_directory", sym_name.len) == 0) {
+                imp->name = ImpName_path_remove_directory;
+            } else if (sym_name.len == strlen("path_rename") &&
+                memcmp(sym_name.ptr, "path_rename", sym_name.len) == 0) {
+                imp->name = ImpName_path_rename;
+            } else if (sym_name.len == strlen("path_unlink_file") &&
+                memcmp(sym_name.ptr, "path_unlink_file", sym_name.len) == 0) {
+                imp->name = ImpName_path_unlink_file;
+            } else if (sym_name.len == strlen("proc_exit") &&
+                memcmp(sym_name.ptr, "proc_exit", sym_name.len) == 0) {
+                imp->name = ImpName_proc_exit;
+            } else if (sym_name.len == strlen("random_get") &&
+                memcmp(sym_name.ptr, "random_get", sym_name.len) == 0) {
+                imp->name = ImpName_random_get;
+            } else panic("unknown import name");
+
+            uint32_t desc = read32_uleb128(mod.ptr, &i);
+            if (desc != 0) panic("external kind not function");
+            imp->type_idx = read32_uleb128(mod.ptr, &i);
+        }
+    }
+
+    // Find _start in the exports
+    uint32_t start_fn_idx;
+    {
+        i = section_starts[Section_export];
+        uint32_t count = read32_uleb128(mod.ptr, &i);
+        for (; count > 0; count -= 1) {
+            struct ByteSlice name = read_name(mod.ptr, &i);
+            uint32_t desc = read32_uleb128(mod.ptr, &i);
+            start_fn_idx = read32_uleb128(mod.ptr, &i);
+            if (desc == 0 && name.len == strlen("_start") &&
+                memcmp(name.ptr, "_start", name.len) == 0)
+            {
+                break;
+            }
+        }
+        if (count == 0) panic("_start symbol not found");
+    }
+
+    // Map function indexes to offsets into the module and type index.
+    struct Function *functions;
+    uint32_t functions_len;
+    {
+        i = section_starts[Section_function];
+        functions_len = read32_uleb128(mod.ptr, &i);
+        functions = arena_alloc(sizeof(struct Function) * functions_len);
+        for (size_t func_i = 0; func_i < functions_len; func_i += 1) {
+            struct Function *func = &functions[func_i];
+            func->type_idx = read32_uleb128(mod.ptr, &i);
+        }
+    }
+
+    // Allocate and initialize globals.
+    uint64_t *globals;
+    {
+        i = section_starts[Section_global];
+        uint32_t globals_len = read32_uleb128(mod.ptr, &i);
+        globals = arena_alloc(sizeof(uint64_t) * globals_len);
+        for (size_t glob_i = 0; glob_i < globals_len; glob_i += 1) {
+            uint64_t *global = &globals[glob_i];
+            uint32_t content_type = read32_uleb128(mod.ptr, &i);
+            uint32_t mutability = read32_uleb128(mod.ptr, &i);
+            if (mutability != 1) panic("expected mutable global");
+            if (content_type != 0x7f) panic("unexpected content type");
+            uint8_t opcode = mod.ptr[i];
+            i += 1;
+            if (opcode != WasmOp_i32_const) panic("expected i32_const op");
+            uint32_t init = read32_ileb128(mod.ptr, &i);
+            *global = (uint32_t)init;
+        }
+    }
+
+    // Allocate and initialize memory.
+    uint32_t memory_len;
+    {
+        i = section_starts[Section_memory];
+        uint32_t memories_len = read32_uleb128(mod.ptr, &i);
+        if (memories_len != 1) panic("unexpected memory count");
+        uint32_t flags = read32_uleb128(mod.ptr, &i);
+        (void)flags;
+        memory_len = read32_uleb128(mod.ptr, &i) * wasm_page_size;
+
+        i = section_starts[Section_data];
+        uint32_t datas_count = read32_uleb128(mod.ptr, &i);
+        for (; datas_count > 0; datas_count -= 1) {
+            uint32_t mode = read32_uleb128(mod.ptr, &i);
+            if (mode != 0) panic("expected mode 0");
+            enum WasmOp opcode = mod.ptr[i];
+            i += 1;
+            if (opcode != WasmOp_i32_const) panic("expected opcode i32_const");
+            uint32_t offset = read32_uleb128(mod.ptr, &i);
+            enum WasmOp end = mod.ptr[i];
+            if (end != WasmOp_end) panic("expected end opcode");
+            i += 1;
+            uint32_t bytes_len = read32_uleb128(mod.ptr, &i);
+            memcpy(memory + offset, mod.ptr + i, bytes_len);
+            i += bytes_len;
+        }
+    }
+
+    uint32_t *table = NULL;
+    {
+        i = section_starts[Section_table];
+        uint32_t table_count = read32_uleb128(mod.ptr, &i);
+        if (table_count > 1) {
+            panic("expected only one table section");
+        } else if (table_count == 1) {
+            uint32_t element_type = read32_uleb128(mod.ptr, &i);
+            (void)element_type;
+            uint32_t has_max = read32_uleb128(mod.ptr, &i);
+            if (has_max != 1) panic("expected has_max==1");
+            uint32_t initial = read32_uleb128(mod.ptr, &i);
+            (void)initial;
+            uint32_t maximum = read32_uleb128(mod.ptr, &i);
+
+            i = section_starts[Section_element];
+            uint32_t element_section_count = read32_uleb128(mod.ptr, &i);
+            if (element_section_count != 1) panic("expected one element section");
+            uint32_t flags = read32_uleb128(mod.ptr, &i);
+            (void)flags;
+            enum WasmOp opcode = mod.ptr[i];
+            i += 1;
+            if (opcode != WasmOp_i32_const) panic("expected op i32_const");
+            uint32_t offset = read32_uleb128(mod.ptr, &i);
+            enum WasmOp end = mod.ptr[i];
+            if (end != WasmOp_end) panic("expected op end");
+            i += 1;
+            uint32_t elem_count = read32_uleb128(mod.ptr, &i);
+
+            table = arena_alloc(sizeof(uint32_t) * maximum);
+            memset(table, 0, maximum);
+
+            for (uint32_t elem_i = 0; elem_i < elem_count; elem_i += 1) {
+                table[elem_i + offset] = read32_uleb128(mod.ptr, &i);
+            }
+        }
+    }
+
+    struct VirtualMachine vm;
+    vm.stack = arena_alloc(sizeof(uint64_t) * 10000000),
+    vm.mod_ptr = mod.ptr;
+    vm.opcodes = arena_alloc(2000000);
+    vm.operands = arena_alloc(sizeof(uint32_t) * 2000000);
+    vm.stack_top = 0;
+    vm.functions = functions;
+    vm.types = types;
+    vm.globals = globals;
+    vm.memory = memory;
+    vm.memory_len = memory_len;
+    vm.imports = imports;
+    vm.imports_len = imports_len;
+    vm.args = argv + vm_argv_start;
+    vm.table = table;
+
+    {
+        uint32_t code_i = section_starts[Section_code];
+        uint32_t codes_len = read32_uleb128(mod.ptr, &code_i);
+        if (codes_len != functions_len) panic("code/function length mismatch");
+        struct ProgramCounter pc;
+        pc.opcode = 0;
+        pc.operand = 0;
+        for (uint32_t func_i = 0; func_i < functions_len; func_i += 1) {
+            struct Function *func = &functions[func_i];
+            uint32_t size = read32_uleb128(mod.ptr, &code_i);
+            uint32_t code_begin = code_i;
+
+            struct TypeInfo *type_info = &vm.types[func->type_idx];
+            func->locals_count = 0;
+            func->local_types = arena_alloc(sizeof(uint32_t) * ((type_info->param_count + func->locals_count + 31) / 32));
+            func->local_types[0] = type_info->param_types;
+
+            for (uint32_t local_sets_count = read32_uleb128(mod.ptr, &code_i);
+                 local_sets_count > 0; local_sets_count -= 1) {
+                uint32_t set_count = read32_uleb128(mod.ptr, &code_i);
+                int64_t local_type = read64_ileb128(mod.ptr, &code_i);
+
+                uint32_t i = type_info->param_count + func->locals_count;
+                func->locals_count += set_count;
+                if ((type_info->param_count + func->locals_count + 31) / 32 > (i + 31) / 32)
+                    func->local_types = arena_realloc(func->local_types, sizeof(uint32_t) * ((type_info->param_count + func->locals_count + 31) / 32));
+                for (; i < type_info->param_count + func->locals_count; i += 1)
+                    switch (local_type) {
+                        case -1: case -3: bs_unset(func->local_types, i); break;
+                        case -2: case -4:   bs_set(func->local_types, i); break;
+                        default: panic("unexpected local type");
+                    }
+            }
+
+            func->entry_pc = pc;
+            vm_decodeCode(&vm, func, &code_i, &pc);
+            if (code_i != code_begin + size) panic("bad code size");
+        }
+
+        uint64_t opcode_counts[0x100];
+        memset(opcode_counts, 0, 0x100);
+        uint64_t prefixed_opcode_counts[0x100];
+        memset(prefixed_opcode_counts, 0, 0x100);
+        bool is_prefixed = false;
+        for (uint32_t opcode_i = 0; opcode_i < pc.opcode; opcode_i += 1) {
+            uint8_t opcode = vm.opcodes[opcode_i];
+            if (!is_prefixed) {
+                opcode_counts[opcode] += 1;
+                is_prefixed = opcode == WasmOp_prefixed;
+            } else {
+                prefixed_opcode_counts[opcode] += 1;
+                is_prefixed = false;
+            }
+        }
+    }
+
+    vm_call(&vm, start_fn_idx);
+    vm_run(&vm);
+
+    return 0;
+}