/*
 * Copyright 2016 WebAssembly Community Group participants
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "interpreter.h"

#include <assert.h>
#include <inttypes.h>
#include <math.h>

#include <algorithm>
#include <vector>

#include "stream.h"

namespace wabt {

static const char* s_interpreter_opcode_name[256] = {

#define WABT_OPCODE(rtype, type1, type2, mem_size, code, NAME, text) text,
#include "interpreter-opcode.def"
#undef WABT_OPCODE

};

#define CHECK_RESULT(expr)  \
  do {                      \
    if (WABT_FAILED(expr))  \
      return Result::Error; \
  } while (0)

static const char* get_interpreter_opcode_name(InterpreterOpcode opcode) {
  return s_interpreter_opcode_name[static_cast<int>(opcode)];
}

InterpreterEnvironment::InterpreterEnvironment()
    : istream(new OutputBuffer()) {}

InterpreterThread::InterpreterThread()
    : env(nullptr),
      value_stack_top(nullptr),
      value_stack_end(nullptr),
      call_stack_top(nullptr),
      call_stack_end(nullptr),
      pc(0) {}

InterpreterImport::InterpreterImport() 
  : kind(ExternalKind::Func) {
  WABT_ZERO_MEMORY(module_name);
  WABT_ZERO_MEMORY(field_name);
  WABT_ZERO_MEMORY(func.sig_index);
}

InterpreterImport::InterpreterImport(InterpreterImport&& other) {
  *this = std::move(other);
}

InterpreterImport& InterpreterImport::operator=(InterpreterImport&& other) {
  kind = other.kind;
  module_name = other.module_name;
  WABT_ZERO_MEMORY(other.module_name);
  field_name = other.field_name;
  WABT_ZERO_MEMORY(other.field_name);
  switch (kind) {
    case ExternalKind::Func:
      func.sig_index = other.func.sig_index;
      break;
    case ExternalKind::Table:
      table.limits = other.table.limits;
      break;
    case ExternalKind::Memory:
      memory.limits = other.memory.limits;
      break;
    case ExternalKind::Global:
      global.type = other.global.type;
      global.mutable_ = other.global.mutable_;
      break;
  }
  return *this;
}


InterpreterImport::~InterpreterImport() {
  destroy_string_slice(&module_name);
  destroy_string_slice(&field_name);
}

InterpreterExport::InterpreterExport(InterpreterExport&& other)
  : name(other.name),
    kind(other.kind),
    index(other.index) {
  WABT_ZERO_MEMORY(other.name);
}

InterpreterExport& InterpreterExport::operator=(InterpreterExport&& other) {
  name = other.name;
  kind = other.kind;
  index = other.index;
  WABT_ZERO_MEMORY(other.name);
  return *this;
}

InterpreterExport::~InterpreterExport() {
  destroy_string_slice(&name);
}

InterpreterModule::InterpreterModule(bool is_host)
    : memory_index(WABT_INVALID_INDEX),
      table_index(WABT_INVALID_INDEX),
      is_host(is_host) {
  WABT_ZERO_MEMORY(name);
}

InterpreterModule::InterpreterModule(const StringSlice& name, bool is_host)
    : name(name),
      memory_index(WABT_INVALID_INDEX),
      table_index(WABT_INVALID_INDEX),
      is_host(is_host) {}

InterpreterModule::~InterpreterModule() {
  destroy_string_slice(&name);
}

DefinedInterpreterModule::DefinedInterpreterModule(size_t istream_start)
    : InterpreterModule(false),
      start_func_index(WABT_INVALID_INDEX),
      istream_start(istream_start),
      istream_end(istream_start) {}

HostInterpreterModule::HostInterpreterModule(const StringSlice& name)
    : InterpreterModule(name, true) {}

InterpreterEnvironmentMark mark_interpreter_environment(
    InterpreterEnvironment* env) {
  InterpreterEnvironmentMark mark;
  WABT_ZERO_MEMORY(mark);
  mark.modules_size = env->modules.size();
  mark.sigs_size = env->sigs.size();
  mark.funcs_size = env->funcs.size();
  mark.memories_size = env->memories.size();
  mark.tables_size = env->tables.size();
  mark.globals_size = env->globals.size();
  mark.istream_size = env->istream->data.size();
  return mark;
}

void reset_interpreter_environment_to_mark(InterpreterEnvironment* env,
                                           InterpreterEnvironmentMark mark) {
  /* Destroy entries in the binding hash. */
  for (size_t i = mark.modules_size; i < env->modules.size(); ++i) {
    const StringSlice* name = &env->modules[i]->name;
    if (!string_slice_is_empty(name))
      env->module_bindings.erase(string_slice_to_string(*name));
  }

  /* registered_module_bindings maps from an arbitrary name to a module index,
   * so we have to iterate through the entire table to find entries to remove.
   */
  auto iter = env->registered_module_bindings.begin();
  while (iter != env->registered_module_bindings.end()) {
    if (iter->second.index >= static_cast<int>(mark.modules_size))
      iter = env->registered_module_bindings.erase(iter);
    else
      ++iter;
  }

  env->modules.erase(env->modules.begin() + mark.modules_size,
                     env->modules.end());
  env->sigs.erase(env->sigs.begin() + mark.sigs_size, env->sigs.end());
  env->funcs.erase(env->funcs.begin() + mark.funcs_size, env->funcs.end());
  env->memories.erase(env->memories.begin() + mark.memories_size,
                      env->memories.end());
  env->tables.erase(env->tables.begin() + mark.tables_size, env->tables.end());
  env->globals.erase(env->globals.begin() + mark.globals_size,
                     env->globals.end());
  env->istream->data.resize(mark.istream_size);
}

HostInterpreterModule* append_host_module(InterpreterEnvironment* env,
                                          StringSlice name) {
  HostInterpreterModule* module =
      new HostInterpreterModule(dup_string_slice(name));
  env->modules.emplace_back(module);
  env->registered_module_bindings.emplace(string_slice_to_string(name),
                                          Binding(env->modules.size() - 1));
  return module;
}

void init_interpreter_thread(InterpreterEnvironment* env,
                             InterpreterThread* thread,
                             InterpreterThreadOptions* options) {
  thread->value_stack.resize(options->value_stack_size);
  thread->call_stack.resize(options->call_stack_size);
  thread->env = env;
  thread->value_stack_top = thread->value_stack.data();
  thread->value_stack_end =
      thread->value_stack.data() + thread->value_stack.size();
  thread->call_stack_top = thread->call_stack.data();
  thread->call_stack_end =
      thread->call_stack.data() + thread->call_stack.size();
  thread->pc = options->pc;
}

InterpreterResult push_thread_value(InterpreterThread* thread,
                                    InterpreterValue value) {
  if (thread->value_stack_top >= thread->value_stack_end)
    return InterpreterResult::TrapValueStackExhausted;
  *thread->value_stack_top++ = value;
  return InterpreterResult::Ok;
}

InterpreterExport* get_interpreter_export_by_name(InterpreterModule* module,
                                                  const StringSlice* name) {
  int field_index = module->export_bindings.find_index(*name);
  if (field_index < 0)
    return nullptr;
  return &module->exports[field_index];
}

/* 3 32222222 222...00
 * 1 09876543 210...10
 * -------------------
 * 0 00000000 000...00 => 0x00000000 => 0
 * 0 10011101 111...11 => 0x4effffff => 2147483520                  (~INT32_MAX)
 * 0 10011110 000...00 => 0x4f000000 => 2147483648
 * 0 10011110 111...11 => 0x4f7fffff => 4294967040                 (~UINT32_MAX)
 * 0 10111110 111...11 => 0x5effffff => 9223371487098961920         (~INT64_MAX)
 * 0 10111110 000...00 => 0x5f000000 => 9223372036854775808
 * 0 10111111 111...11 => 0x5f7fffff => 18446742974197923840       (~UINT64_MAX)
 * 0 10111111 000...00 => 0x5f800000 => 18446744073709551616
 * 0 11111111 000...00 => 0x7f800000 => inf
 * 0 11111111 000...01 => 0x7f800001 => nan(0x1)
 * 0 11111111 111...11 => 0x7fffffff => nan(0x7fffff)
 * 1 00000000 000...00 => 0x80000000 => -0
 * 1 01111110 111...11 => 0xbf7fffff => -1 + ulp      (~UINT32_MIN, ~UINT64_MIN)
 * 1 01111111 000...00 => 0xbf800000 => -1
 * 1 10011110 000...00 => 0xcf000000 => -2147483648                  (INT32_MIN)
 * 1 10111110 000...00 => 0xdf000000 => -9223372036854775808         (INT64_MIN)
 * 1 11111111 000...00 => 0xff800000 => -inf
 * 1 11111111 000...01 => 0xff800001 => -nan(0x1)
 * 1 11111111 111...11 => 0xffffffff => -nan(0x7fffff)
 */

#define F32_MAX 0x7f7fffffU
#define F32_INF 0x7f800000U
#define F32_NEG_MAX 0xff7fffffU
#define F32_NEG_INF 0xff800000U
#define F32_NEG_ONE 0xbf800000U
#define F32_NEG_ZERO 0x80000000U
#define F32_QUIET_NAN 0x7fc00000U
#define F32_QUIET_NEG_NAN 0xffc00000U
#define F32_QUIET_NAN_BIT 0x00400000U
#define F32_SIG_BITS 23
#define F32_SIG_MASK 0x7fffff
#define F32_SIGN_MASK 0x80000000U

static bool is_nan_f32(uint32_t f32_bits) {
  return (f32_bits > F32_INF && f32_bits < F32_NEG_ZERO) ||
         (f32_bits > F32_NEG_INF);
}

bool is_canonical_nan_f32(uint32_t f32_bits) {
  return f32_bits == F32_QUIET_NAN || f32_bits == F32_QUIET_NEG_NAN;
}

bool is_arithmetic_nan_f32(uint32_t f32_bits) {
  return (f32_bits & F32_QUIET_NAN) == F32_QUIET_NAN;
}

static WABT_INLINE bool is_zero_f32(uint32_t f32_bits) {
  return f32_bits == 0 || f32_bits == F32_NEG_ZERO;
}

static WABT_INLINE bool is_in_range_i32_trunc_s_f32(uint32_t f32_bits) {
  return (f32_bits < 0x4f000000U) ||
         (f32_bits >= F32_NEG_ZERO && f32_bits <= 0xcf000000U);
}

static WABT_INLINE bool is_in_range_i64_trunc_s_f32(uint32_t f32_bits) {
  return (f32_bits < 0x5f000000U) ||
         (f32_bits >= F32_NEG_ZERO && f32_bits <= 0xdf000000U);
}

static WABT_INLINE bool is_in_range_i32_trunc_u_f32(uint32_t f32_bits) {
  return (f32_bits < 0x4f800000U) ||
         (f32_bits >= F32_NEG_ZERO && f32_bits < F32_NEG_ONE);
}

static WABT_INLINE bool is_in_range_i64_trunc_u_f32(uint32_t f32_bits) {
  return (f32_bits < 0x5f800000U) ||
         (f32_bits >= F32_NEG_ZERO && f32_bits < F32_NEG_ONE);
}

/*
 * 6 66655555555 5544..2..222221...000
 * 3 21098765432 1098..9..432109...210
 * -----------------------------------
 * 0 00000000000 0000..0..000000...000 0x0000000000000000 => 0
 * 0 10000011101 1111..1..111000...000 0x41dfffffffc00000 => 2147483647           (INT32_MAX)
 * 0 10000011110 1111..1..111100...000 0x41efffffffe00000 => 4294967295           (UINT32_MAX)
 * 0 10000111101 1111..1..111111...111 0x43dfffffffffffff => 9223372036854774784  (~INT64_MAX)
 * 0 10000111110 0000..0..000000...000 0x43e0000000000000 => 9223372036854775808
 * 0 10000111110 1111..1..111111...111 0x43efffffffffffff => 18446744073709549568 (~UINT64_MAX)
 * 0 10000111111 0000..0..000000...000 0x43f0000000000000 => 18446744073709551616
 * 0 10001111110 1111..1..000000...000 0x47efffffe0000000 => 3.402823e+38         (FLT_MAX)
 * 0 11111111111 0000..0..000000...000 0x7ff0000000000000 => inf
 * 0 11111111111 0000..0..000000...001 0x7ff0000000000001 => nan(0x1)
 * 0 11111111111 1111..1..111111...111 0x7fffffffffffffff => nan(0xfff...)
 * 1 00000000000 0000..0..000000...000 0x8000000000000000 => -0
 * 1 01111111110 1111..1..111111...111 0xbfefffffffffffff => -1 + ulp             (~UINT32_MIN, ~UINT64_MIN)
 * 1 01111111111 0000..0..000000...000 0xbff0000000000000 => -1
 * 1 10000011110 0000..0..000000...000 0xc1e0000000000000 => -2147483648          (INT32_MIN)
 * 1 10000111110 0000..0..000000...000 0xc3e0000000000000 => -9223372036854775808 (INT64_MIN)
 * 1 10001111110 1111..1..000000...000 0xc7efffffe0000000 => -3.402823e+38        (-FLT_MAX)
 * 1 11111111111 0000..0..000000...000 0xfff0000000000000 => -inf
 * 1 11111111111 0000..0..000000...001 0xfff0000000000001 => -nan(0x1)
 * 1 11111111111 1111..1..111111...111 0xffffffffffffffff => -nan(0xfff...)
 */

#define F64_INF 0x7ff0000000000000ULL
#define F64_NEG_INF 0xfff0000000000000ULL
#define F64_NEG_ONE 0xbff0000000000000ULL
#define F64_NEG_ZERO 0x8000000000000000ULL
#define F64_QUIET_NAN 0x7ff8000000000000ULL
#define F64_QUIET_NEG_NAN 0xfff8000000000000ULL
#define F64_QUIET_NAN_BIT 0x0008000000000000ULL
#define F64_SIG_BITS 52
#define F64_SIG_MASK 0xfffffffffffffULL
#define F64_SIGN_MASK 0x8000000000000000ULL

static bool is_nan_f64(uint64_t f64_bits) {
  return (f64_bits > F64_INF && f64_bits < F64_NEG_ZERO) ||
         (f64_bits > F64_NEG_INF);
}

bool is_canonical_nan_f64(uint64_t f64_bits) {
  return f64_bits == F64_QUIET_NAN || f64_bits == F64_QUIET_NEG_NAN;
}

bool is_arithmetic_nan_f64(uint64_t f64_bits) {
  return (f64_bits & F64_QUIET_NAN) == F64_QUIET_NAN;
}

static WABT_INLINE bool is_zero_f64(uint64_t f64_bits) {
  return f64_bits == 0 || f64_bits == F64_NEG_ZERO;
}

static WABT_INLINE bool is_in_range_i32_trunc_s_f64(uint64_t f64_bits) {
  return (f64_bits <= 0x41dfffffffc00000ULL) ||
         (f64_bits >= F64_NEG_ZERO && f64_bits <= 0xc1e0000000000000ULL);
}

static WABT_INLINE bool is_in_range_i32_trunc_u_f64(uint64_t f64_bits) {
  return (f64_bits <= 0x41efffffffe00000ULL) ||
         (f64_bits >= F64_NEG_ZERO && f64_bits < F64_NEG_ONE);
}

static WABT_INLINE bool is_in_range_i64_trunc_s_f64(uint64_t f64_bits) {
  return (f64_bits < 0x43e0000000000000ULL) ||
         (f64_bits >= F64_NEG_ZERO && f64_bits <= 0xc3e0000000000000ULL);
}

static WABT_INLINE bool is_in_range_i64_trunc_u_f64(uint64_t f64_bits) {
  return (f64_bits < 0x43f0000000000000ULL) ||
         (f64_bits >= F64_NEG_ZERO && f64_bits < F64_NEG_ONE);
}

static WABT_INLINE bool is_in_range_f64_demote_f32(uint64_t f64_bits) {
  return (f64_bits <= 0x47efffffe0000000ULL) ||
         (f64_bits >= F64_NEG_ZERO && f64_bits <= 0xc7efffffe0000000ULL);
}

/* The WebAssembly rounding mode means that these values (which are > F32_MAX)
 * should be rounded to F32_MAX and not set to infinity. Unfortunately, UBSAN
 * complains that the value is not representable as a float, so we'll special
 * case them. */
static WABT_INLINE bool is_in_range_f64_demote_f32_round_to_f32_max(
    uint64_t f64_bits) {
  return f64_bits > 0x47efffffe0000000ULL && f64_bits < 0x47effffff0000000ULL;
}

static WABT_INLINE bool is_in_range_f64_demote_f32_round_to_neg_f32_max(
    uint64_t f64_bits) {
  return f64_bits > 0xc7efffffe0000000ULL && f64_bits < 0xc7effffff0000000ULL;
}

#define IS_NAN_F32 is_nan_f32
#define IS_NAN_F64 is_nan_f64
#define IS_ZERO_F32 is_zero_f32
#define IS_ZERO_F64 is_zero_f64

#define DEFINE_BITCAST(name, src, dst) \
  static WABT_INLINE dst name(src x) { \
    dst result;                        \
    memcpy(&result, &x, sizeof(dst));  \
    return result;                     \
  }

DEFINE_BITCAST(bitcast_u32_to_i32, uint32_t, int32_t)
DEFINE_BITCAST(bitcast_u64_to_i64, uint64_t, int64_t)
DEFINE_BITCAST(bitcast_f32_to_u32, float, uint32_t)
DEFINE_BITCAST(bitcast_u32_to_f32, uint32_t, float)
DEFINE_BITCAST(bitcast_f64_to_u64, double, uint64_t)
DEFINE_BITCAST(bitcast_u64_to_f64, uint64_t, double)

#define bitcast_i32_to_u32(x) (static_cast<uint32_t>(x))
#define bitcast_i64_to_u64(x) (static_cast<uint64_t>(x))

#define VALUE_TYPE_I32 uint32_t
#define VALUE_TYPE_I64 uint64_t
#define VALUE_TYPE_F32 uint32_t
#define VALUE_TYPE_F64 uint64_t

#define VALUE_TYPE_SIGNED_MAX_I32 (0x80000000U)
#define VALUE_TYPE_UNSIGNED_MAX_I32 (0xFFFFFFFFU)
#define VALUE_TYPE_SIGNED_MAX_I64 static_cast<uint64_t>(0x8000000000000000ULL)
#define VALUE_TYPE_UNSIGNED_MAX_I64 static_cast<uint64_t>(0xFFFFFFFFFFFFFFFFULL)

#define FLOAT_TYPE_F32 float
#define FLOAT_TYPE_F64 double

#define MEM_TYPE_I8 int8_t
#define MEM_TYPE_U8 uint8_t
#define MEM_TYPE_I16 int16_t
#define MEM_TYPE_U16 uint16_t
#define MEM_TYPE_I32 int32_t
#define MEM_TYPE_U32 uint32_t
#define MEM_TYPE_I64 int64_t
#define MEM_TYPE_U64 uint64_t
#define MEM_TYPE_F32 uint32_t
#define MEM_TYPE_F64 uint64_t

#define MEM_TYPE_EXTEND_I32_I8 int32_t
#define MEM_TYPE_EXTEND_I32_U8 uint32_t
#define MEM_TYPE_EXTEND_I32_I16 int32_t
#define MEM_TYPE_EXTEND_I32_U16 uint32_t
#define MEM_TYPE_EXTEND_I32_I32 int32_t
#define MEM_TYPE_EXTEND_I32_U32 uint32_t

#define MEM_TYPE_EXTEND_I64_I8 int64_t
#define MEM_TYPE_EXTEND_I64_U8 uint64_t
#define MEM_TYPE_EXTEND_I64_I16 int64_t
#define MEM_TYPE_EXTEND_I64_U16 uint64_t
#define MEM_TYPE_EXTEND_I64_I32 int64_t
#define MEM_TYPE_EXTEND_I64_U32 uint64_t
#define MEM_TYPE_EXTEND_I64_I64 int64_t
#define MEM_TYPE_EXTEND_I64_U64 uint64_t

#define MEM_TYPE_EXTEND_F32_F32 uint32_t
#define MEM_TYPE_EXTEND_F64_F64 uint64_t

#define BITCAST_I32_TO_SIGNED bitcast_u32_to_i32
#define BITCAST_I64_TO_SIGNED bitcast_u64_to_i64
#define BITCAST_I32_TO_UNSIGNED bitcast_i32_to_u32
#define BITCAST_I64_TO_UNSIGNED bitcast_i64_to_u64

#define BITCAST_TO_F32 bitcast_u32_to_f32
#define BITCAST_TO_F64 bitcast_u64_to_f64
#define BITCAST_FROM_F32 bitcast_f32_to_u32
#define BITCAST_FROM_F64 bitcast_f64_to_u64

#define TYPE_FIELD_NAME_I32 i32
#define TYPE_FIELD_NAME_I64 i64
#define TYPE_FIELD_NAME_F32 f32_bits
#define TYPE_FIELD_NAME_F64 f64_bits

#define TRAP(type) return InterpreterResult::Trap##type
#define TRAP_UNLESS(cond, type) TRAP_IF(!(cond), type)
#define TRAP_IF(cond, type)  \
  do {                       \
    if (WABT_UNLIKELY(cond)) \
      TRAP(type);            \
  } while (0)

#define CHECK_STACK()                                         \
  TRAP_IF(thread->value_stack_top >= thread->value_stack_end, \
          ValueStackExhausted)

#define PUSH_NEG_1_AND_BREAK_IF(cond) \
  if (WABT_UNLIKELY(cond)) {          \
    PUSH_I32(-1);                     \
    break;                            \
  }

#define PUSH(v)                         \
  do {                                  \
    CHECK_STACK();                      \
    (*thread->value_stack_top++) = (v); \
  } while (0)

#define PUSH_TYPE(type, v)                                \
  do {                                                    \
    CHECK_STACK();                                        \
    (*thread->value_stack_top++).TYPE_FIELD_NAME_##type = \
        static_cast<VALUE_TYPE_##type>(v);                \
  } while (0)

#define PUSH_I32(v) PUSH_TYPE(I32, (v))
#define PUSH_I64(v) PUSH_TYPE(I64, (v))
#define PUSH_F32(v) PUSH_TYPE(F32, (v))
#define PUSH_F64(v) PUSH_TYPE(F64, (v))

#define PICK(depth) (*(thread->value_stack_top - (depth)))
#define TOP() (PICK(1))
#define POP() (*--thread->value_stack_top)
#define POP_I32() (POP().i32)
#define POP_I64() (POP().i64)
#define POP_F32() (POP().f32_bits)
#define POP_F64() (POP().f64_bits)
#define DROP_KEEP(drop, keep)          \
  do {                                 \
    assert((keep) <= 1);               \
    if ((keep) == 1)                   \
      PICK((drop) + 1) = TOP();        \
    thread->value_stack_top -= (drop); \
  } while (0)

#define GOTO(offset) pc = &istream[offset]

#define PUSH_CALL()                                           \
  do {                                                        \
    TRAP_IF(thread->call_stack_top >= thread->call_stack_end, \
            CallStackExhausted);                              \
    (*thread->call_stack_top++) = (pc - istream);             \
  } while (0)

#define POP_CALL() (*--thread->call_stack_top)

#define GET_MEMORY(var)                  \
  uint32_t memory_index = read_u32(&pc); \
  InterpreterMemory* var = &env->memories[memory_index]

#define LOAD(type, mem_type)                                              \
  do {                                                                    \
    GET_MEMORY(memory);                                                   \
    uint64_t offset = static_cast<uint64_t>(POP_I32()) + read_u32(&pc);   \
    MEM_TYPE_##mem_type value;                                            \
    TRAP_IF(offset + sizeof(value) > memory->data.size(),                 \
            MemoryAccessOutOfBounds);                                     \
    void* src = memory->data.data() + static_cast<uint32_t>(offset);      \
    memcpy(&value, src, sizeof(MEM_TYPE_##mem_type));                     \
    PUSH_##type(static_cast<MEM_TYPE_EXTEND_##type##_##mem_type>(value)); \
  } while (0)

#define STORE(type, mem_type)                                           \
  do {                                                                  \
    GET_MEMORY(memory);                                                 \
    VALUE_TYPE_##type value = POP_##type();                             \
    uint64_t offset = static_cast<uint64_t>(POP_I32()) + read_u32(&pc); \
    MEM_TYPE_##mem_type src = static_cast<MEM_TYPE_##mem_type>(value);  \
    TRAP_IF(offset + sizeof(src) > memory->data.size(),                 \
            MemoryAccessOutOfBounds);                                   \
    void* dst = memory->data.data() + static_cast<uint32_t>(offset);    \
    memcpy(dst, &src, sizeof(MEM_TYPE_##mem_type));                     \
  } while (0)

#define BINOP(rtype, type, op)            \
  do {                                    \
    VALUE_TYPE_##type rhs = POP_##type(); \
    VALUE_TYPE_##type lhs = POP_##type(); \
    PUSH_##rtype(lhs op rhs);             \
  } while (0)

#define BINOP_SIGNED(rtype, type, op)                     \
  do {                                                    \
    VALUE_TYPE_##type rhs = POP_##type();                 \
    VALUE_TYPE_##type lhs = POP_##type();                 \
    PUSH_##rtype(BITCAST_##type##_TO_SIGNED(lhs)          \
                     op BITCAST_##type##_TO_SIGNED(rhs)); \
  } while (0)

#define SHIFT_MASK_I32 31
#define SHIFT_MASK_I64 63

#define BINOP_SHIFT(type, op, sign)                                          \
  do {                                                                       \
    VALUE_TYPE_##type rhs = POP_##type();                                    \
    VALUE_TYPE_##type lhs = POP_##type();                                    \
    PUSH_##type(BITCAST_##type##_TO_##sign(lhs) op(rhs& SHIFT_MASK_##type)); \
  } while (0)

#define ROT_LEFT_0_SHIFT_OP <<
#define ROT_LEFT_1_SHIFT_OP >>
#define ROT_RIGHT_0_SHIFT_OP >>
#define ROT_RIGHT_1_SHIFT_OP <<

#define BINOP_ROT(type, dir)                                               \
  do {                                                                     \
    VALUE_TYPE_##type rhs = POP_##type();                                  \
    VALUE_TYPE_##type lhs = POP_##type();                                  \
    uint32_t amount = rhs & SHIFT_MASK_##type;                             \
    if (WABT_LIKELY(amount != 0)) {                                        \
      PUSH_##type(                                                         \
          (lhs ROT_##dir##_0_SHIFT_OP amount) |                            \
          (lhs ROT_##dir##_1_SHIFT_OP((SHIFT_MASK_##type + 1) - amount))); \
    } else {                                                               \
      PUSH_##type(lhs);                                                    \
    }                                                                      \
  } while (0)

#define BINOP_DIV_REM_U(type, op)                          \
  do {                                                     \
    VALUE_TYPE_##type rhs = POP_##type();                  \
    VALUE_TYPE_##type lhs = POP_##type();                  \
    TRAP_IF(rhs == 0, IntegerDivideByZero);                \
    PUSH_##type(BITCAST_##type##_TO_UNSIGNED(lhs)          \
                    op BITCAST_##type##_TO_UNSIGNED(rhs)); \
  } while (0)

/* {i32,i64}.{div,rem}_s are special-cased because they trap when dividing the
 * max signed value by -1. The modulo operation on x86 uses the same
 * instruction to generate the quotient and the remainder. */
#define BINOP_DIV_S(type)                              \
  do {                                                 \
    VALUE_TYPE_##type rhs = POP_##type();              \
    VALUE_TYPE_##type lhs = POP_##type();              \
    TRAP_IF(rhs == 0, IntegerDivideByZero);            \
    TRAP_IF(lhs == VALUE_TYPE_SIGNED_MAX_##type &&     \
                rhs == VALUE_TYPE_UNSIGNED_MAX_##type, \
            IntegerOverflow);                          \
    PUSH_##type(BITCAST_##type##_TO_SIGNED(lhs) /      \
                BITCAST_##type##_TO_SIGNED(rhs));      \
  } while (0)

#define BINOP_REM_S(type)                                       \
  do {                                                          \
    VALUE_TYPE_##type rhs = POP_##type();                       \
    VALUE_TYPE_##type lhs = POP_##type();                       \
    TRAP_IF(rhs == 0, IntegerDivideByZero);                     \
    if (WABT_UNLIKELY(lhs == VALUE_TYPE_SIGNED_MAX_##type &&    \
                      rhs == VALUE_TYPE_UNSIGNED_MAX_##type)) { \
      PUSH_##type(0);                                           \
    } else {                                                    \
      PUSH_##type(BITCAST_##type##_TO_SIGNED(lhs) %             \
                  BITCAST_##type##_TO_SIGNED(rhs));             \
    }                                                           \
  } while (0)

#define UNOP_FLOAT(type, func)                                   \
  do {                                                           \
    FLOAT_TYPE_##type value = BITCAST_TO_##type(POP_##type());   \
    VALUE_TYPE_##type result = BITCAST_FROM_##type(func(value)); \
    if (WABT_UNLIKELY(IS_NAN_##type(result))) {                  \
      result |= type##_QUIET_NAN_BIT;                            \
    }                                                            \
    PUSH_##type(result);                                         \
    break;                                                       \
  } while (0)

#define BINOP_FLOAT(type, op)                                \
  do {                                                       \
    FLOAT_TYPE_##type rhs = BITCAST_TO_##type(POP_##type()); \
    FLOAT_TYPE_##type lhs = BITCAST_TO_##type(POP_##type()); \
    PUSH_##type(BITCAST_FROM_##type(lhs op rhs));            \
  } while (0)

#define BINOP_FLOAT_DIV(type)                                    \
  do {                                                           \
    VALUE_TYPE_##type rhs = POP_##type();                        \
    VALUE_TYPE_##type lhs = POP_##type();                        \
    if (WABT_UNLIKELY(IS_ZERO_##type(rhs))) {                    \
      if (IS_NAN_##type(lhs)) {                                  \
        PUSH_##type(lhs | type##_QUIET_NAN);                     \
      } else if (IS_ZERO_##type(lhs)) {                          \
        PUSH_##type(type##_QUIET_NAN);                           \
      } else {                                                   \
        VALUE_TYPE_##type sign =                                 \
            (lhs & type##_SIGN_MASK) ^ (rhs & type##_SIGN_MASK); \
        PUSH_##type(sign | type##_INF);                          \
      }                                                          \
    } else {                                                     \
      PUSH_##type(BITCAST_FROM_##type(BITCAST_TO_##type(lhs) /   \
                                      BITCAST_TO_##type(rhs)));  \
    }                                                            \
  } while (0)

#define BINOP_FLOAT_COMPARE(type, op)                        \
  do {                                                       \
    FLOAT_TYPE_##type rhs = BITCAST_TO_##type(POP_##type()); \
    FLOAT_TYPE_##type lhs = BITCAST_TO_##type(POP_##type()); \
    PUSH_I32(lhs op rhs);                                    \
  } while (0)

#define MIN_OP <
#define MAX_OP >

#define MINMAX_FLOAT(type, op)                                                 \
  do {                                                                         \
    VALUE_TYPE_##type rhs = POP_##type();                                      \
    VALUE_TYPE_##type lhs = POP_##type();                                      \
    VALUE_TYPE_##type result;                                                  \
    if (WABT_UNLIKELY(IS_NAN_##type(lhs))) {                                   \
      result = lhs | type##_QUIET_NAN_BIT;                                     \
    } else if (WABT_UNLIKELY(IS_NAN_##type(rhs))) {                            \
      result = rhs | type##_QUIET_NAN_BIT;                                     \
    } else if ((lhs ^ rhs) & type##_SIGN_MASK) {                               \
      /* min(-0.0, 0.0) => -0.0; since we know the sign bits are different, we \
       * can just use the inverse integer comparison (because the sign bit is  \
       * set when the value is negative) */                                    \
      result = !(lhs op##_OP rhs) ? lhs : rhs;                                 \
    } else {                                                                   \
      FLOAT_TYPE_##type float_rhs = BITCAST_TO_##type(rhs);                    \
      FLOAT_TYPE_##type float_lhs = BITCAST_TO_##type(lhs);                    \
      result = BITCAST_FROM_##type(float_lhs op##_OP float_rhs ? float_lhs     \
                                                               : float_rhs);   \
    }                                                                          \
    PUSH_##type(result);                                                       \
  } while (0)

static WABT_INLINE uint32_t read_u32_at(const uint8_t* pc) {
  uint32_t result;
  memcpy(&result, pc, sizeof(uint32_t));
  return result;
}

static WABT_INLINE uint32_t read_u32(const uint8_t** pc) {
  uint32_t result = read_u32_at(*pc);
  *pc += sizeof(uint32_t);
  return result;
}

static WABT_INLINE uint64_t read_u64_at(const uint8_t* pc) {
  uint64_t result;
  memcpy(&result, pc, sizeof(uint64_t));
  return result;
}

static WABT_INLINE uint64_t read_u64(const uint8_t** pc) {
  uint64_t result = read_u64_at(*pc);
  *pc += sizeof(uint64_t);
  return result;
}

static WABT_INLINE void read_table_entry_at(const uint8_t* pc,
                                            uint32_t* out_offset,
                                            uint32_t* out_drop,
                                            uint8_t* out_keep) {
  *out_offset = read_u32_at(pc + WABT_TABLE_ENTRY_OFFSET_OFFSET);
  *out_drop = read_u32_at(pc + WABT_TABLE_ENTRY_DROP_OFFSET);
  *out_keep = *(pc + WABT_TABLE_ENTRY_KEEP_OFFSET);
}

bool func_signatures_are_equal(InterpreterEnvironment* env,
                               uint32_t sig_index_0,
                               uint32_t sig_index_1) {
  if (sig_index_0 == sig_index_1)
    return true;
  InterpreterFuncSignature* sig_0 = &env->sigs[sig_index_0];
  InterpreterFuncSignature* sig_1 = &env->sigs[sig_index_1];
  return sig_0->param_types == sig_1->param_types &&
         sig_0->result_types == sig_1->result_types;
}

InterpreterResult call_host(InterpreterThread* thread,
                            HostInterpreterFunc* func) {
  InterpreterFuncSignature* sig = &thread->env->sigs[func->sig_index];

  size_t num_params = sig->param_types.size();
  size_t num_results = sig->result_types.size();
  // + 1 is a workaround for using data() below; UBSAN doesn't like calling
  // data() with an empty vector.
  std::vector<InterpreterTypedValue> params(num_params + 1);
  std::vector<InterpreterTypedValue> results(num_results + 1);

  for (size_t i = num_params; i > 0; --i) {
    params[i - 1].value = POP();
    params[i - 1].type = sig->param_types[i - 1];
  }

  Result call_result =
      func->callback(func, sig, num_params, params.data(), num_results,
                     results.data(), func->user_data);
  TRAP_IF(call_result != Result::Ok, HostTrapped);

  for (size_t i = 0; i < num_results; ++i) {
    TRAP_IF(results[i].type != sig->result_types[i], HostResultTypeMismatch);
    PUSH(results[i].value);
  }

  return InterpreterResult::Ok;
}

InterpreterResult run_interpreter(InterpreterThread* thread,
                                  uint32_t num_instructions,
                                  uint32_t* call_stack_return_top) {
  InterpreterResult result = InterpreterResult::Ok;
  assert(call_stack_return_top < thread->call_stack_end);

  InterpreterEnvironment* env = thread->env;

  const uint8_t* istream = env->istream->data.data();
  const uint8_t* pc = &istream[thread->pc];
  for (uint32_t i = 0; i < num_instructions; ++i) {
    InterpreterOpcode opcode = static_cast<InterpreterOpcode>(*pc++);
    switch (opcode) {
      case InterpreterOpcode::Select: {
        VALUE_TYPE_I32 cond = POP_I32();
        InterpreterValue false_ = POP();
        InterpreterValue true_ = POP();
        PUSH(cond ? true_ : false_);
        break;
      }

      case InterpreterOpcode::Br:
        GOTO(read_u32(&pc));
        break;

      case InterpreterOpcode::BrIf: {
        uint32_t new_pc = read_u32(&pc);
        if (POP_I32())
          GOTO(new_pc);
        break;
      }

      case InterpreterOpcode::BrTable: {
        uint32_t num_targets = read_u32(&pc);
        uint32_t table_offset = read_u32(&pc);
        VALUE_TYPE_I32 key = POP_I32();
        uint32_t key_offset =
            (key >= num_targets ? num_targets : key) * WABT_TABLE_ENTRY_SIZE;
        const uint8_t* entry = istream + table_offset + key_offset;
        uint32_t new_pc;
        uint32_t drop_count;
        uint8_t keep_count;
        read_table_entry_at(entry, &new_pc, &drop_count, &keep_count);
        DROP_KEEP(drop_count, keep_count);
        GOTO(new_pc);
        break;
      }

      case InterpreterOpcode::Return:
        if (thread->call_stack_top == call_stack_return_top) {
          result = InterpreterResult::Returned;
          goto exit_loop;
        }
        GOTO(POP_CALL());
        break;

      case InterpreterOpcode::Unreachable:
        TRAP(Unreachable);
        break;

      case InterpreterOpcode::I32Const:
        PUSH_I32(read_u32(&pc));
        break;

      case InterpreterOpcode::I64Const:
        PUSH_I64(read_u64(&pc));
        break;

      case InterpreterOpcode::F32Const:
        PUSH_F32(read_u32(&pc));
        break;

      case InterpreterOpcode::F64Const:
        PUSH_F64(read_u64(&pc));
        break;

      case InterpreterOpcode::GetGlobal: {
        uint32_t index = read_u32(&pc);
        assert(index < env->globals.size());
        PUSH(env->globals[index].typed_value.value);
        break;
      }

      case InterpreterOpcode::SetGlobal: {
        uint32_t index = read_u32(&pc);
        assert(index < env->globals.size());
        env->globals[index].typed_value.value = POP();
        break;
      }

      case InterpreterOpcode::GetLocal: {
        InterpreterValue value = PICK(read_u32(&pc));
        PUSH(value);
        break;
      }

      case InterpreterOpcode::SetLocal: {
        InterpreterValue value = POP();
        PICK(read_u32(&pc)) = value;
        break;
      }

      case InterpreterOpcode::TeeLocal:
        PICK(read_u32(&pc)) = TOP();
        break;

      case InterpreterOpcode::Call: {
        uint32_t offset = read_u32(&pc);
        PUSH_CALL();
        GOTO(offset);
        break;
      }

      case InterpreterOpcode::CallIndirect: {
        uint32_t table_index = read_u32(&pc);
        InterpreterTable* table = &env->tables[table_index];
        uint32_t sig_index = read_u32(&pc);
        VALUE_TYPE_I32 entry_index = POP_I32();
        TRAP_IF(entry_index >= table->func_indexes.size(), UndefinedTableIndex);
        uint32_t func_index = table->func_indexes[entry_index];
        TRAP_IF(func_index == WABT_INVALID_INDEX, UninitializedTableElement);
        InterpreterFunc* func = env->funcs[func_index].get();
        TRAP_UNLESS(func_signatures_are_equal(env, func->sig_index, sig_index),
                    IndirectCallSignatureMismatch);
        if (func->is_host) {
          call_host(thread, func->as_host());
        } else {
          PUSH_CALL();
          GOTO(func->as_defined()->offset);
        }
        break;
      }

      case InterpreterOpcode::CallHost: {
        uint32_t func_index = read_u32(&pc);
        call_host(thread, env->funcs[func_index]->as_host());
        break;
      }

      case InterpreterOpcode::I32Load8S:
        LOAD(I32, I8);
        break;

      case InterpreterOpcode::I32Load8U:
        LOAD(I32, U8);
        break;

      case InterpreterOpcode::I32Load16S:
        LOAD(I32, I16);
        break;

      case InterpreterOpcode::I32Load16U:
        LOAD(I32, U16);
        break;

      case InterpreterOpcode::I64Load8S:
        LOAD(I64, I8);
        break;

      case InterpreterOpcode::I64Load8U:
        LOAD(I64, U8);
        break;

      case InterpreterOpcode::I64Load16S:
        LOAD(I64, I16);
        break;

      case InterpreterOpcode::I64Load16U:
        LOAD(I64, U16);
        break;

      case InterpreterOpcode::I64Load32S:
        LOAD(I64, I32);
        break;

      case InterpreterOpcode::I64Load32U:
        LOAD(I64, U32);
        break;

      case InterpreterOpcode::I32Load:
        LOAD(I32, U32);
        break;

      case InterpreterOpcode::I64Load:
        LOAD(I64, U64);
        break;

      case InterpreterOpcode::F32Load:
        LOAD(F32, F32);
        break;

      case InterpreterOpcode::F64Load:
        LOAD(F64, F64);
        break;

      case InterpreterOpcode::I32Store8:
        STORE(I32, U8);
        break;

      case InterpreterOpcode::I32Store16:
        STORE(I32, U16);
        break;

      case InterpreterOpcode::I64Store8:
        STORE(I64, U8);
        break;

      case InterpreterOpcode::I64Store16:
        STORE(I64, U16);
        break;

      case InterpreterOpcode::I64Store32:
        STORE(I64, U32);
        break;

      case InterpreterOpcode::I32Store:
        STORE(I32, U32);
        break;

      case InterpreterOpcode::I64Store:
        STORE(I64, U64);
        break;

      case InterpreterOpcode::F32Store:
        STORE(F32, F32);
        break;

      case InterpreterOpcode::F64Store:
        STORE(F64, F64);
        break;

      case InterpreterOpcode::CurrentMemory: {
        GET_MEMORY(memory);
        PUSH_I32(memory->page_limits.initial);
        break;
      }

      case InterpreterOpcode::GrowMemory: {
        GET_MEMORY(memory);
        uint32_t old_page_size = memory->page_limits.initial;
        VALUE_TYPE_I32 grow_pages = POP_I32();
        uint32_t new_page_size = old_page_size + grow_pages;
        uint32_t max_page_size = memory->page_limits.has_max
                                     ? memory->page_limits.max
                                     : WABT_MAX_PAGES;
        PUSH_NEG_1_AND_BREAK_IF(new_page_size > max_page_size);
        PUSH_NEG_1_AND_BREAK_IF(
            static_cast<uint64_t>(new_page_size) * WABT_PAGE_SIZE > UINT32_MAX);
        memory->data.resize(new_page_size * WABT_PAGE_SIZE);
        memory->page_limits.initial = new_page_size;
        PUSH_I32(old_page_size);
        break;
      }

      case InterpreterOpcode::I32Add:
        BINOP(I32, I32, +);
        break;

      case InterpreterOpcode::I32Sub:
        BINOP(I32, I32, -);
        break;

      case InterpreterOpcode::I32Mul:
        BINOP(I32, I32, *);
        break;

      case InterpreterOpcode::I32DivS:
        BINOP_DIV_S(I32);
        break;

      case InterpreterOpcode::I32DivU:
        BINOP_DIV_REM_U(I32, /);
        break;

      case InterpreterOpcode::I32RemS:
        BINOP_REM_S(I32);
        break;

      case InterpreterOpcode::I32RemU:
        BINOP_DIV_REM_U(I32, %);
        break;

      case InterpreterOpcode::I32And:
        BINOP(I32, I32, &);
        break;

      case InterpreterOpcode::I32Or:
        BINOP(I32, I32, |);
        break;

      case InterpreterOpcode::I32Xor:
        BINOP(I32, I32, ^);
        break;

      case InterpreterOpcode::I32Shl:
        BINOP_SHIFT(I32, <<, UNSIGNED);
        break;

      case InterpreterOpcode::I32ShrU:
        BINOP_SHIFT(I32, >>, UNSIGNED);
        break;

      case InterpreterOpcode::I32ShrS:
        BINOP_SHIFT(I32, >>, SIGNED);
        break;

      case InterpreterOpcode::I32Eq:
        BINOP(I32, I32, ==);
        break;

      case InterpreterOpcode::I32Ne:
        BINOP(I32, I32, !=);
        break;

      case InterpreterOpcode::I32LtS:
        BINOP_SIGNED(I32, I32, <);
        break;

      case InterpreterOpcode::I32LeS:
        BINOP_SIGNED(I32, I32, <=);
        break;

      case InterpreterOpcode::I32LtU:
        BINOP(I32, I32, <);
        break;

      case InterpreterOpcode::I32LeU:
        BINOP(I32, I32, <=);
        break;

      case InterpreterOpcode::I32GtS:
        BINOP_SIGNED(I32, I32, >);
        break;

      case InterpreterOpcode::I32GeS:
        BINOP_SIGNED(I32, I32, >=);
        break;

      case InterpreterOpcode::I32GtU:
        BINOP(I32, I32, >);
        break;

      case InterpreterOpcode::I32GeU:
        BINOP(I32, I32, >=);
        break;

      case InterpreterOpcode::I32Clz: {
        VALUE_TYPE_I32 value = POP_I32();
        PUSH_I32(value != 0 ? wabt_clz_u32(value) : 32);
        break;
      }

      case InterpreterOpcode::I32Ctz: {
        VALUE_TYPE_I32 value = POP_I32();
        PUSH_I32(value != 0 ? wabt_ctz_u32(value) : 32);
        break;
      }

      case InterpreterOpcode::I32Popcnt: {
        VALUE_TYPE_I32 value = POP_I32();
        PUSH_I32(wabt_popcount_u32(value));
        break;
      }

      case InterpreterOpcode::I32Eqz: {
        VALUE_TYPE_I32 value = POP_I32();
        PUSH_I32(value == 0);
        break;
      }

      case InterpreterOpcode::I64Add:
        BINOP(I64, I64, +);
        break;

      case InterpreterOpcode::I64Sub:
        BINOP(I64, I64, -);
        break;

      case InterpreterOpcode::I64Mul:
        BINOP(I64, I64, *);
        break;

      case InterpreterOpcode::I64DivS:
        BINOP_DIV_S(I64);
        break;

      case InterpreterOpcode::I64DivU:
        BINOP_DIV_REM_U(I64, /);
        break;

      case InterpreterOpcode::I64RemS:
        BINOP_REM_S(I64);
        break;

      case InterpreterOpcode::I64RemU:
        BINOP_DIV_REM_U(I64, %);
        break;

      case InterpreterOpcode::I64And:
        BINOP(I64, I64, &);
        break;

      case InterpreterOpcode::I64Or:
        BINOP(I64, I64, |);
        break;

      case InterpreterOpcode::I64Xor:
        BINOP(I64, I64, ^);
        break;

      case InterpreterOpcode::I64Shl:
        BINOP_SHIFT(I64, <<, UNSIGNED);
        break;

      case InterpreterOpcode::I64ShrU:
        BINOP_SHIFT(I64, >>, UNSIGNED);
        break;

      case InterpreterOpcode::I64ShrS:
        BINOP_SHIFT(I64, >>, SIGNED);
        break;

      case InterpreterOpcode::I64Eq:
        BINOP(I32, I64, ==);
        break;

      case InterpreterOpcode::I64Ne:
        BINOP(I32, I64, !=);
        break;

      case InterpreterOpcode::I64LtS:
        BINOP_SIGNED(I32, I64, <);
        break;

      case InterpreterOpcode::I64LeS:
        BINOP_SIGNED(I32, I64, <=);
        break;

      case InterpreterOpcode::I64LtU:
        BINOP(I32, I64, <);
        break;

      case InterpreterOpcode::I64LeU:
        BINOP(I32, I64, <=);
        break;

      case InterpreterOpcode::I64GtS:
        BINOP_SIGNED(I32, I64, >);
        break;

      case InterpreterOpcode::I64GeS:
        BINOP_SIGNED(I32, I64, >=);
        break;

      case InterpreterOpcode::I64GtU:
        BINOP(I32, I64, >);
        break;

      case InterpreterOpcode::I64GeU:
        BINOP(I32, I64, >=);
        break;

      case InterpreterOpcode::I64Clz: {
        VALUE_TYPE_I64 value = POP_I64();
        PUSH_I64(value != 0 ? wabt_clz_u64(value) : 64);
        break;
      }

      case InterpreterOpcode::I64Ctz: {
        VALUE_TYPE_I64 value = POP_I64();
        PUSH_I64(value != 0 ? wabt_ctz_u64(value) : 64);
        break;
      }

      case InterpreterOpcode::I64Popcnt: {
        VALUE_TYPE_I64 value = POP_I64();
        PUSH_I64(wabt_popcount_u64(value));
        break;
      }

      case InterpreterOpcode::F32Add:
        BINOP_FLOAT(F32, +);
        break;

      case InterpreterOpcode::F32Sub:
        BINOP_FLOAT(F32, -);
        break;

      case InterpreterOpcode::F32Mul:
        BINOP_FLOAT(F32, *);
        break;

      case InterpreterOpcode::F32Div:
        BINOP_FLOAT_DIV(F32);
        break;

      case InterpreterOpcode::F32Min:
        MINMAX_FLOAT(F32, MIN);
        break;

      case InterpreterOpcode::F32Max:
        MINMAX_FLOAT(F32, MAX);
        break;

      case InterpreterOpcode::F32Abs:
        TOP().f32_bits &= ~F32_SIGN_MASK;
        break;

      case InterpreterOpcode::F32Neg:
        TOP().f32_bits ^= F32_SIGN_MASK;
        break;

      case InterpreterOpcode::F32Copysign: {
        VALUE_TYPE_F32 rhs = POP_F32();
        VALUE_TYPE_F32 lhs = POP_F32();
        PUSH_F32((lhs & ~F32_SIGN_MASK) | (rhs & F32_SIGN_MASK));
        break;
      }

      case InterpreterOpcode::F32Ceil:
        UNOP_FLOAT(F32, ceilf);
        break;

      case InterpreterOpcode::F32Floor:
        UNOP_FLOAT(F32, floorf);
        break;

      case InterpreterOpcode::F32Trunc:
        UNOP_FLOAT(F32, truncf);
        break;

      case InterpreterOpcode::F32Nearest:
        UNOP_FLOAT(F32, nearbyintf);
        break;

      case InterpreterOpcode::F32Sqrt:
        UNOP_FLOAT(F32, sqrtf);
        break;

      case InterpreterOpcode::F32Eq:
        BINOP_FLOAT_COMPARE(F32, ==);
        break;

      case InterpreterOpcode::F32Ne:
        BINOP_FLOAT_COMPARE(F32, !=);
        break;

      case InterpreterOpcode::F32Lt:
        BINOP_FLOAT_COMPARE(F32, <);
        break;

      case InterpreterOpcode::F32Le:
        BINOP_FLOAT_COMPARE(F32, <=);
        break;

      case InterpreterOpcode::F32Gt:
        BINOP_FLOAT_COMPARE(F32, >);
        break;

      case InterpreterOpcode::F32Ge:
        BINOP_FLOAT_COMPARE(F32, >=);
        break;

      case InterpreterOpcode::F64Add:
        BINOP_FLOAT(F64, +);
        break;

      case InterpreterOpcode::F64Sub:
        BINOP_FLOAT(F64, -);
        break;

      case InterpreterOpcode::F64Mul:
        BINOP_FLOAT(F64, *);
        break;

      case InterpreterOpcode::F64Div:
        BINOP_FLOAT_DIV(F64);
        break;

      case InterpreterOpcode::F64Min:
        MINMAX_FLOAT(F64, MIN);
        break;

      case InterpreterOpcode::F64Max:
        MINMAX_FLOAT(F64, MAX);
        break;

      case InterpreterOpcode::F64Abs:
        TOP().f64_bits &= ~F64_SIGN_MASK;
        break;

      case InterpreterOpcode::F64Neg:
        TOP().f64_bits ^= F64_SIGN_MASK;
        break;

      case InterpreterOpcode::F64Copysign: {
        VALUE_TYPE_F64 rhs = POP_F64();
        VALUE_TYPE_F64 lhs = POP_F64();
        PUSH_F64((lhs & ~F64_SIGN_MASK) | (rhs & F64_SIGN_MASK));
        break;
      }

      case InterpreterOpcode::F64Ceil:
        UNOP_FLOAT(F64, ceil);
        break;

      case InterpreterOpcode::F64Floor:
        UNOP_FLOAT(F64, floor);
        break;

      case InterpreterOpcode::F64Trunc:
        UNOP_FLOAT(F64, trunc);
        break;

      case InterpreterOpcode::F64Nearest:
        UNOP_FLOAT(F64, nearbyint);
        break;

      case InterpreterOpcode::F64Sqrt:
        UNOP_FLOAT(F64, sqrt);
        break;

      case InterpreterOpcode::F64Eq:
        BINOP_FLOAT_COMPARE(F64, ==);
        break;

      case InterpreterOpcode::F64Ne:
        BINOP_FLOAT_COMPARE(F64, !=);
        break;

      case InterpreterOpcode::F64Lt:
        BINOP_FLOAT_COMPARE(F64, <);
        break;

      case InterpreterOpcode::F64Le:
        BINOP_FLOAT_COMPARE(F64, <=);
        break;

      case InterpreterOpcode::F64Gt:
        BINOP_FLOAT_COMPARE(F64, >);
        break;

      case InterpreterOpcode::F64Ge:
        BINOP_FLOAT_COMPARE(F64, >=);
        break;

      case InterpreterOpcode::I32TruncSF32: {
        VALUE_TYPE_F32 value = POP_F32();
        TRAP_IF(is_nan_f32(value), InvalidConversionToInteger);
        TRAP_UNLESS(is_in_range_i32_trunc_s_f32(value), IntegerOverflow);
        PUSH_I32(static_cast<int32_t>(BITCAST_TO_F32(value)));
        break;
      }

      case InterpreterOpcode::I32TruncSF64: {
        VALUE_TYPE_F64 value = POP_F64();
        TRAP_IF(is_nan_f64(value), InvalidConversionToInteger);
        TRAP_UNLESS(is_in_range_i32_trunc_s_f64(value), IntegerOverflow);
        PUSH_I32(static_cast<int32_t>(BITCAST_TO_F64(value)));
        break;
      }

      case InterpreterOpcode::I32TruncUF32: {
        VALUE_TYPE_F32 value = POP_F32();
        TRAP_IF(is_nan_f32(value), InvalidConversionToInteger);
        TRAP_UNLESS(is_in_range_i32_trunc_u_f32(value), IntegerOverflow);
        PUSH_I32(static_cast<uint32_t>(BITCAST_TO_F32(value)));
        break;
      }

      case InterpreterOpcode::I32TruncUF64: {
        VALUE_TYPE_F64 value = POP_F64();
        TRAP_IF(is_nan_f64(value), InvalidConversionToInteger);
        TRAP_UNLESS(is_in_range_i32_trunc_u_f64(value), IntegerOverflow);
        PUSH_I32(static_cast<uint32_t>(BITCAST_TO_F64(value)));
        break;
      }

      case InterpreterOpcode::I32WrapI64: {
        VALUE_TYPE_I64 value = POP_I64();
        PUSH_I32(static_cast<uint32_t>(value));
        break;
      }

      case InterpreterOpcode::I64TruncSF32: {
        VALUE_TYPE_F32 value = POP_F32();
        TRAP_IF(is_nan_f32(value), InvalidConversionToInteger);
        TRAP_UNLESS(is_in_range_i64_trunc_s_f32(value), IntegerOverflow);
        PUSH_I64(static_cast<int64_t>(BITCAST_TO_F32(value)));
        break;
      }

      case InterpreterOpcode::I64TruncSF64: {
        VALUE_TYPE_F64 value = POP_F64();
        TRAP_IF(is_nan_f64(value), InvalidConversionToInteger);
        TRAP_UNLESS(is_in_range_i64_trunc_s_f64(value), IntegerOverflow);
        PUSH_I64(static_cast<int64_t>(BITCAST_TO_F64(value)));
        break;
      }

      case InterpreterOpcode::I64TruncUF32: {
        VALUE_TYPE_F32 value = POP_F32();
        TRAP_IF(is_nan_f32(value), InvalidConversionToInteger);
        TRAP_UNLESS(is_in_range_i64_trunc_u_f32(value), IntegerOverflow);
        PUSH_I64(static_cast<uint64_t>(BITCAST_TO_F32(value)));
        break;
      }

      case InterpreterOpcode::I64TruncUF64: {
        VALUE_TYPE_F64 value = POP_F64();
        TRAP_IF(is_nan_f64(value), InvalidConversionToInteger);
        TRAP_UNLESS(is_in_range_i64_trunc_u_f64(value), IntegerOverflow);
        PUSH_I64(static_cast<uint64_t>(BITCAST_TO_F64(value)));
        break;
      }

      case InterpreterOpcode::I64ExtendSI32: {
        VALUE_TYPE_I32 value = POP_I32();
        PUSH_I64(static_cast<int64_t>(BITCAST_I32_TO_SIGNED(value)));
        break;
      }

      case InterpreterOpcode::I64ExtendUI32: {
        VALUE_TYPE_I32 value = POP_I32();
        PUSH_I64(static_cast<uint64_t>(value));
        break;
      }

      case InterpreterOpcode::F32ConvertSI32: {
        VALUE_TYPE_I32 value = POP_I32();
        PUSH_F32(
            BITCAST_FROM_F32(static_cast<float>(BITCAST_I32_TO_SIGNED(value))));
        break;
      }

      case InterpreterOpcode::F32ConvertUI32: {
        VALUE_TYPE_I32 value = POP_I32();
        PUSH_F32(BITCAST_FROM_F32(static_cast<float>(value)));
        break;
      }

      case InterpreterOpcode::F32ConvertSI64: {
        VALUE_TYPE_I64 value = POP_I64();
        PUSH_F32(
            BITCAST_FROM_F32(static_cast<float>(BITCAST_I64_TO_SIGNED(value))));
        break;
      }

      case InterpreterOpcode::F32ConvertUI64: {
        VALUE_TYPE_I64 value = POP_I64();
        PUSH_F32(BITCAST_FROM_F32(wabt_convert_uint64_to_float(value)));
        break;
      }

      case InterpreterOpcode::F32DemoteF64: {
        VALUE_TYPE_F64 value = POP_F64();
        if (WABT_LIKELY(is_in_range_f64_demote_f32(value))) {
          PUSH_F32(BITCAST_FROM_F32(static_cast<float>(BITCAST_TO_F64(value))));
        } else if (is_in_range_f64_demote_f32_round_to_f32_max(value)) {
          PUSH_F32(F32_MAX);
        } else if (is_in_range_f64_demote_f32_round_to_neg_f32_max(value)) {
          PUSH_F32(F32_NEG_MAX);
        } else {
          uint32_t sign = (value >> 32) & F32_SIGN_MASK;
          uint32_t tag = 0;
          if (IS_NAN_F64(value)) {
            tag = F32_QUIET_NAN_BIT |
                  ((value >> (F64_SIG_BITS - F32_SIG_BITS)) & F32_SIG_MASK);
          }
          PUSH_F32(sign | F32_INF | tag);
        }
        break;
      }

      case InterpreterOpcode::F32ReinterpretI32: {
        VALUE_TYPE_I32 value = POP_I32();
        PUSH_F32(value);
        break;
      }

      case InterpreterOpcode::F64ConvertSI32: {
        VALUE_TYPE_I32 value = POP_I32();
        PUSH_F64(BITCAST_FROM_F64(
            static_cast<double>(BITCAST_I32_TO_SIGNED(value))));
        break;
      }

      case InterpreterOpcode::F64ConvertUI32: {
        VALUE_TYPE_I32 value = POP_I32();
        PUSH_F64(BITCAST_FROM_F64(static_cast<double>(value)));
        break;
      }

      case InterpreterOpcode::F64ConvertSI64: {
        VALUE_TYPE_I64 value = POP_I64();
        PUSH_F64(BITCAST_FROM_F64(
            static_cast<double>(BITCAST_I64_TO_SIGNED(value))));
        break;
      }

      case InterpreterOpcode::F64ConvertUI64: {
        VALUE_TYPE_I64 value = POP_I64();
        PUSH_F64(BITCAST_FROM_F64(wabt_convert_uint64_to_double(value)));
        break;
      }

      case InterpreterOpcode::F64PromoteF32: {
        VALUE_TYPE_F32 value = POP_F32();
        PUSH_F64(BITCAST_FROM_F64(static_cast<double>(BITCAST_TO_F32(value))));
        break;
      }

      case InterpreterOpcode::F64ReinterpretI64: {
        VALUE_TYPE_I64 value = POP_I64();
        PUSH_F64(value);
        break;
      }

      case InterpreterOpcode::I32ReinterpretF32: {
        VALUE_TYPE_F32 value = POP_F32();
        PUSH_I32(value);
        break;
      }

      case InterpreterOpcode::I64ReinterpretF64: {
        VALUE_TYPE_F64 value = POP_F64();
        PUSH_I64(value);
        break;
      }

      case InterpreterOpcode::I32Rotr:
        BINOP_ROT(I32, RIGHT);
        break;

      case InterpreterOpcode::I32Rotl:
        BINOP_ROT(I32, LEFT);
        break;

      case InterpreterOpcode::I64Rotr:
        BINOP_ROT(I64, RIGHT);
        break;

      case InterpreterOpcode::I64Rotl:
        BINOP_ROT(I64, LEFT);
        break;

      case InterpreterOpcode::I64Eqz: {
        VALUE_TYPE_I64 value = POP_I64();
        PUSH_I64(value == 0);
        break;
      }

      case InterpreterOpcode::Alloca: {
        InterpreterValue* old_value_stack_top = thread->value_stack_top;
        thread->value_stack_top += read_u32(&pc);
        CHECK_STACK();
        memset(old_value_stack_top, 0,
               (thread->value_stack_top - old_value_stack_top) *
                   sizeof(InterpreterValue));
        break;
      }

      case InterpreterOpcode::BrUnless: {
        uint32_t new_pc = read_u32(&pc);
        if (!POP_I32())
          GOTO(new_pc);
        break;
      }

      case InterpreterOpcode::Drop:
        (void)POP();
        break;

      case InterpreterOpcode::DropKeep: {
        uint32_t drop_count = read_u32(&pc);
        uint8_t keep_count = *pc++;
        DROP_KEEP(drop_count, keep_count);
        break;
      }

      case InterpreterOpcode::Data:
        /* shouldn't ever execute this */
        assert(0);
        break;

      case InterpreterOpcode::Nop:
        break;

      default:
        assert(0);
        break;
    }
  }

exit_loop:
  thread->pc = pc - istream;
  return result;
}

void trace_pc(InterpreterThread* thread, Stream* stream) {
  const uint8_t* istream = thread->env->istream->data.data();
  const uint8_t* pc = &istream[thread->pc];
  size_t value_stack_depth =
      thread->value_stack_top - thread->value_stack.data();
  size_t call_stack_depth = thread->call_stack_top - thread->call_stack.data();

  stream->Writef("#%" PRIzd ". %4" PRIzd ": V:%-3" PRIzd "| ", call_stack_depth,
                 pc - thread->env->istream->data.data(), value_stack_depth);

  InterpreterOpcode opcode = static_cast<InterpreterOpcode>(*pc++);
  switch (opcode) {
    case InterpreterOpcode::Select:
      stream->Writef("%s %u, %" PRIu64 ", %" PRIu64 "\n",
                     get_interpreter_opcode_name(opcode), PICK(3).i32,
                     PICK(2).i64, PICK(1).i64);
      break;

    case InterpreterOpcode::Br:
      stream->Writef("%s @%u\n", get_interpreter_opcode_name(opcode),
                     read_u32_at(pc));
      break;

    case InterpreterOpcode::BrIf:
      stream->Writef("%s @%u, %u\n", get_interpreter_opcode_name(opcode),
                     read_u32_at(pc), TOP().i32);
      break;

    case InterpreterOpcode::BrTable: {
      uint32_t num_targets = read_u32_at(pc);
      uint32_t table_offset = read_u32_at(pc + 4);
      VALUE_TYPE_I32 key = TOP().i32;
      stream->Writef("%s %u, $#%u, table:$%u\n",
                     get_interpreter_opcode_name(opcode), key, num_targets,
                     table_offset);
      break;
    }

    case InterpreterOpcode::Nop:
    case InterpreterOpcode::Return:
    case InterpreterOpcode::Unreachable:
    case InterpreterOpcode::Drop:
      stream->Writef("%s\n", get_interpreter_opcode_name(opcode));
      break;

    case InterpreterOpcode::CurrentMemory: {
      uint32_t memory_index = read_u32(&pc);
      stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode),
                     memory_index);
      break;
    }

    case InterpreterOpcode::I32Const:
      stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode),
                     read_u32_at(pc));
      break;

    case InterpreterOpcode::I64Const:
      stream->Writef("%s $%" PRIu64 "\n", get_interpreter_opcode_name(opcode),
                     read_u64_at(pc));
      break;

    case InterpreterOpcode::F32Const:
      stream->Writef("%s $%g\n", get_interpreter_opcode_name(opcode),
                     bitcast_u32_to_f32(read_u32_at(pc)));
      break;

    case InterpreterOpcode::F64Const:
      stream->Writef("%s $%g\n", get_interpreter_opcode_name(opcode),
                     bitcast_u64_to_f64(read_u64_at(pc)));
      break;

    case InterpreterOpcode::GetLocal:
    case InterpreterOpcode::GetGlobal:
      stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode),
                     read_u32_at(pc));
      break;

    case InterpreterOpcode::SetLocal:
    case InterpreterOpcode::SetGlobal:
    case InterpreterOpcode::TeeLocal:
      stream->Writef("%s $%u, %u\n", get_interpreter_opcode_name(opcode),
                     read_u32_at(pc), TOP().i32);
      break;

    case InterpreterOpcode::Call:
      stream->Writef("%s @%u\n", get_interpreter_opcode_name(opcode),
                     read_u32_at(pc));
      break;

    case InterpreterOpcode::CallIndirect:
      stream->Writef("%s $%u, %u\n", get_interpreter_opcode_name(opcode),
                     read_u32_at(pc), TOP().i32);
      break;

    case InterpreterOpcode::CallHost:
      stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode),
                     read_u32_at(pc));
      break;

    case InterpreterOpcode::I32Load8S:
    case InterpreterOpcode::I32Load8U:
    case InterpreterOpcode::I32Load16S:
    case InterpreterOpcode::I32Load16U:
    case InterpreterOpcode::I64Load8S:
    case InterpreterOpcode::I64Load8U:
    case InterpreterOpcode::I64Load16S:
    case InterpreterOpcode::I64Load16U:
    case InterpreterOpcode::I64Load32S:
    case InterpreterOpcode::I64Load32U:
    case InterpreterOpcode::I32Load:
    case InterpreterOpcode::I64Load:
    case InterpreterOpcode::F32Load:
    case InterpreterOpcode::F64Load: {
      uint32_t memory_index = read_u32(&pc);
      stream->Writef("%s $%u:%u+$%u\n", get_interpreter_opcode_name(opcode),
                     memory_index, TOP().i32, read_u32_at(pc));
      break;
    }

    case InterpreterOpcode::I32Store8:
    case InterpreterOpcode::I32Store16:
    case InterpreterOpcode::I32Store: {
      uint32_t memory_index = read_u32(&pc);
      stream->Writef("%s $%u:%u+$%u, %u\n", get_interpreter_opcode_name(opcode),
                     memory_index, PICK(2).i32, read_u32_at(pc), PICK(1).i32);
      break;
    }

    case InterpreterOpcode::I64Store8:
    case InterpreterOpcode::I64Store16:
    case InterpreterOpcode::I64Store32:
    case InterpreterOpcode::I64Store: {
      uint32_t memory_index = read_u32(&pc);
      stream->Writef("%s $%u:%u+$%u, %" PRIu64 "\n",
                     get_interpreter_opcode_name(opcode), memory_index,
                     PICK(2).i32, read_u32_at(pc), PICK(1).i64);
      break;
    }

    case InterpreterOpcode::F32Store: {
      uint32_t memory_index = read_u32(&pc);
      stream->Writef("%s $%u:%u+$%u, %g\n", get_interpreter_opcode_name(opcode),
                     memory_index, PICK(2).i32, read_u32_at(pc),
                     bitcast_u32_to_f32(PICK(1).f32_bits));
      break;
    }

    case InterpreterOpcode::F64Store: {
      uint32_t memory_index = read_u32(&pc);
      stream->Writef("%s $%u:%u+$%u, %g\n", get_interpreter_opcode_name(opcode),
                     memory_index, PICK(2).i32, read_u32_at(pc),
                     bitcast_u64_to_f64(PICK(1).f64_bits));
      break;
    }

    case InterpreterOpcode::GrowMemory: {
      uint32_t memory_index = read_u32(&pc);
      stream->Writef("%s $%u:%u\n", get_interpreter_opcode_name(opcode),
                     memory_index, TOP().i32);
      break;
    }

    case InterpreterOpcode::I32Add:
    case InterpreterOpcode::I32Sub:
    case InterpreterOpcode::I32Mul:
    case InterpreterOpcode::I32DivS:
    case InterpreterOpcode::I32DivU:
    case InterpreterOpcode::I32RemS:
    case InterpreterOpcode::I32RemU:
    case InterpreterOpcode::I32And:
    case InterpreterOpcode::I32Or:
    case InterpreterOpcode::I32Xor:
    case InterpreterOpcode::I32Shl:
    case InterpreterOpcode::I32ShrU:
    case InterpreterOpcode::I32ShrS:
    case InterpreterOpcode::I32Eq:
    case InterpreterOpcode::I32Ne:
    case InterpreterOpcode::I32LtS:
    case InterpreterOpcode::I32LeS:
    case InterpreterOpcode::I32LtU:
    case InterpreterOpcode::I32LeU:
    case InterpreterOpcode::I32GtS:
    case InterpreterOpcode::I32GeS:
    case InterpreterOpcode::I32GtU:
    case InterpreterOpcode::I32GeU:
    case InterpreterOpcode::I32Rotr:
    case InterpreterOpcode::I32Rotl:
      stream->Writef("%s %u, %u\n", get_interpreter_opcode_name(opcode),
                     PICK(2).i32, PICK(1).i32);
      break;

    case InterpreterOpcode::I32Clz:
    case InterpreterOpcode::I32Ctz:
    case InterpreterOpcode::I32Popcnt:
    case InterpreterOpcode::I32Eqz:
      stream->Writef("%s %u\n", get_interpreter_opcode_name(opcode), TOP().i32);
      break;

    case InterpreterOpcode::I64Add:
    case InterpreterOpcode::I64Sub:
    case InterpreterOpcode::I64Mul:
    case InterpreterOpcode::I64DivS:
    case InterpreterOpcode::I64DivU:
    case InterpreterOpcode::I64RemS:
    case InterpreterOpcode::I64RemU:
    case InterpreterOpcode::I64And:
    case InterpreterOpcode::I64Or:
    case InterpreterOpcode::I64Xor:
    case InterpreterOpcode::I64Shl:
    case InterpreterOpcode::I64ShrU:
    case InterpreterOpcode::I64ShrS:
    case InterpreterOpcode::I64Eq:
    case InterpreterOpcode::I64Ne:
    case InterpreterOpcode::I64LtS:
    case InterpreterOpcode::I64LeS:
    case InterpreterOpcode::I64LtU:
    case InterpreterOpcode::I64LeU:
    case InterpreterOpcode::I64GtS:
    case InterpreterOpcode::I64GeS:
    case InterpreterOpcode::I64GtU:
    case InterpreterOpcode::I64GeU:
    case InterpreterOpcode::I64Rotr:
    case InterpreterOpcode::I64Rotl:
      stream->Writef("%s %" PRIu64 ", %" PRIu64 "\n",
                     get_interpreter_opcode_name(opcode), PICK(2).i64,
                     PICK(1).i64);
      break;

    case InterpreterOpcode::I64Clz:
    case InterpreterOpcode::I64Ctz:
    case InterpreterOpcode::I64Popcnt:
    case InterpreterOpcode::I64Eqz:
      stream->Writef("%s %" PRIu64 "\n", get_interpreter_opcode_name(opcode),
                     TOP().i64);
      break;

    case InterpreterOpcode::F32Add:
    case InterpreterOpcode::F32Sub:
    case InterpreterOpcode::F32Mul:
    case InterpreterOpcode::F32Div:
    case InterpreterOpcode::F32Min:
    case InterpreterOpcode::F32Max:
    case InterpreterOpcode::F32Copysign:
    case InterpreterOpcode::F32Eq:
    case InterpreterOpcode::F32Ne:
    case InterpreterOpcode::F32Lt:
    case InterpreterOpcode::F32Le:
    case InterpreterOpcode::F32Gt:
    case InterpreterOpcode::F32Ge:
      stream->Writef("%s %g, %g\n", get_interpreter_opcode_name(opcode),
                     bitcast_u32_to_f32(PICK(2).i32),
                     bitcast_u32_to_f32(PICK(1).i32));
      break;

    case InterpreterOpcode::F32Abs:
    case InterpreterOpcode::F32Neg:
    case InterpreterOpcode::F32Ceil:
    case InterpreterOpcode::F32Floor:
    case InterpreterOpcode::F32Trunc:
    case InterpreterOpcode::F32Nearest:
    case InterpreterOpcode::F32Sqrt:
      stream->Writef("%s %g\n", get_interpreter_opcode_name(opcode),
                     bitcast_u32_to_f32(TOP().i32));
      break;

    case InterpreterOpcode::F64Add:
    case InterpreterOpcode::F64Sub:
    case InterpreterOpcode::F64Mul:
    case InterpreterOpcode::F64Div:
    case InterpreterOpcode::F64Min:
    case InterpreterOpcode::F64Max:
    case InterpreterOpcode::F64Copysign:
    case InterpreterOpcode::F64Eq:
    case InterpreterOpcode::F64Ne:
    case InterpreterOpcode::F64Lt:
    case InterpreterOpcode::F64Le:
    case InterpreterOpcode::F64Gt:
    case InterpreterOpcode::F64Ge:
      stream->Writef("%s %g, %g\n", get_interpreter_opcode_name(opcode),
                     bitcast_u64_to_f64(PICK(2).i64),
                     bitcast_u64_to_f64(PICK(1).i64));
      break;

    case InterpreterOpcode::F64Abs:
    case InterpreterOpcode::F64Neg:
    case InterpreterOpcode::F64Ceil:
    case InterpreterOpcode::F64Floor:
    case InterpreterOpcode::F64Trunc:
    case InterpreterOpcode::F64Nearest:
    case InterpreterOpcode::F64Sqrt:
      stream->Writef("%s %g\n", get_interpreter_opcode_name(opcode),
                     bitcast_u64_to_f64(TOP().i64));
      break;

    case InterpreterOpcode::I32TruncSF32:
    case InterpreterOpcode::I32TruncUF32:
    case InterpreterOpcode::I64TruncSF32:
    case InterpreterOpcode::I64TruncUF32:
    case InterpreterOpcode::F64PromoteF32:
    case InterpreterOpcode::I32ReinterpretF32:
      stream->Writef("%s %g\n", get_interpreter_opcode_name(opcode),
                     bitcast_u32_to_f32(TOP().i32));
      break;

    case InterpreterOpcode::I32TruncSF64:
    case InterpreterOpcode::I32TruncUF64:
    case InterpreterOpcode::I64TruncSF64:
    case InterpreterOpcode::I64TruncUF64:
    case InterpreterOpcode::F32DemoteF64:
    case InterpreterOpcode::I64ReinterpretF64:
      stream->Writef("%s %g\n", get_interpreter_opcode_name(opcode),
                     bitcast_u64_to_f64(TOP().i64));
      break;

    case InterpreterOpcode::I32WrapI64:
    case InterpreterOpcode::F32ConvertSI64:
    case InterpreterOpcode::F32ConvertUI64:
    case InterpreterOpcode::F64ConvertSI64:
    case InterpreterOpcode::F64ConvertUI64:
    case InterpreterOpcode::F64ReinterpretI64:
      stream->Writef("%s %" PRIu64 "\n", get_interpreter_opcode_name(opcode),
                     TOP().i64);
      break;

    case InterpreterOpcode::I64ExtendSI32:
    case InterpreterOpcode::I64ExtendUI32:
    case InterpreterOpcode::F32ConvertSI32:
    case InterpreterOpcode::F32ConvertUI32:
    case InterpreterOpcode::F32ReinterpretI32:
    case InterpreterOpcode::F64ConvertSI32:
    case InterpreterOpcode::F64ConvertUI32:
      stream->Writef("%s %u\n", get_interpreter_opcode_name(opcode), TOP().i32);
      break;

    case InterpreterOpcode::Alloca:
      stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode),
                     read_u32_at(pc));
      break;

    case InterpreterOpcode::BrUnless:
      stream->Writef("%s @%u, %u\n", get_interpreter_opcode_name(opcode),
                     read_u32_at(pc), TOP().i32);
      break;

    case InterpreterOpcode::DropKeep:
      stream->Writef("%s $%u $%u\n", get_interpreter_opcode_name(opcode),
                     read_u32_at(pc), *(pc + 4));
      break;

    case InterpreterOpcode::Data:
      /* shouldn't ever execute this */
      assert(0);
      break;

    default:
      assert(0);
      break;
  }
}

void disassemble(InterpreterEnvironment* env,
                 Stream* stream,
                 uint32_t from,
                 uint32_t to) {
  /* TODO(binji): mark function entries */
  /* TODO(binji): track value stack size */
  if (from >= env->istream->data.size())
    return;
  to = std::min<uint32_t>(to, env->istream->data.size());
  const uint8_t* istream = env->istream->data.data();
  const uint8_t* pc = &istream[from];

  while (static_cast<uint32_t>(pc - istream) < to) {
    stream->Writef("%4" PRIzd "| ", pc - istream);

    InterpreterOpcode opcode = static_cast<InterpreterOpcode>(*pc++);
    switch (opcode) {
      case InterpreterOpcode::Select:
        stream->Writef("%s %%[-3], %%[-2], %%[-1]\n",
                       get_interpreter_opcode_name(opcode));
        break;

      case InterpreterOpcode::Br:
        stream->Writef("%s @%u\n", get_interpreter_opcode_name(opcode),
                       read_u32(&pc));
        break;

      case InterpreterOpcode::BrIf:
        stream->Writef("%s @%u, %%[-1]\n", get_interpreter_opcode_name(opcode),
                       read_u32(&pc));
        break;

      case InterpreterOpcode::BrTable: {
        uint32_t num_targets = read_u32(&pc);
        uint32_t table_offset = read_u32(&pc);
        stream->Writef("%s %%[-1], $#%u, table:$%u\n",
                       get_interpreter_opcode_name(opcode), num_targets,
                       table_offset);
        break;
      }

      case InterpreterOpcode::Nop:
      case InterpreterOpcode::Return:
      case InterpreterOpcode::Unreachable:
      case InterpreterOpcode::Drop:
        stream->Writef("%s\n", get_interpreter_opcode_name(opcode));
        break;

      case InterpreterOpcode::CurrentMemory: {
        uint32_t memory_index = read_u32(&pc);
        stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode),
                       memory_index);
        break;
      }

      case InterpreterOpcode::I32Const:
        stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode),
                       read_u32(&pc));
        break;

      case InterpreterOpcode::I64Const:
        stream->Writef("%s $%" PRIu64 "\n", get_interpreter_opcode_name(opcode),
                       read_u64(&pc));
        break;

      case InterpreterOpcode::F32Const:
        stream->Writef("%s $%g\n", get_interpreter_opcode_name(opcode),
                       bitcast_u32_to_f32(read_u32(&pc)));
        break;

      case InterpreterOpcode::F64Const:
        stream->Writef("%s $%g\n", get_interpreter_opcode_name(opcode),
                       bitcast_u64_to_f64(read_u64(&pc)));
        break;

      case InterpreterOpcode::GetLocal:
      case InterpreterOpcode::GetGlobal:
        stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode),
                       read_u32(&pc));
        break;

      case InterpreterOpcode::SetLocal:
      case InterpreterOpcode::SetGlobal:
      case InterpreterOpcode::TeeLocal:
        stream->Writef("%s $%u, %%[-1]\n", get_interpreter_opcode_name(opcode),
                       read_u32(&pc));
        break;

      case InterpreterOpcode::Call:
        stream->Writef("%s @%u\n", get_interpreter_opcode_name(opcode),
                       read_u32(&pc));
        break;

      case InterpreterOpcode::CallIndirect: {
        uint32_t table_index = read_u32(&pc);
        stream->Writef("%s $%u:%u, %%[-1]\n",
                       get_interpreter_opcode_name(opcode), table_index,
                       read_u32(&pc));
        break;
      }

      case InterpreterOpcode::CallHost:
        stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode),
                       read_u32(&pc));
        break;

      case InterpreterOpcode::I32Load8S:
      case InterpreterOpcode::I32Load8U:
      case InterpreterOpcode::I32Load16S:
      case InterpreterOpcode::I32Load16U:
      case InterpreterOpcode::I64Load8S:
      case InterpreterOpcode::I64Load8U:
      case InterpreterOpcode::I64Load16S:
      case InterpreterOpcode::I64Load16U:
      case InterpreterOpcode::I64Load32S:
      case InterpreterOpcode::I64Load32U:
      case InterpreterOpcode::I32Load:
      case InterpreterOpcode::I64Load:
      case InterpreterOpcode::F32Load:
      case InterpreterOpcode::F64Load: {
        uint32_t memory_index = read_u32(&pc);
        stream->Writef("%s $%u:%%[-1]+$%u\n",
                       get_interpreter_opcode_name(opcode), memory_index,
                       read_u32(&pc));
        break;
      }

      case InterpreterOpcode::I32Store8:
      case InterpreterOpcode::I32Store16:
      case InterpreterOpcode::I32Store:
      case InterpreterOpcode::I64Store8:
      case InterpreterOpcode::I64Store16:
      case InterpreterOpcode::I64Store32:
      case InterpreterOpcode::I64Store:
      case InterpreterOpcode::F32Store:
      case InterpreterOpcode::F64Store: {
        uint32_t memory_index = read_u32(&pc);
        stream->Writef("%s %%[-2]+$%u, $%u:%%[-1]\n",
                       get_interpreter_opcode_name(opcode), memory_index,
                       read_u32(&pc));
        break;
      }

      case InterpreterOpcode::I32Add:
      case InterpreterOpcode::I32Sub:
      case InterpreterOpcode::I32Mul:
      case InterpreterOpcode::I32DivS:
      case InterpreterOpcode::I32DivU:
      case InterpreterOpcode::I32RemS:
      case InterpreterOpcode::I32RemU:
      case InterpreterOpcode::I32And:
      case InterpreterOpcode::I32Or:
      case InterpreterOpcode::I32Xor:
      case InterpreterOpcode::I32Shl:
      case InterpreterOpcode::I32ShrU:
      case InterpreterOpcode::I32ShrS:
      case InterpreterOpcode::I32Eq:
      case InterpreterOpcode::I32Ne:
      case InterpreterOpcode::I32LtS:
      case InterpreterOpcode::I32LeS:
      case InterpreterOpcode::I32LtU:
      case InterpreterOpcode::I32LeU:
      case InterpreterOpcode::I32GtS:
      case InterpreterOpcode::I32GeS:
      case InterpreterOpcode::I32GtU:
      case InterpreterOpcode::I32GeU:
      case InterpreterOpcode::I32Rotr:
      case InterpreterOpcode::I32Rotl:
      case InterpreterOpcode::F32Add:
      case InterpreterOpcode::F32Sub:
      case InterpreterOpcode::F32Mul:
      case InterpreterOpcode::F32Div:
      case InterpreterOpcode::F32Min:
      case InterpreterOpcode::F32Max:
      case InterpreterOpcode::F32Copysign:
      case InterpreterOpcode::F32Eq:
      case InterpreterOpcode::F32Ne:
      case InterpreterOpcode::F32Lt:
      case InterpreterOpcode::F32Le:
      case InterpreterOpcode::F32Gt:
      case InterpreterOpcode::F32Ge:
      case InterpreterOpcode::I64Add:
      case InterpreterOpcode::I64Sub:
      case InterpreterOpcode::I64Mul:
      case InterpreterOpcode::I64DivS:
      case InterpreterOpcode::I64DivU:
      case InterpreterOpcode::I64RemS:
      case InterpreterOpcode::I64RemU:
      case InterpreterOpcode::I64And:
      case InterpreterOpcode::I64Or:
      case InterpreterOpcode::I64Xor:
      case InterpreterOpcode::I64Shl:
      case InterpreterOpcode::I64ShrU:
      case InterpreterOpcode::I64ShrS:
      case InterpreterOpcode::I64Eq:
      case InterpreterOpcode::I64Ne:
      case InterpreterOpcode::I64LtS:
      case InterpreterOpcode::I64LeS:
      case InterpreterOpcode::I64LtU:
      case InterpreterOpcode::I64LeU:
      case InterpreterOpcode::I64GtS:
      case InterpreterOpcode::I64GeS:
      case InterpreterOpcode::I64GtU:
      case InterpreterOpcode::I64GeU:
      case InterpreterOpcode::I64Rotr:
      case InterpreterOpcode::I64Rotl:
      case InterpreterOpcode::F64Add:
      case InterpreterOpcode::F64Sub:
      case InterpreterOpcode::F64Mul:
      case InterpreterOpcode::F64Div:
      case InterpreterOpcode::F64Min:
      case InterpreterOpcode::F64Max:
      case InterpreterOpcode::F64Copysign:
      case InterpreterOpcode::F64Eq:
      case InterpreterOpcode::F64Ne:
      case InterpreterOpcode::F64Lt:
      case InterpreterOpcode::F64Le:
      case InterpreterOpcode::F64Gt:
      case InterpreterOpcode::F64Ge:
        stream->Writef("%s %%[-2], %%[-1]\n",
                       get_interpreter_opcode_name(opcode));
        break;

      case InterpreterOpcode::I32Clz:
      case InterpreterOpcode::I32Ctz:
      case InterpreterOpcode::I32Popcnt:
      case InterpreterOpcode::I32Eqz:
      case InterpreterOpcode::I64Clz:
      case InterpreterOpcode::I64Ctz:
      case InterpreterOpcode::I64Popcnt:
      case InterpreterOpcode::I64Eqz:
      case InterpreterOpcode::F32Abs:
      case InterpreterOpcode::F32Neg:
      case InterpreterOpcode::F32Ceil:
      case InterpreterOpcode::F32Floor:
      case InterpreterOpcode::F32Trunc:
      case InterpreterOpcode::F32Nearest:
      case InterpreterOpcode::F32Sqrt:
      case InterpreterOpcode::F64Abs:
      case InterpreterOpcode::F64Neg:
      case InterpreterOpcode::F64Ceil:
      case InterpreterOpcode::F64Floor:
      case InterpreterOpcode::F64Trunc:
      case InterpreterOpcode::F64Nearest:
      case InterpreterOpcode::F64Sqrt:
      case InterpreterOpcode::I32TruncSF32:
      case InterpreterOpcode::I32TruncUF32:
      case InterpreterOpcode::I64TruncSF32:
      case InterpreterOpcode::I64TruncUF32:
      case InterpreterOpcode::F64PromoteF32:
      case InterpreterOpcode::I32ReinterpretF32:
      case InterpreterOpcode::I32TruncSF64:
      case InterpreterOpcode::I32TruncUF64:
      case InterpreterOpcode::I64TruncSF64:
      case InterpreterOpcode::I64TruncUF64:
      case InterpreterOpcode::F32DemoteF64:
      case InterpreterOpcode::I64ReinterpretF64:
      case InterpreterOpcode::I32WrapI64:
      case InterpreterOpcode::F32ConvertSI64:
      case InterpreterOpcode::F32ConvertUI64:
      case InterpreterOpcode::F64ConvertSI64:
      case InterpreterOpcode::F64ConvertUI64:
      case InterpreterOpcode::F64ReinterpretI64:
      case InterpreterOpcode::I64ExtendSI32:
      case InterpreterOpcode::I64ExtendUI32:
      case InterpreterOpcode::F32ConvertSI32:
      case InterpreterOpcode::F32ConvertUI32:
      case InterpreterOpcode::F32ReinterpretI32:
      case InterpreterOpcode::F64ConvertSI32:
      case InterpreterOpcode::F64ConvertUI32:
        stream->Writef("%s %%[-1]\n", get_interpreter_opcode_name(opcode));
        break;

      case InterpreterOpcode::GrowMemory: {
        uint32_t memory_index = read_u32(&pc);
        stream->Writef("%s $%u:%%[-1]\n", get_interpreter_opcode_name(opcode),
                       memory_index);
        break;
      }

      case InterpreterOpcode::Alloca:
        stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode),
                       read_u32(&pc));
        break;

      case InterpreterOpcode::BrUnless:
        stream->Writef("%s @%u, %%[-1]\n", get_interpreter_opcode_name(opcode),
                       read_u32(&pc));
        break;

      case InterpreterOpcode::DropKeep: {
        uint32_t drop = read_u32(&pc);
        uint32_t keep = *pc++;
        stream->Writef("%s $%u $%u\n", get_interpreter_opcode_name(opcode),
                       drop, keep);
        break;
      }

      case InterpreterOpcode::Data: {
        uint32_t num_bytes = read_u32(&pc);
        stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode),
                       num_bytes);
        /* for now, the only reason this is emitted is for br_table, so display
         * it as a list of table entries */
        if (num_bytes % WABT_TABLE_ENTRY_SIZE == 0) {
          uint32_t num_entries = num_bytes / WABT_TABLE_ENTRY_SIZE;
          for (uint32_t i = 0; i < num_entries; ++i) {
            stream->Writef("%4" PRIzd "| ", pc - istream);
            uint32_t offset;
            uint32_t drop;
            uint8_t keep;
            read_table_entry_at(pc, &offset, &drop, &keep);
            stream->Writef("  entry %d: offset: %u drop: %u keep: %u\n", i,
                           offset, drop, keep);
            pc += WABT_TABLE_ENTRY_SIZE;
          }
        } else {
          /* just skip those data bytes */
          pc += num_bytes;
        }

        break;
      }

      default:
        assert(0);
        break;
    }
  }
}

void disassemble_module(InterpreterEnvironment* env,
                        Stream* stream,
                        InterpreterModule* module) {
  assert(!module->is_host);
  disassemble(env, stream, module->as_defined()->istream_start,
              module->as_defined()->istream_end);
}

}  // namespace wabt