wasm_interp_classic.c

/*
 * Copyright (C) 2019 Intel Corporation.  All rights reserved.
 * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 */

#include "wasm_interp.h"
#include "bh_log.h"
#include "wasm_runtime.h"
#include "wasm_opcode.h"
#include "wasm_loader.h"
#include "wasm_memory.h"
#include "../common/wasm_exec_env.h"
#if WASM_ENABLE_GC != 0
#include "../common/gc/gc_object.h"
#include "mem_alloc.h"
#if WASM_ENABLE_STRINGREF != 0
#include "string_object.h"
#endif
#endif
#if WASM_ENABLE_SHARED_MEMORY != 0
#include "../common/wasm_shared_memory.h"
#endif
#if WASM_ENABLE_THREAD_MGR != 0 && WASM_ENABLE_DEBUG_INTERP != 0
#include "../libraries/thread-mgr/thread_manager.h"
#include "../libraries/debug-engine/debug_engine.h"
#endif
#if WASM_ENABLE_FAST_JIT != 0
#include "../fast-jit/jit_compiler.h"
#endif

typedef int32 CellType_I32;
typedef int64 CellType_I64;
typedef float32 CellType_F32;
typedef float64 CellType_F64;

#define BR_TABLE_TMP_BUF_LEN 32

#if WASM_ENABLE_THREAD_MGR == 0
#define get_linear_mem_size() linear_mem_size
#else
/**
 * Load memory data size in each time boundary check in
 * multi-threading mode since it may be changed by other
 * threads in memory.grow
 */
#define get_linear_mem_size() GET_LINEAR_MEMORY_SIZE(memory)
#endif

#if WASM_ENABLE_MEMORY64 == 0

#if (!defined(OS_ENABLE_HW_BOUND_CHECK) \
     || WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0)
#define CHECK_MEMORY_OVERFLOW(bytes)                                           \
    do {                                                                       \
        uint64 offset1 = (uint64)offset + (uint64)addr;                        \
        if (disable_bounds_checks || offset1 + bytes <= get_linear_mem_size()) \
            /* If offset1 is in valid range, maddr must also                   \
               be in valid range, no need to check it again. */                \
            maddr = memory->memory_data + offset1;                             \
        else                                                                   \
            goto out_of_bounds;                                                \
    } while (0)

#define CHECK_BULK_MEMORY_OVERFLOW(start, bytes, maddr)                        \
    do {                                                                       \
        uint64 offset1 = (uint32)(start);                                      \
        if (disable_bounds_checks || offset1 + bytes <= get_linear_mem_size()) \
            /* App heap space is not valid space for                           \
             bulk memory operation */                                          \
            maddr = memory->memory_data + offset1;                             \
        else                                                                   \
            goto out_of_bounds;                                                \
    } while (0)
#else /* else of !defined(OS_ENABLE_HW_BOUND_CHECK) || \
         WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0 */
#define CHECK_MEMORY_OVERFLOW(bytes)                    \
    do {                                                \
        uint64 offset1 = (uint64)offset + (uint64)addr; \
        maddr = memory->memory_data + offset1;          \
    } while (0)

#define CHECK_BULK_MEMORY_OVERFLOW(start, bytes, maddr) \
    do {                                                \
        maddr = memory->memory_data + (uint32)(start);  \
    } while (0)
#endif /* end of !defined(OS_ENABLE_HW_BOUND_CHECK) || \
          WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0 */

#else /* else of WASM_ENABLE_MEMORY64 == 0 */

#define CHECK_MEMORY_OVERFLOW(bytes)                                        \
    do {                                                                    \
        uint64 offset1 = (uint64)offset + (uint64)addr;                     \
        /* If memory64 is enabled, offset1, offset1 + bytes can overflow */ \
        if (disable_bounds_checks                                           \
            || (offset1 >= offset && offset1 + bytes >= offset1             \
                && offset1 + bytes <= get_linear_mem_size()))               \
            maddr = memory->memory_data + offset1;                          \
        else                                                                \
            goto out_of_bounds;                                             \
    } while (0)
#define CHECK_BULK_MEMORY_OVERFLOW(start, bytes, maddr)            \
    do {                                                           \
        uint64 offset1 = (uint64)(start);                          \
        /* If memory64 is enabled, offset1 + bytes can overflow */ \
        if (disable_bounds_checks                                  \
            || (offset1 + bytes >= offset1                         \
                && offset1 + bytes <= get_linear_mem_size()))      \
            /* App heap space is not valid space for               \
             bulk memory operation */                              \
            maddr = memory->memory_data + offset1;                 \
        else                                                       \
            goto out_of_bounds;                                    \
    } while (0)

#endif /* end of WASM_ENABLE_MEMORY64 == 0 */

#define CHECK_ATOMIC_MEMORY_ACCESS()                                 \
    do {                                                             \
        if (((uintptr_t)maddr & (((uintptr_t)1 << align) - 1)) != 0) \
            goto unaligned_atomic;                                   \
    } while (0)

#if WASM_ENABLE_DEBUG_INTERP != 0
#define TRIGGER_WATCHPOINT_SIGTRAP()                              \
    do {                                                          \
        wasm_cluster_thread_send_signal(exec_env, WAMR_SIG_TRAP); \
        CHECK_SUSPEND_FLAGS();                                    \
    } while (0)

#define CHECK_WATCHPOINT(list, current_addr)                               \
    do {                                                                   \
        WASMDebugWatchPoint *watchpoint = bh_list_first_elem(list);        \
        while (watchpoint) {                                               \
            WASMDebugWatchPoint *next = bh_list_elem_next(watchpoint);     \
            if (watchpoint->addr <= current_addr                           \
                && watchpoint->addr + watchpoint->length > current_addr) { \
                TRIGGER_WATCHPOINT_SIGTRAP();                              \
            }                                                              \
            watchpoint = next;                                             \
        }                                                                  \
    } while (0)

#define CHECK_READ_WATCHPOINT(addr, offset) \
    CHECK_WATCHPOINT(watch_point_list_read, WASM_ADDR_OFFSET(addr + offset))
#define CHECK_WRITE_WATCHPOINT(addr, offset) \
    CHECK_WATCHPOINT(watch_point_list_write, WASM_ADDR_OFFSET(addr + offset))
#else
#define CHECK_READ_WATCHPOINT(addr, offset) (void)0
#define CHECK_WRITE_WATCHPOINT(addr, offset) (void)0
#endif

static inline uint32
rotl32(uint32 n, uint32 c)
{
    const uint32 mask = (31);
    c = c % 32;
    c &= mask;
    return (n << c) | (n >> ((0 - c) & mask));
}

static inline uint32
rotr32(uint32 n, uint32 c)
{
    const uint32 mask = (31);
    c = c % 32;
    c &= mask;
    return (n >> c) | (n << ((0 - c) & mask));
}

static inline uint64
rotl64(uint64 n, uint64 c)
{
    const uint64 mask = (63);
    c = c % 64;
    c &= mask;
    return (n << c) | (n >> ((0 - c) & mask));
}

static inline uint64
rotr64(uint64 n, uint64 c)
{
    const uint64 mask = (63);
    c = c % 64;
    c &= mask;
    return (n >> c) | (n << ((0 - c) & mask));
}

static inline float32
f32_min(float32 a, float32 b)
{
    if (isnan(a) || isnan(b))
        return NAN;
    else if (a == 0 && a == b)
        return signbit(a) ? a : b;
    else
        return a > b ? b : a;
}

static inline float32
f32_max(float32 a, float32 b)
{
    if (isnan(a) || isnan(b))
        return NAN;
    else if (a == 0 && a == b)
        return signbit(a) ? b : a;
    else
        return a > b ? a : b;
}

static inline float64
f64_min(float64 a, float64 b)
{
    if (isnan(a) || isnan(b))
        return NAN;
    else if (a == 0 && a == b)
        return signbit(a) ? a : b;
    else
        return a > b ? b : a;
}

static inline float64
f64_max(float64 a, float64 b)
{
    if (isnan(a) || isnan(b))
        return NAN;
    else if (a == 0 && a == b)
        return signbit(a) ? b : a;
    else
        return a > b ? a : b;
}

static inline uint32
clz32(uint32 type)
{
    uint32 num = 0;
    if (type == 0)
        return 32;
    while (!(type & 0x80000000)) {
        num++;
        type <<= 1;
    }
    return num;
}

static inline uint32
clz64(uint64 type)
{
    uint32 num = 0;
    if (type == 0)
        return 64;
    while (!(type & 0x8000000000000000LL)) {
        num++;
        type <<= 1;
    }
    return num;
}

static inline uint32
ctz32(uint32 type)
{
    uint32 num = 0;
    if (type == 0)
        return 32;
    while (!(type & 1)) {
        num++;
        type >>= 1;
    }
    return num;
}

static inline uint32
ctz64(uint64 type)
{
    uint32 num = 0;
    if (type == 0)
        return 64;
    while (!(type & 1)) {
        num++;
        type >>= 1;
    }
    return num;
}

static inline uint32
popcount32(uint32 u)
{
    uint32 ret = 0;
    while (u) {
        u = (u & (u - 1));
        ret++;
    }
    return ret;
}

static inline uint32
popcount64(uint64 u)
{
    uint32 ret = 0;
    while (u) {
        u = (u & (u - 1));
        ret++;
    }
    return ret;
}

static float
local_copysignf(float x, float y)
{
    union {
        float f;
        uint32 i;
    } ux = { x }, uy = { y };
    ux.i &= 0x7fffffff;
    ux.i |= uy.i & 0x80000000;
    return ux.f;
}

static double
local_copysign(double x, double y)
{
    union {
        double f;
        uint64 i;
    } ux = { x }, uy = { y };
    ux.i &= UINT64_MAX / 2;
    ux.i |= uy.i & 1ULL << 63;
    return ux.f;
}

static uint64
read_leb(const uint8 *buf, uint32 *p_offset, uint32 maxbits, bool sign)
{
    uint64 result = 0, byte;
    uint32 offset = *p_offset;
    uint32 shift = 0;

    while (true) {
        byte = buf[offset++];
        result |= ((byte & 0x7f) << shift);
        shift += 7;
        if ((byte & 0x80) == 0) {
            break;
        }
    }
    if (sign && (shift < maxbits) && (byte & 0x40)) {
        /* Sign extend */
        result |= (~((uint64)0)) << shift;
    }
    *p_offset = offset;
    return result;
}

#if WASM_ENABLE_GC != 0
static uint8 *
get_frame_ref(WASMInterpFrame *frame)
{
    WASMFunctionInstance *cur_func = frame->function;
    uint32 all_cell_num;

    if (!cur_func) {
        /* it's a glue frame created in wasm_interp_call_wasm,
           no GC object will be traversed */
        return (uint8 *)frame->lp;
    }
    else if (!frame->ip) {
        /* it's a native method frame created in
           wasm_interp_call_func_native */
        all_cell_num =
            cur_func->param_cell_num > 2 ? cur_func->param_cell_num : 2;
        return (uint8 *)(frame->lp + all_cell_num);
    }
    else {
#if WASM_ENABLE_JIT == 0
        /* it's a wasm bytecode function frame */
        return (uint8 *)frame->csp_boundary;
#else
        return (uint8 *)(frame->lp + cur_func->param_cell_num
                         + cur_func->local_cell_num
                         + cur_func->u.func->max_stack_cell_num);
#endif
    }
}

static void
init_frame_refs(uint8 *frame_ref, uint32 cell_num, WASMFunctionInstance *func)
{
    uint32 i, j;

    memset(frame_ref, 0, cell_num);

    for (i = 0, j = 0; i < func->param_count; i++) {
        if (wasm_is_type_reftype(func->param_types[i])
            && !wasm_is_reftype_i31ref(func->param_types[i])) {
            frame_ref[j++] = 1;
#if UINTPTR_MAX == UINT64_MAX
            frame_ref[j++] = 1;
#endif
        }
        else {
            j += wasm_value_type_cell_num(func->param_types[i]);
        }
    }

    for (i = 0; i < func->local_count; i++) {
        if (wasm_is_type_reftype(func->local_types[i])
            && !wasm_is_reftype_i31ref(func->local_types[i])) {
            frame_ref[j++] = 1;
#if UINTPTR_MAX == UINT64_MAX
            frame_ref[j++] = 1;
#endif
        }
        else {
            j += wasm_value_type_cell_num(func->local_types[i]);
        }
    }
}

uint8 *
wasm_interp_get_frame_ref(WASMInterpFrame *frame)
{
    return get_frame_ref(frame);
}

/* Return the corresponding ref slot of the given address of local
   variable or stack pointer. */

#define COMPUTE_FRAME_REF(ref, lp, p) (ref + (unsigned)((uint32 *)p - lp))

#define FRAME_REF(p) COMPUTE_FRAME_REF(frame_ref, frame_lp, p)

#define FRAME_REF_FOR(frame, p) \
    COMPUTE_FRAME_REF(get_frame_ref(frame), frame->lp, p)

#define CLEAR_FRAME_REF(p, n)                   \
    do {                                        \
        int32 ref_i, ref_n = (int32)(n);        \
        uint8 *ref = FRAME_REF(p);              \
        for (ref_i = 0; ref_i < ref_n; ref_i++) \
            ref[ref_i] = 0;                     \
    } while (0)
#else
#define CLEAR_FRAME_REF(p, n) (void)0
#endif /* end of WASM_ENABLE_GC != 0 */

#define skip_leb(p) while (*p++ & 0x80)

#define PUSH_I32(value)                        \
    do {                                       \
        *(int32 *)frame_sp++ = (int32)(value); \
    } while (0)

#define PUSH_F32(value)                            \
    do {                                           \
        *(float32 *)frame_sp++ = (float32)(value); \
    } while (0)

#define PUSH_I64(value)                   \
    do {                                  \
        PUT_I64_TO_ADDR(frame_sp, value); \
        frame_sp += 2;                    \
    } while (0)

#define PUSH_F64(value)                   \
    do {                                  \
        PUT_F64_TO_ADDR(frame_sp, value); \
        frame_sp += 2;                    \
    } while (0)

#if UINTPTR_MAX == UINT64_MAX
#define PUSH_REF(value)                            \
    do {                                           \
        PUT_REF_TO_ADDR(frame_sp, value);          \
        frame_ref_tmp = FRAME_REF(frame_sp);       \
        *frame_ref_tmp = *(frame_ref_tmp + 1) = 1; \
        frame_sp += 2;                             \
    } while (0)
#define PUSH_I31REF(value)                \
    do {                                  \
        PUT_REF_TO_ADDR(frame_sp, value); \
        frame_sp += 2;                    \
    } while (0)
#else
#define PUSH_REF(value)                      \
    do {                                     \
        PUT_REF_TO_ADDR(frame_sp, value);    \
        frame_ref_tmp = FRAME_REF(frame_sp); \
        *frame_ref_tmp = 1;                  \
        frame_sp++;                          \
    } while (0)
#define PUSH_I31REF(value)                \
    do {                                  \
        PUT_REF_TO_ADDR(frame_sp, value); \
        frame_sp++;                       \
    } while (0)
#endif

/* in exception handling, label_type needs to be stored to lookup exception
 * handlers */

#if WASM_ENABLE_EXCE_HANDLING != 0
#define SET_LABEL_TYPE(_label_type) frame_csp->label_type = _label_type
#else
#define SET_LABEL_TYPE(_label_type) (void)0
#endif

#if WASM_ENABLE_MEMORY64 != 0
#define PUSH_MEM_OFFSET(value)                     \
    do {                                           \
        if (is_memory64) {                         \
            PUT_I64_TO_ADDR(frame_sp, value);      \
            frame_sp += 2;                         \
        }                                          \
        else {                                     \
            *(int32 *)frame_sp++ = (int32)(value); \
        }                                          \
    } while (0)
#else
#define PUSH_MEM_OFFSET(value) PUSH_I32(value)
#endif

#define PUSH_PAGE_COUNT(value) PUSH_MEM_OFFSET(value)

#define PUSH_CSP(_label_type, param_cell_num, cell_num, _target_addr) \
    do {                                                              \
        bh_assert(frame_csp < frame->csp_boundary);                   \
        SET_LABEL_TYPE(_label_type);                                  \
        frame_csp->cell_num = cell_num;                               \
        frame_csp->begin_addr = frame_ip;                             \
        frame_csp->target_addr = _target_addr;                        \
        frame_csp->frame_sp = frame_sp - param_cell_num;              \
        frame_csp++;                                                  \
    } while (0)

#define POP_I32() (--frame_sp, *(int32 *)frame_sp)

#define POP_F32() (--frame_sp, *(float32 *)frame_sp)

#define POP_I64() (frame_sp -= 2, GET_I64_FROM_ADDR(frame_sp))

#define POP_F64() (frame_sp -= 2, GET_F64_FROM_ADDR(frame_sp))

#if UINTPTR_MAX == UINT64_MAX
#define POP_REF()                                        \
    (frame_sp -= 2, frame_ref_tmp = FRAME_REF(frame_sp), \
     *frame_ref_tmp = *(frame_ref_tmp + 1) = 0, GET_REF_FROM_ADDR(frame_sp))
#else
#define POP_REF()                                                         \
    (frame_sp--, frame_ref_tmp = FRAME_REF(frame_sp), *frame_ref_tmp = 0, \
     GET_REF_FROM_ADDR(frame_sp))
#endif

#if WASM_ENABLE_MEMORY64 != 0
#define POP_MEM_OFFSET() (is_memory64 ? POP_I64() : POP_I32())
#else
#define POP_MEM_OFFSET() POP_I32()
#endif

#define POP_PAGE_COUNT() POP_MEM_OFFSET()

#define POP_CSP_CHECK_OVERFLOW(n)                      \
    do {                                               \
        bh_assert(frame_csp - n >= frame->csp_bottom); \
    } while (0)

#define POP_CSP()                  \
    do {                           \
        POP_CSP_CHECK_OVERFLOW(1); \
        --frame_csp;               \
    } while (0)

#define POP_CSP_N(n)                                                   \
    do {                                                               \
        uint32 *frame_sp_old = frame_sp;                               \
        uint32 cell_num_to_copy;                                       \
        POP_CSP_CHECK_OVERFLOW(n + 1);                                 \
        frame_csp -= n;                                                \
        frame_ip = (frame_csp - 1)->target_addr;                       \
        /* copy arity values of block */                               \
        frame_sp = (frame_csp - 1)->frame_sp;                          \
        cell_num_to_copy = (frame_csp - 1)->cell_num;                  \
        if (cell_num_to_copy > 0) {                                    \
            word_copy(frame_sp, frame_sp_old - cell_num_to_copy,       \
                      cell_num_to_copy);                               \
            frame_ref_copy(FRAME_REF(frame_sp),                        \
                           FRAME_REF(frame_sp_old - cell_num_to_copy), \
                           cell_num_to_copy);                          \
        }                                                              \
        frame_sp += cell_num_to_copy;                                  \
        CLEAR_FRAME_REF(frame_sp, frame_sp_old - frame_sp);            \
    } while (0)

/* Pop the given number of elements from the given frame's stack.  */
#define POP(N)                        \
    do {                              \
        int n = (N);                  \
        frame_sp -= n;                \
        CLEAR_FRAME_REF(frame_sp, n); \
    } while (0)

#if WASM_ENABLE_EXCE_HANDLING != 0
/* unwind the CSP to a given label and optionally modify the labeltype  */
#define UNWIND_CSP(N, T)                                                   \
    do {                                                                   \
        /* unwind to function frame  */                                    \
        frame_csp -= N;                                                    \
        /* drop handlers and values pushd in try block */                  \
        frame_sp = (frame_csp - 1)->frame_sp;                              \
        (frame_csp - 1)->label_type = T ? T : (frame_csp - 1)->label_type; \
    } while (0)
#endif

#define SYNC_ALL_TO_FRAME()     \
    do {                        \
        frame->sp = frame_sp;   \
        frame->ip = frame_ip;   \
        frame->csp = frame_csp; \
    } while (0)

#define UPDATE_ALL_FROM_FRAME() \
    do {                        \
        frame_sp = frame->sp;   \
        frame_ip = frame->ip;   \
        frame_csp = frame->csp; \
    } while (0)

#define read_leb_int64(p, p_end, res)                  \
    do {                                               \
        uint8 _val = *p;                               \
        if (!(_val & 0x80)) {                          \
            res = (int64)_val;                         \
            if (_val & 0x40)                           \
                /* sign extend */                      \
                res |= 0xFFFFFFFFFFFFFF80LL;           \
            p++;                                       \
        }                                              \
        else {                                         \
            uint32 _off = 0;                           \
            res = (int64)read_leb(p, &_off, 64, true); \
            p += _off;                                 \
        }                                              \
    } while (0)

#define read_leb_uint32(p, p_end, res)                   \
    do {                                                 \
        uint8 _val = *p;                                 \
        if (!(_val & 0x80)) {                            \
            res = _val;                                  \
            p++;                                         \
        }                                                \
        else {                                           \
            uint32 _off = 0;                             \
            res = (uint32)read_leb(p, &_off, 32, false); \
            p += _off;                                   \
        }                                                \
    } while (0)

#define read_leb_int32(p, p_end, res)                  \
    do {                                               \
        uint8 _val = *p;                               \
        if (!(_val & 0x80)) {                          \
            res = (int32)_val;                         \
            if (_val & 0x40)                           \
                /* sign extend */                      \
                res |= 0xFFFFFF80;                     \
            p++;                                       \
        }                                              \
        else {                                         \
            uint32 _off = 0;                           \
            res = (int32)read_leb(p, &_off, 32, true); \
            p += _off;                                 \
        }                                              \
    } while (0)

#if WASM_ENABLE_MEMORY64 != 0
#define read_leb_mem_offset(p, p_end, res)                                \
    do {                                                                  \
        uint8 _val = *p;                                                  \
        if (!(_val & 0x80)) {                                             \
            res = (mem_offset_t)_val;                                     \
            p++;                                                          \
        }                                                                 \
        else {                                                            \
            uint32 _off = 0;                                              \
            res = (mem_offset_t)read_leb(p, &_off, is_memory64 ? 64 : 32, \
                                         false);                          \
            p += _off;                                                    \
        }                                                                 \
    } while (0)
#else
#define read_leb_mem_offset(p, p_end, res) read_leb_uint32(p, p_end, res)
#endif

#if WASM_ENABLE_LABELS_AS_VALUES == 0
#define RECOVER_FRAME_IP_END() frame_ip_end = wasm_get_func_code_end(cur_func)
#else
#define RECOVER_FRAME_IP_END() (void)0
#endif

#if WASM_ENABLE_GC != 0
#define RECOVER_FRAME_REF() frame_ref = (uint8 *)frame->csp_boundary
#else
#define RECOVER_FRAME_REF() (void)0
#endif

#define RECOVER_CONTEXT(new_frame)      \
    do {                                \
        frame = (new_frame);            \
        cur_func = frame->function;     \
        prev_frame = frame->prev_frame; \
        frame_ip = frame->ip;           \
        RECOVER_FRAME_IP_END();         \
        frame_lp = frame->lp;           \
        frame_sp = frame->sp;           \
        frame_csp = frame->csp;         \
        RECOVER_FRAME_REF();            \
    } while (0)

#if WASM_ENABLE_LABELS_AS_VALUES != 0
#define GET_OPCODE() opcode = *(frame_ip - 1);
#else
#define GET_OPCODE() (void)0
#endif

#define DEF_OP_I_CONST(ctype, src_op_type)              \
    do {                                                \
        ctype cval;                                     \
        read_leb_##ctype(frame_ip, frame_ip_end, cval); \
        PUSH_##src_op_type(cval);                       \
    } while (0)

#define DEF_OP_EQZ(src_op_type)             \
    do {                                    \
        int32 pop_val;                      \
        pop_val = POP_##src_op_type() == 0; \
        PUSH_I32(pop_val);                  \
    } while (0)

#define DEF_OP_CMP(src_type, src_op_type, cond) \
    do {                                        \
        uint32 res;                             \
        src_type val1, val2;                    \
        val2 = (src_type)POP_##src_op_type();   \
        val1 = (src_type)POP_##src_op_type();   \
        res = val1 cond val2;                   \
        PUSH_I32(res);                          \
    } while (0)

#define DEF_OP_BIT_COUNT(src_type, src_op_type, operation) \
    do {                                                   \
        src_type val1, val2;                               \
        val1 = (src_type)POP_##src_op_type();              \
        val2 = (src_type)operation(val1);                  \
        PUSH_##src_op_type(val2);                          \
    } while (0)

#define DEF_OP_NUMERIC(src_type1, src_type2, src_op_type, operation)  \
    do {                                                              \
        frame_sp -= sizeof(src_type2) / sizeof(uint32);               \
        *(src_type1 *)(frame_sp - sizeof(src_type1) / sizeof(uint32)) \
            operation## = *(src_type2 *)(frame_sp);                   \
    } while (0)

#if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0
#define DEF_OP_NUMERIC_64 DEF_OP_NUMERIC
#else
#define DEF_OP_NUMERIC_64(src_type1, src_type2, src_op_type, operation) \
    do {                                                                \
        src_type1 val1;                                                 \
        src_type2 val2;                                                 \
        frame_sp -= 2;                                                  \
        val1 = (src_type1)GET_##src_op_type##_FROM_ADDR(frame_sp - 2);  \
        val2 = (src_type2)GET_##src_op_type##_FROM_ADDR(frame_sp);      \
        val1 operation## = val2;                                        \
        PUT_##src_op_type##_TO_ADDR(frame_sp - 2, val1);                \
    } while (0)
#endif

#define DEF_OP_NUMERIC2(src_type1, src_type2, src_op_type, operation) \
    do {                                                              \
        frame_sp -= sizeof(src_type2) / sizeof(uint32);               \
        *(src_type1 *)(frame_sp - sizeof(src_type1) / sizeof(uint32)) \
            operation## = (*(src_type2 *)(frame_sp) % 32);            \
    } while (0)

#define DEF_OP_NUMERIC2_64(src_type1, src_type2, src_op_type, operation) \
    do {                                                                 \
        src_type1 val1;                                                  \
        src_type2 val2;                                                  \
        frame_sp -= 2;                                                   \
        val1 = (src_type1)GET_##src_op_type##_FROM_ADDR(frame_sp - 2);   \
        val2 = (src_type2)GET_##src_op_type##_FROM_ADDR(frame_sp);       \
        val1 operation## = (val2 % 64);                                  \
        PUT_##src_op_type##_TO_ADDR(frame_sp - 2, val1);                 \
    } while (0)

#define DEF_OP_MATH(src_type, src_op_type, method) \
    do {                                           \
        src_type src_val;                          \
        src_val = POP_##src_op_type();             \
        PUSH_##src_op_type(method(src_val));       \
    } while (0)

#define TRUNC_FUNCTION(func_name, src_type, dst_type, signed_type)  \
    static dst_type func_name(src_type src_value, src_type src_min, \
                              src_type src_max, dst_type dst_min,   \
                              dst_type dst_max, bool is_sign)       \
    {                                                               \
        dst_type dst_value = 0;                                     \
        if (!isnan(src_value)) {                                    \
            if (src_value <= src_min)                               \
                dst_value = dst_min;                                \
            else if (src_value >= src_max)                          \
                dst_value = dst_max;                                \
            else {                                                  \
                if (is_sign)                                        \
                    dst_value = (dst_type)(signed_type)src_value;   \
                else                                                \
                    dst_value = (dst_type)src_value;                \
            }                                                       \
        }                                                           \
        return dst_value;                                           \
    }

TRUNC_FUNCTION(trunc_f32_to_i32, float32, uint32, int32)
TRUNC_FUNCTION(trunc_f32_to_i64, float32, uint64, int64)
TRUNC_FUNCTION(trunc_f64_to_i32, float64, uint32, int32)
TRUNC_FUNCTION(trunc_f64_to_i64, float64, uint64, int64)

static bool
trunc_f32_to_int(WASMModuleInstance *module, uint32 *frame_sp, float32 src_min,
                 float32 src_max, bool saturating, bool is_i32, bool is_sign)
{
    float32 src_value = POP_F32();
    uint64 dst_value_i64;
    uint32 dst_value_i32;

    if (!saturating) {
        if (isnan(src_value)) {
            wasm_set_exception(module, "invalid conversion to integer");
            return false;
        }
        else if (src_value <= src_min || src_value >= src_max) {
            wasm_set_exception(module, "integer overflow");
            return false;
        }
    }

    if (is_i32) {
        uint32 dst_min = is_sign ? INT32_MIN : 0;
        uint32 dst_max = is_sign ? INT32_MAX : UINT32_MAX;
        dst_value_i32 = trunc_f32_to_i32(src_value, src_min, src_max, dst_min,
                                         dst_max, is_sign);
        PUSH_I32(dst_value_i32);
    }
    else {
        uint64 dst_min = is_sign ? INT64_MIN : 0;
        uint64 dst_max = is_sign ? INT64_MAX : UINT64_MAX;
        dst_value_i64 = trunc_f32_to_i64(src_value, src_min, src_max, dst_min,
                                         dst_max, is_sign);
        PUSH_I64(dst_value_i64);
    }
    return true;
}

static bool
trunc_f64_to_int(WASMModuleInstance *module, uint32 *frame_sp, float64 src_min,
                 float64 src_max, bool saturating, bool is_i32, bool is_sign)
{
    float64 src_value = POP_F64();
    uint64 dst_value_i64;
    uint32 dst_value_i32;

    if (!saturating) {
        if (isnan(src_value)) {
            wasm_set_exception(module, "invalid conversion to integer");
            return false;
        }
        else if (src_value <= src_min || src_value >= src_max) {
            wasm_set_exception(module, "integer overflow");
            return false;
        }
    }

    if (is_i32) {
        uint32 dst_min = is_sign ? INT32_MIN : 0;
        uint32 dst_max = is_sign ? INT32_MAX : UINT32_MAX;
        dst_value_i32 = trunc_f64_to_i32(src_value, src_min, src_max, dst_min,
                                         dst_max, is_sign);
        PUSH_I32(dst_value_i32);
    }
    else {
        uint64 dst_min = is_sign ? INT64_MIN : 0;
        uint64 dst_max = is_sign ? INT64_MAX : UINT64_MAX;
        dst_value_i64 = trunc_f64_to_i64(src_value, src_min, src_max, dst_min,
                                         dst_max, is_sign);
        PUSH_I64(dst_value_i64);
    }
    return true;
}

#define DEF_OP_TRUNC_F32(min, max, is_i32, is_sign)                      \
    do {                                                                 \
        if (!trunc_f32_to_int(module, frame_sp, min, max, false, is_i32, \
                              is_sign))                                  \
            goto got_exception;                                          \
    } while (0)

#define DEF_OP_TRUNC_F64(min, max, is_i32, is_sign)                      \
    do {                                                                 \
        if (!trunc_f64_to_int(module, frame_sp, min, max, false, is_i32, \
                              is_sign))                                  \
            goto got_exception;                                          \
    } while (0)

#define DEF_OP_TRUNC_SAT_F32(min, max, is_i32, is_sign)                  \
    do {                                                                 \
        (void)trunc_f32_to_int(module, frame_sp, min, max, true, is_i32, \
                               is_sign);                                 \
    } while (0)

#define DEF_OP_TRUNC_SAT_F64(min, max, is_i32, is_sign)                  \
    do {                                                                 \
        (void)trunc_f64_to_int(module, frame_sp, min, max, true, is_i32, \
                               is_sign);                                 \
    } while (0)

#define DEF_OP_CONVERT(dst_type, dst_op_type, src_type, src_op_type) \
    do {                                                             \
        dst_type value = (dst_type)(src_type)POP_##src_op_type();    \
        PUSH_##dst_op_type(value);                                   \
    } while (0)

#define GET_LOCAL_INDEX_TYPE_AND_OFFSET()                                \
    do {                                                                 \
        uint32 param_count = cur_func->param_count;                      \
        read_leb_uint32(frame_ip, frame_ip_end, local_idx);              \
        bh_assert(local_idx < param_count + cur_func->local_count);      \
        local_offset = cur_func->local_offsets[local_idx];               \
        if (local_idx < param_count)                                     \
            local_type = cur_func->param_types[local_idx];               \
        else                                                             \
            local_type = cur_func->local_types[local_idx - param_count]; \
    } while (0)

#define DEF_ATOMIC_RMW_OPCODE(OP_NAME, op)                           \
    case WASM_OP_ATOMIC_RMW_I32_##OP_NAME:                           \
    case WASM_OP_ATOMIC_RMW_I32_##OP_NAME##8_U:                      \
    case WASM_OP_ATOMIC_RMW_I32_##OP_NAME##16_U:                     \
    {                                                                \
        uint32 readv, sval;                                          \
                                                                     \
        sval = POP_I32();                                            \
        addr = POP_MEM_OFFSET();                                     \
                                                                     \
        if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##8_U) {       \
            CHECK_MEMORY_OVERFLOW(1);                                \
            CHECK_ATOMIC_MEMORY_ACCESS();                            \
                                                                     \
            shared_memory_lock(memory);                              \
            readv = (uint32)(*(uint8 *)maddr);                       \
            *(uint8 *)maddr = (uint8)(readv op sval);                \
            shared_memory_unlock(memory);                            \
        }                                                            \
        else if (opcode == WASM_OP_ATOMIC_RMW_I32_##OP_NAME##16_U) { \
            CHECK_MEMORY_OVERFLOW(2);                                \
            CHECK_ATOMIC_MEMORY_ACCESS();                            \
                                                                     \
            shared_memory_lock(memory);                              \
            readv = (uint32)LOAD_U16(maddr);                         \
            STORE_U16(maddr, (uint16)(readv op sval));               \
            shared_memory_unlock(memory);                            \
        }                                                            \
        else {                                                       \
            CHECK_MEMORY_OVERFLOW(4);                                \
            CHECK_ATOMIC_MEMORY_ACCESS();                            \
                                                                     \
            shared_memory_lock(memory);                              \
            readv = LOAD_I32(maddr);                                 \
            STORE_U32(maddr, readv op sval);                         \
            shared_memory_unlock(memory);                            \
        }                                                            \
        PUSH_I32(readv);                                             \
        break;                                                       \
    }                                                                \
    case WASM_OP_ATOMIC_RMW_I64_##OP_NAME:                           \
    case WASM_OP_ATOMIC_RMW_I64_##OP_NAME##8_U:                      \
    case WASM_OP_ATOMIC_RMW_I64_##OP_NAME##16_U:                     \
    case WASM_OP_ATOMIC_RMW_I64_##OP_NAME##32_U:                     \
    {                                                                \
        uint64 readv, sval;                                          \
                                                                     \
        sval = (uint64)POP_I64();                                    \
        addr = POP_MEM_OFFSET();                                     \
                                                                     \
        if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##8_U) {       \
            CHECK_MEMORY_OVERFLOW(1);                                \
            CHECK_ATOMIC_MEMORY_ACCESS();                            \
                                                                     \
            shared_memory_lock(memory);                              \
            readv = (uint64)(*(uint8 *)maddr);                       \
            *(uint8 *)maddr = (uint8)(readv op sval);                \
            shared_memory_unlock(memory);                            \
        }                                                            \
        else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##16_U) { \
            CHECK_MEMORY_OVERFLOW(2);                                \
            CHECK_ATOMIC_MEMORY_ACCESS();                            \
                                                                     \
            shared_memory_lock(memory);                              \
            readv = (uint64)LOAD_U16(maddr);                         \
            STORE_U16(maddr, (uint16)(readv op sval));               \
            shared_memory_unlock(memory);                            \
        }                                                            \
        else if (opcode == WASM_OP_ATOMIC_RMW_I64_##OP_NAME##32_U) { \
            CHECK_MEMORY_OVERFLOW(4);                                \
            CHECK_ATOMIC_MEMORY_ACCESS();                            \
                                                                     \
            shared_memory_lock(memory);                              \
            readv = (uint64)LOAD_U32(maddr);                         \
            STORE_U32(maddr, (uint32)(readv op sval));               \
            shared_memory_unlock(memory);                            \
        }                                                            \
        else {                                                       \
            uint64 op_result;                                        \
            CHECK_MEMORY_OVERFLOW(8);                                \
            CHECK_ATOMIC_MEMORY_ACCESS();                            \
                                                                     \
            shared_memory_lock(memory);                              \
            readv = (uint64)LOAD_I64(maddr);                         \
            op_result = readv op sval;                               \
            STORE_I64(maddr, op_result);                             \
            shared_memory_unlock(memory);                            \
        }                                                            \
        PUSH_I64(readv);                                             \
        break;                                                       \
    }

static inline int32
sign_ext_8_32(int8 val)
{
    if (val & 0x80)
        return (int32)val | (int32)0xffffff00;
    return val;
}

static inline int32
sign_ext_16_32(int16 val)
{
    if (val & 0x8000)
        return (int32)val | (int32)0xffff0000;
    return val;
}

static inline int64
sign_ext_8_64(int8 val)
{
    if (val & 0x80)
        return (int64)val | (int64)0xffffffffffffff00LL;
    return val;
}

static inline int64
sign_ext_16_64(int16 val)
{
    if (val & 0x8000)
        return (int64)val | (int64)0xffffffffffff0000LL;
    return val;
}

static inline int64
sign_ext_32_64(int32 val)
{
    if (val & (int32)0x80000000)
        return (int64)val | (int64)0xffffffff00000000LL;
    return val;
}

static inline void
word_copy(uint32 *dest, uint32 *src, unsigned num)
{
    bh_assert(dest != NULL);
    bh_assert(src != NULL);
    bh_assert(num > 0);
    if (dest != src) {
        /* No overlap buffer */
        bh_assert(!((src < dest) && (dest < src + num)));
        for (; num > 0; num--)
            *dest++ = *src++;
    }
}

#if WASM_ENABLE_GC != 0
static inline void
frame_ref_copy(uint8 *frame_ref_dest, uint8 *frame_ref_src, unsigned num)
{
    if (frame_ref_dest != frame_ref_src)
        for (; num > 0; num--)
            *frame_ref_dest++ = *frame_ref_src++;
}
#else
#define frame_ref_copy(frame_ref_dst, frame_ref_src, num) (void)0
#endif

static inline WASMInterpFrame *
ALLOC_FRAME(WASMExecEnv *exec_env, uint32 size, WASMInterpFrame *prev_frame)
{
    WASMInterpFrame *frame = wasm_exec_env_alloc_wasm_frame(exec_env, size);

    if (frame) {
        frame->prev_frame = prev_frame;
#if WASM_ENABLE_PERF_PROFILING != 0
        frame->time_started = os_time_thread_cputime_us();
#endif
    }
    else {
        wasm_set_exception((WASMModuleInstance *)exec_env->module_inst,
                           "wasm operand stack overflow");
    }

    return frame;
}

static inline void
FREE_FRAME(WASMExecEnv *exec_env, WASMInterpFrame *frame)
{
#if WASM_ENABLE_PERF_PROFILING != 0
    if (frame->function) {
        WASMInterpFrame *prev_frame = frame->prev_frame;
        uint64 time_elapsed = os_time_thread_cputime_us() - frame->time_started;

        frame->function->total_exec_time += time_elapsed;
        frame->function->total_exec_cnt++;

        if (prev_frame && prev_frame->function)
            prev_frame->function->children_exec_time += time_elapsed;
    }
#endif
    wasm_exec_env_free_wasm_frame(exec_env, frame);
}

static void
wasm_interp_call_func_native(WASMModuleInstance *module_inst,
                             WASMExecEnv *exec_env,
                             WASMFunctionInstance *cur_func,
                             WASMInterpFrame *prev_frame)
{
    WASMFunctionImport *func_import = cur_func->u.func_import;
    CApiFuncImport *c_api_func_import = NULL;
    unsigned local_cell_num =
        cur_func->param_cell_num > 2 ? cur_func->param_cell_num : 2;
    unsigned all_cell_num;
    WASMInterpFrame *frame;
    uint32 argv_ret[2], cur_func_index;
    void *native_func_pointer = NULL;
    char buf[128];
    bool ret;
#if WASM_ENABLE_GC != 0
    WASMFuncType *func_type;
    uint8 *frame_ref;
#endif

    if (!wasm_runtime_detect_native_stack_overflow(exec_env)) {
        return;
    }

    all_cell_num = local_cell_num;
#if WASM_ENABLE_GC != 0
    all_cell_num += (local_cell_num + 3) / 4;
#endif

    if (!(frame =
              ALLOC_FRAME(exec_env, wasm_interp_interp_frame_size(all_cell_num),
                          prev_frame)))
        return;

    frame->function = cur_func;
    frame->ip = NULL;
    frame->sp = frame->lp + local_cell_num;
#if WASM_ENABLE_GC != 0
    /* native function doesn't have operand stack and label stack */
    frame_ref = (uint8 *)frame->sp;
    init_frame_refs(frame_ref, local_cell_num, cur_func);
#endif

    wasm_exec_env_set_cur_frame(exec_env, frame);

    cur_func_index = (uint32)(cur_func - module_inst->e->functions);
    bh_assert(cur_func_index < module_inst->module->import_function_count);
    if (!func_import->call_conv_wasm_c_api) {
        native_func_pointer = module_inst->import_func_ptrs[cur_func_index];
    }
    else if (module_inst->c_api_func_imports) {
        c_api_func_import = module_inst->c_api_func_imports + cur_func_index;
        native_func_pointer = c_api_func_import->func_ptr_linked;
    }

    if (!native_func_pointer) {
        snprintf(buf, sizeof(buf),
                 "failed to call unlinked import function (%s, %s)",
                 func_import->module_name, func_import->field_name);
        wasm_set_exception(module_inst, buf);
        return;
    }

    if (func_import->call_conv_wasm_c_api) {
        ret = wasm_runtime_invoke_c_api_native(
            (WASMModuleInstanceCommon *)module_inst, native_func_pointer,
            func_import->func_type, cur_func->param_cell_num, frame->lp,
            c_api_func_import->with_env_arg, c_api_func_import->env_arg);
        if (ret) {
            argv_ret[0] = frame->lp[0];
            argv_ret[1] = frame->lp[1];
        }
    }
    else if (!func_import->call_conv_raw) {
        ret = wasm_runtime_invoke_native(
            exec_env, native_func_pointer, func_import->func_type,
            func_import->signature, func_import->attachment, frame->lp,
            cur_func->param_cell_num, argv_ret);
    }
    else {
        ret = wasm_runtime_invoke_native_raw(
            exec_env, native_func_pointer, func_import->func_type,
            func_import->signature, func_import->attachment, frame->lp,
            cur_func->param_cell_num, argv_ret);
    }

    if (!ret)
        return;

#if WASM_ENABLE_GC != 0
    func_type = cur_func->u.func_import->func_type;
    if (func_type->result_count
        && wasm_is_type_reftype(func_type->types[cur_func->param_count])) {
        frame_ref = (uint8 *)prev_frame->csp_boundary
                    + (unsigned)(uintptr_t)(prev_frame->sp - prev_frame->lp);
        if (!wasm_is_reftype_i31ref(func_type->types[cur_func->param_count])) {
#if UINTPTR_MAX == UINT64_MAX
            *frame_ref = *(frame_ref + 1) = 1;
#else
            *frame_ref = 1;
#endif
        }
    }
#endif

    if (cur_func->ret_cell_num == 1) {
        prev_frame->sp[0] = argv_ret[0];
        prev_frame->sp++;
    }
    else if (cur_func->ret_cell_num == 2) {
        prev_frame->sp[0] = argv_ret[0];
        prev_frame->sp[1] = argv_ret[1];
        prev_frame->sp += 2;
    }

    FREE_FRAME(exec_env, frame);
    wasm_exec_env_set_cur_frame(exec_env, prev_frame);
}

#if WASM_ENABLE_FAST_JIT != 0
bool
fast_jit_invoke_native(WASMExecEnv *exec_env, uint32 func_idx,
                       WASMInterpFrame *prev_frame)
{
    WASMModuleInstance *module_inst =
        (WASMModuleInstance *)exec_env->module_inst;
    WASMFunctionInstance *cur_func = module_inst->e->functions + func_idx;

    wasm_interp_call_func_native(module_inst, exec_env, cur_func, prev_frame);
    return wasm_copy_exception(module_inst, NULL) ? false : true;
}
#endif

#if WASM_ENABLE_MULTI_MODULE != 0
static void
wasm_interp_call_func_bytecode(WASMModuleInstance *module,
                               WASMExecEnv *exec_env,
                               WASMFunctionInstance *cur_func,
                               WASMInterpFrame *prev_frame);

static void
wasm_interp_call_func_import(WASMModuleInstance *module_inst,
                             WASMExecEnv *exec_env,
                             WASMFunctionInstance *cur_func,
                             WASMInterpFrame *prev_frame)
{
    WASMModuleInstance *sub_module_inst = cur_func->import_module_inst;
    WASMFunctionInstance *sub_func_inst = cur_func->import_func_inst;
    WASMFunctionImport *func_import = cur_func->u.func_import;
    uint8 *ip = prev_frame->ip;
    char buf[128];
    WASMExecEnv *sub_module_exec_env = NULL;
    uintptr_t aux_stack_origin_boundary = 0;
    uintptr_t aux_stack_origin_bottom = 0;

    /*
     * perform stack overflow check before calling
     * wasm_interp_call_func_bytecode recursively.
     */
    if (!wasm_runtime_detect_native_stack_overflow(exec_env)) {
        return;
    }

    if (!sub_func_inst) {
        snprintf(buf, sizeof(buf),
                 "failed to call unlinked import function (%s, %s)",
                 func_import->module_name, func_import->field_name);
        wasm_set_exception(module_inst, buf);
        return;
    }

    /* Switch exec_env but keep using the same one by replacing necessary
     * variables */
    sub_module_exec_env = wasm_runtime_get_exec_env_singleton(
        (WASMModuleInstanceCommon *)sub_module_inst);
    if (!sub_module_exec_env) {
        wasm_set_exception(module_inst, "create singleton exec_env failed");
        return;
    }

    /* - module_inst */
    wasm_exec_env_set_module_inst(exec_env,
                                  (WASMModuleInstanceCommon *)sub_module_inst);
    /* - aux_stack_boundary */
    aux_stack_origin_boundary = exec_env->aux_stack_boundary;
    exec_env->aux_stack_boundary = sub_module_exec_env->aux_stack_boundary;
    /* - aux_stack_bottom */
    aux_stack_origin_bottom = exec_env->aux_stack_bottom;
    exec_env->aux_stack_bottom = sub_module_exec_env->aux_stack_bottom;

    /* set ip NULL to make call_func_bytecode return after executing
       this function */
    prev_frame->ip = NULL;

    /* call function of sub-module*/
    wasm_interp_call_func_bytecode(sub_module_inst, exec_env, sub_func_inst,
                                   prev_frame);

    /* restore ip and other replaced */
    prev_frame->ip = ip;
    exec_env->aux_stack_boundary = aux_stack_origin_boundary;
    exec_env->aux_stack_bottom = aux_stack_origin_bottom;
    wasm_exec_env_restore_module_inst(exec_env,
                                      (WASMModuleInstanceCommon *)module_inst);
}
#endif

#if WASM_ENABLE_THREAD_MGR != 0
#if WASM_ENABLE_DEBUG_INTERP != 0
#define CHECK_SUSPEND_FLAGS()                                          \
    do {                                                               \
        os_mutex_lock(&exec_env->wait_lock);                           \
        if (IS_WAMR_TERM_SIG(exec_env->current_status->signal_flag)) { \
            os_mutex_unlock(&exec_env->wait_lock);                     \
            return;                                                    \
        }                                                              \
        if (IS_WAMR_STOP_SIG(exec_env->current_status->signal_flag)) { \
            SYNC_ALL_TO_FRAME();                                       \
            wasm_cluster_thread_waiting_run(exec_env);                 \
        }                                                              \
        os_mutex_unlock(&exec_env->wait_lock);                         \
    } while (0)
#else
#if WASM_SUSPEND_FLAGS_IS_ATOMIC != 0
/* The lock is only needed when the suspend_flags is atomic; otherwise
   the lock is already taken at the time when SUSPENSION_LOCK() is called. */
#define SUSPENSION_LOCK() os_mutex_lock(&exec_env->wait_lock);
#define SUSPENSION_UNLOCK() os_mutex_unlock(&exec_env->wait_lock);
#else
#define SUSPENSION_LOCK()
#define SUSPENSION_UNLOCK()
#endif

#define CHECK_SUSPEND_FLAGS()                                         \
    do {                                                              \
        WASM_SUSPEND_FLAGS_LOCK(exec_env->wait_lock);                 \
        if (WASM_SUSPEND_FLAGS_GET(exec_env->suspend_flags)           \
            & WASM_SUSPEND_FLAG_TERMINATE) {                          \
            /* terminate current thread */                            \
            WASM_SUSPEND_FLAGS_UNLOCK(exec_env->wait_lock);           \
            return;                                                   \
        }                                                             \
        while (WASM_SUSPEND_FLAGS_GET(exec_env->suspend_flags)        \
               & WASM_SUSPEND_FLAG_SUSPEND) {                         \
            /* suspend current thread */                              \
            SUSPENSION_LOCK()                                         \
            os_cond_wait(&exec_env->wait_cond, &exec_env->wait_lock); \
            SUSPENSION_UNLOCK()                                       \
        }                                                             \
        WASM_SUSPEND_FLAGS_UNLOCK(exec_env->wait_lock);               \
    } while (0)
#endif /* WASM_ENABLE_DEBUG_INTERP */
#endif /* WASM_ENABLE_THREAD_MGR */

#if WASM_ENABLE_LABELS_AS_VALUES != 0

#define HANDLE_OP(opcode) HANDLE_##opcode:
#define FETCH_OPCODE_AND_DISPATCH() goto *handle_table[*frame_ip++]

#if WASM_ENABLE_THREAD_MGR != 0 && WASM_ENABLE_DEBUG_INTERP != 0
#define HANDLE_OP_END()                                                   \
    do {                                                                  \
        /* Record the current frame_ip, so when exception occurs,         \
           debugger can know the exact opcode who caused the exception */ \
        frame_ip_orig = frame_ip;                                         \
        os_mutex_lock(&exec_env->wait_lock);                              \
        while (exec_env->current_status->signal_flag == WAMR_SIG_SINGSTEP \
               && exec_env->current_status->step_count++ == 1) {          \
            exec_env->current_status->step_count = 0;                     \
            SYNC_ALL_TO_FRAME();                                          \
            wasm_cluster_thread_waiting_run(exec_env);                    \
        }                                                                 \
        os_mutex_unlock(&exec_env->wait_lock);                            \
        goto *handle_table[*frame_ip++];                                  \
    } while (0)
#else
#define HANDLE_OP_END() FETCH_OPCODE_AND_DISPATCH()
#endif

#else /* else of WASM_ENABLE_LABELS_AS_VALUES */
#define HANDLE_OP(opcode) case opcode:
#if WASM_ENABLE_THREAD_MGR != 0 && WASM_ENABLE_DEBUG_INTERP != 0
#define HANDLE_OP_END()                                            \
    os_mutex_lock(&exec_env->wait_lock);                           \
    if (exec_env->current_status->signal_flag == WAMR_SIG_SINGSTEP \
        && exec_env->current_status->step_count++ == 2) {          \
        exec_env->current_status->step_count = 0;                  \
        SYNC_ALL_TO_FRAME();                                       \
        wasm_cluster_thread_waiting_run(exec_env);                 \
    }                                                              \
    os_mutex_unlock(&exec_env->wait_lock);                         \
    continue
#else
#define HANDLE_OP_END() continue
#endif

#endif /* end of WASM_ENABLE_LABELS_AS_VALUES */

static inline uint8 *
get_global_addr(uint8 *global_data, WASMGlobalInstance *global)
{
#if WASM_ENABLE_MULTI_MODULE == 0
    return global_data + global->data_offset;
#else
    return global->import_global_inst
               ? global->import_module_inst->global_data
                     + global->import_global_inst->data_offset
               : global_data + global->data_offset;
#endif
}

static void
wasm_interp_call_func_bytecode(WASMModuleInstance *module,
                               WASMExecEnv *exec_env,
                               WASMFunctionInstance *cur_func,
                               WASMInterpFrame *prev_frame)
{
    WASMMemoryInstance *memory = wasm_get_default_memory(module);
#if !defined(OS_ENABLE_HW_BOUND_CHECK)              \
    || WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0 \
    || WASM_ENABLE_BULK_MEMORY != 0
    uint64 linear_mem_size = 0;
    if (memory)
#if WASM_ENABLE_THREAD_MGR == 0
        linear_mem_size = memory->memory_data_size;
#else
        linear_mem_size = GET_LINEAR_MEMORY_SIZE(memory);
#endif
#endif
    WASMFuncType **wasm_types = (WASMFuncType **)module->module->types;
    WASMGlobalInstance *globals = module->e->globals, *global;
    uint8 *global_data = module->global_data;
    uint8 opcode_IMPDEP = WASM_OP_IMPDEP;
    WASMInterpFrame *frame = NULL;
    /* Points to this special opcode so as to jump to the
     * call_method_from_entry.  */
    register uint8 *frame_ip = &opcode_IMPDEP; /* cache of frame->ip */
    register uint32 *frame_lp = NULL;          /* cache of frame->lp */
    register uint32 *frame_sp = NULL;          /* cache of frame->sp */
#if WASM_ENABLE_GC != 0
    register uint8 *frame_ref = NULL; /* cache of frame->ref */
    uint8 *frame_ref_tmp;
#endif
    WASMBranchBlock *frame_csp = NULL;
    BlockAddr *cache_items;
    uint8 *frame_ip_end = frame_ip + 1;
    uint8 opcode;
    uint32 i, depth, cond, count, fidx, tidx, lidx, frame_size = 0;
    uint32 all_cell_num = 0;
    int32 val;
    uint8 *else_addr, *end_addr, *maddr = NULL;
    uint32 local_idx, local_offset, global_idx;
    uint8 local_type, *global_addr;
    uint32 cache_index, type_index, param_cell_num, cell_num;
#if WASM_ENABLE_EXCE_HANDLING != 0
    int32_t exception_tag_index;
#endif
    uint8 value_type;
#if !defined(OS_ENABLE_HW_BOUND_CHECK) \
    || WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0
#if WASM_CONFIGURABLE_BOUNDS_CHECKS != 0
    bool disable_bounds_checks = !wasm_runtime_is_bounds_checks_enabled(
        (WASMModuleInstanceCommon *)module);
#else
    bool disable_bounds_checks = false;
#endif
#endif
#if WASM_ENABLE_GC != 0
    WASMObjectRef gc_obj;
    WASMStructObjectRef struct_obj;
    WASMArrayObjectRef array_obj;
    WASMFuncObjectRef func_obj;
    WASMI31ObjectRef i31_obj;
    WASMExternrefObjectRef externref_obj;
#if WASM_ENABLE_STRINGREF != 0
    WASMString str_obj = NULL;
    WASMStringrefObjectRef stringref_obj;
    WASMStringviewWTF8ObjectRef stringview_wtf8_obj;
    WASMStringviewWTF16ObjectRef stringview_wtf16_obj;
    WASMStringviewIterObjectRef stringview_iter_obj;
#endif
#endif
#if WASM_ENABLE_TAIL_CALL != 0 || WASM_ENABLE_GC != 0
    bool is_return_call = false;
#endif
#if WASM_ENABLE_MEMORY64 != 0
    /* TODO: multi-memories for now assuming the memory idx type is consistent
     * across multi-memories */
    bool is_memory64 = false;
    if (memory)
        is_memory64 = memory->is_memory64;
#endif

#if WASM_ENABLE_DEBUG_INTERP != 0
    uint8 *frame_ip_orig = NULL;
    WASMDebugInstance *debug_instance = wasm_exec_env_get_instance(exec_env);
    bh_list *watch_point_list_read =
        debug_instance ? &debug_instance->watch_point_list_read : NULL;
    bh_list *watch_point_list_write =
        debug_instance ? &debug_instance->watch_point_list_write : NULL;
#endif

#if WASM_ENABLE_LABELS_AS_VALUES != 0
#define HANDLE_OPCODE(op) &&HANDLE_##op
    DEFINE_GOTO_TABLE(const void *, handle_table);
#undef HANDLE_OPCODE
#endif

#if WASM_ENABLE_LABELS_AS_VALUES == 0
    while (frame_ip < frame_ip_end) {
        opcode = *frame_ip++;
        switch (opcode) {
#else
    FETCH_OPCODE_AND_DISPATCH();
#endif
            /* control instructions */
            HANDLE_OP(WASM_OP_UNREACHABLE)
            {
                wasm_set_exception(module, "unreachable");
                goto got_exception;
            }

            HANDLE_OP(WASM_OP_NOP) { HANDLE_OP_END(); }

#if WASM_ENABLE_EXCE_HANDLING != 0
            HANDLE_OP(WASM_OP_RETHROW)
            {
                int32_t relative_depth;
                read_leb_int32(frame_ip, frame_ip_end, relative_depth);

                /* No frame found with exception handler; validation should
                 * catch it */
                bh_assert(frame_csp >= frame->csp_bottom + relative_depth);

                /* go up the frame stack */
                WASMBranchBlock *tgtframe = (frame_csp - 1) - relative_depth;

                bh_assert(tgtframe->label_type == LABEL_TYPE_CATCH
                          || tgtframe->label_type == LABEL_TYPE_CATCH_ALL);

                /* tgtframe points to the frame containing a thrown
                 * exception */

                uint32 *tgtframe_sp = tgtframe->frame_sp;

                /* frame sp of tgtframe points to catched exception */
                exception_tag_index = *((uint32 *)tgtframe_sp);
                tgtframe_sp++;

                /* get tag type */
                uint8 tag_type_index =
                    module->module->tags[exception_tag_index]->type;
                uint32 cell_num_to_copy =
                    wasm_types[tag_type_index]->param_cell_num;

                /* move exception parameters (if there are any) onto top
                 * of stack */
                if (cell_num_to_copy > 0) {
                    word_copy(frame_sp, tgtframe_sp - cell_num_to_copy,
                              cell_num_to_copy);
                }

                frame_sp += cell_num_to_copy;
                goto find_a_catch_handler;
            }

            HANDLE_OP(WASM_OP_THROW)
            {
                read_leb_int32(frame_ip, frame_ip_end, exception_tag_index);

            /* landing pad for the rethrow ? */
            find_a_catch_handler:
            {
                WASMType *tag_type = NULL;
                uint32 cell_num_to_copy = 0;
                if (IS_INVALID_TAGINDEX(exception_tag_index)) {
                    /*
                     * invalid exception index,
                     * generated if a submodule throws an exception
                     * that has not been imported here
                     *
                     * This should result in a branch to the CATCH_ALL block,
                     * if there is one
                     */
                    tag_type = NULL;
                    cell_num_to_copy = 0;
                }
                else {
                    if (module->e->tags[exception_tag_index].is_import_tag) {
                        tag_type = module->e->tags[exception_tag_index]
                                       .u.tag_import->tag_type;
                    }
                    else {
                        tag_type = module->e->tags[exception_tag_index]
                                       .u.tag->tag_type;
                    }
                    cell_num_to_copy = tag_type->param_cell_num;
                }

                /* browse through frame stack */
                uint32 relative_depth = 0;
                do {
                    POP_CSP_CHECK_OVERFLOW(relative_depth - 1);
                    WASMBranchBlock *tgtframe = frame_csp - relative_depth - 1;

                    switch (tgtframe->label_type) {
                        case LABEL_TYPE_BLOCK:
                        case LABEL_TYPE_IF:
                        case LABEL_TYPE_LOOP:
                        case LABEL_TYPE_CATCH:
                        case LABEL_TYPE_CATCH_ALL:
                            /*
                             * skip that blocks in search
                             * BLOCK, IF and LOOP do not contain handlers and
                             * cannot catch exceptions.
                             * blocks marked as CATCH or
                             * CATCH_ALL did already caugth an exception and can
                             * only be a target for RETHROW, but cannot catch an
                             * exception again
                             */
                            break;
                        case LABEL_TYPE_TRY:
                        {
                            uint32 handler_number = 0;
                            uint8 **handlers = (uint8 **)tgtframe->frame_sp;
                            uint8 *handler = NULL;
                            while ((handler = handlers[handler_number]) != 0) {
                                uint8 handler_opcode = *handler;
                                uint8 *target_addr =
                                    handler
                                    + 1; /* first instruction or leb-immediate
                                            behind the handler opcode */
                                switch (handler_opcode) {
                                    case WASM_OP_CATCH:
                                    {
                                        int32 lookup_index = 0;
                                        /* read the tag_index and advance
                                         * target_addr to the first instruction
                                         * in the block */
                                        read_leb_int32(target_addr, 0,
                                                       lookup_index);

                                        if (exception_tag_index
                                            == lookup_index) {
                                            /* set ip */
                                            frame_ip = target_addr;
                                            /* save frame_sp (points to
                                             * exception values) */
                                            uint32 *frame_sp_old = frame_sp;

                                            UNWIND_CSP(relative_depth,
                                                       LABEL_TYPE_CATCH);

                                            /* push exception_tag_index and
                                             * exception values for rethrow */
                                            PUSH_I32(exception_tag_index);
                                            if (cell_num_to_copy > 0) {
                                                word_copy(
                                                    frame_sp,
                                                    frame_sp_old
                                                        - cell_num_to_copy,
                                                    cell_num_to_copy);
                                                frame_sp += cell_num_to_copy;
                                                /* push exception values for
                                                 * catch
                                                 */
                                                word_copy(
                                                    frame_sp,
                                                    frame_sp_old
                                                        - cell_num_to_copy,
                                                    cell_num_to_copy);
                                                frame_sp += cell_num_to_copy;
                                            }

                                            /* advance to handler */
                                            HANDLE_OP_END();
                                        }
                                        break;
                                    }
                                    case WASM_OP_DELEGATE:
                                    {
                                        int32 lookup_depth = 0;
                                        /* read the depth */
                                        read_leb_int32(target_addr, 0,
                                                       lookup_depth);

                                        /* save frame_sp (points to exception
                                         * values) */
                                        uint32 *frame_sp_old = frame_sp;

                                        UNWIND_CSP(relative_depth,
                                                   LABEL_TYPE_CATCH);

                                        /* leave the block (the delegate is
                                         * technically not inside the frame) */
                                        frame_csp--;

                                        /* unwind to delegated frame */
                                        frame_csp -= lookup_depth;

                                        /* push exception values for catch */
                                        if (cell_num_to_copy > 0) {
                                            word_copy(frame_sp,
                                                      frame_sp_old
                                                          - cell_num_to_copy,
                                                      cell_num_to_copy);
                                            frame_sp += cell_num_to_copy;
                                        }

                                        /* tag_index is already stored in
                                         * exception_tag_index */
                                        goto find_a_catch_handler;
                                    }
                                    case WASM_OP_CATCH_ALL:
                                    {
                                        /* no immediate */
                                        /* save frame_sp (points to exception
                                         * values) */
                                        uint32 *frame_sp_old = frame_sp;
                                        /* set ip */
                                        frame_ip = target_addr;

                                        UNWIND_CSP(relative_depth,
                                                   LABEL_TYPE_CATCH_ALL);

                                        /* push exception_tag_index and
                                         * exception values for rethrow */
                                        PUSH_I32(exception_tag_index);
                                        if (cell_num_to_copy > 0) {
                                            word_copy(frame_sp,
                                                      frame_sp_old
                                                          - cell_num_to_copy,
                                                      cell_num_to_copy);
                                            frame_sp += cell_num_to_copy;
                                        }
                                        /* catch_all has no exception values */

                                        /* advance to handler */
                                        HANDLE_OP_END();
                                    }
                                    default:
                                        wasm_set_exception(
                                            module, "WASM_OP_THROW found "
                                                    "unexpected handler type");
                                        goto got_exception;
                                }
                                handler_number++;
                            }
                            /* exception not catched in this frame */
                            break;
                        }
                        case LABEL_TYPE_FUNCTION:
                        {
                            /* save frame_sp (points to exception values) */
                            uint32 *frame_sp_old = frame_sp;

                            UNWIND_CSP(relative_depth, LABEL_TYPE_FUNCTION);
                            /* push exception values for catch
                             * The values are copied to the CALLER FRAME
                             * (prev_frame->sp) same behvior ad WASM_OP_RETURN
                             */
                            if (cell_num_to_copy > 0) {
                                word_copy(prev_frame->sp,
                                          frame_sp_old - cell_num_to_copy,
                                          cell_num_to_copy);
                                prev_frame->sp += cell_num_to_copy;
                            }
                            *((int32 *)(prev_frame->sp)) = exception_tag_index;
                            prev_frame->sp++;

                            /* mark frame as raised exception */
                            wasm_set_exception(module,
                                               "uncaught wasm exception");

                            /* end of function, treat as WASM_OP_RETURN */
                            goto return_func;
                        }
                        default:
                            wasm_set_exception(
                                module,
                                "unexpected or invalid label in THROW or "
                                "RETHROW when searching a catch handler");
                            goto got_exception;
                    }

                    relative_depth++;

                } while (1);
            }

                /* something went wrong. normally, we should always find the
                 * func label. if not, stop the interpreter */
                wasm_set_exception(
                    module, "WASM_OP_THROW hit the bottom of the frame stack");
                goto got_exception;
            }

            HANDLE_OP(EXT_OP_TRY)
            {
                /* read the blocktype */
                read_leb_uint32(frame_ip, frame_ip_end, type_index);
                param_cell_num = wasm_types[type_index]->param_cell_num;
                cell_num = wasm_types[type_index]->ret_cell_num;
                goto handle_op_try;
            }

            HANDLE_OP(WASM_OP_TRY)
            {
                value_type = *frame_ip++;
                param_cell_num = 0;
                cell_num = wasm_value_type_cell_num(value_type);

            handle_op_try:

                cache_index = ((uintptr_t)frame_ip)
                              & (uintptr_t)(BLOCK_ADDR_CACHE_SIZE - 1);
                cache_items = exec_env->block_addr_cache[cache_index];
                if (cache_items[0].start_addr == frame_ip) {
                    cache_items[0].start_addr = 0;
                }
                if (cache_items[1].start_addr == frame_ip) {
                    cache_items[1].start_addr = 0;
                }

                /* start at the first opcode following the try and its blocktype
                 */
                uint8 *lookup_cursor = frame_ip;
                uint8 handler_opcode = WASM_OP_UNREACHABLE;

                /* target_addr filled in when END or DELEGATE is found */
                PUSH_CSP(LABEL_TYPE_TRY, param_cell_num, cell_num, 0);

                /* reset to begin of block */
                lookup_cursor = frame_ip;
                do {
                    /* lookup the next CATCH, CATCH_ALL or END for this TRY */
                    if (!wasm_loader_find_block_addr(
                            exec_env, (BlockAddr *)exec_env->block_addr_cache,
                            lookup_cursor, (uint8 *)-1, LABEL_TYPE_TRY,
                            &else_addr, &end_addr)) {
                        /* something went wrong */
                        wasm_set_exception(module, "find block address failed");
                        goto got_exception;
                    }

                    /* place cursor for continuation past opcode */
                    lookup_cursor = end_addr + 1;

                    /* end_addr points to CATCH, CATCH_ALL, DELEGATE or END */
                    handler_opcode = *end_addr;
                    switch (handler_opcode) {
                        case WASM_OP_CATCH:
                            skip_leb(lookup_cursor); /* skip tag_index */
                            PUSH_I64(end_addr);
                            break;
                        case WASM_OP_CATCH_ALL:
                            PUSH_I64(end_addr);
                            break;
                        case WASM_OP_DELEGATE:
                            skip_leb(lookup_cursor); /* skip depth */
                            PUSH_I64(end_addr);
                            /* patch target_addr */
                            (frame_csp - 1)->target_addr = lookup_cursor;
                            break;
                        case WASM_OP_END:
                            PUSH_I64(0);
                            /* patch target_addr */
                            (frame_csp - 1)->target_addr = end_addr;
                            break;
                        default:
                            /* something went wrong */
                            wasm_set_exception(module,
                                               "find block address returned an "
                                               "unexpected opcode");
                            goto got_exception;
                    }
                    /* ... search until the returned address is the END of the
                     * TRY block */
                } while (handler_opcode != WASM_OP_END
                         && handler_opcode != WASM_OP_DELEGATE);
                /* handler setup on stack complete */

                HANDLE_OP_END();
            }
            HANDLE_OP(WASM_OP_CATCH)
            {
                /* skip the tag_index */
                skip_leb(frame_ip);
                /* leave the frame */
                POP_CSP_N(0);
                HANDLE_OP_END();
            }
            HANDLE_OP(WASM_OP_CATCH_ALL)
            {
                /* leave the frame */
                POP_CSP_N(0);
                HANDLE_OP_END();
            }
            HANDLE_OP(WASM_OP_DELEGATE)
            {
                /* skip the delegate depth */
                skip_leb(frame_ip);
                /* leave the frame like WASM_OP_END */
                POP_CSP();
                HANDLE_OP_END();
            }
#endif /* end of WASM_ENABLE_EXCE_HANDLING != 0 */
            HANDLE_OP(EXT_OP_BLOCK)
            {
                read_leb_uint32(frame_ip, frame_ip_end, type_index);
                param_cell_num =
                    ((WASMFuncType *)wasm_types[type_index])->param_cell_num;
                cell_num =
                    ((WASMFuncType *)wasm_types[type_index])->ret_cell_num;
                goto handle_op_block;
            }

            HANDLE_OP(WASM_OP_BLOCK)
            {
                value_type = *frame_ip++;
                param_cell_num = 0;
                cell_num = wasm_value_type_cell_num(value_type);
            handle_op_block:
                cache_index = ((uintptr_t)frame_ip)
                              & (uintptr_t)(BLOCK_ADDR_CACHE_SIZE - 1);
                cache_items = exec_env->block_addr_cache[cache_index];
                if (cache_items[0].start_addr == frame_ip) {
                    end_addr = cache_items[0].end_addr;
                }
                else if (cache_items[1].start_addr == frame_ip) {
                    end_addr = cache_items[1].end_addr;
                }
#if WASM_ENABLE_DEBUG_INTERP != 0
                else if (!wasm_loader_find_block_addr(
                             exec_env, (BlockAddr *)exec_env->block_addr_cache,
                             frame_ip, (uint8 *)-1, LABEL_TYPE_BLOCK,
                             &else_addr, &end_addr)) {
                    wasm_set_exception(module, "find block address failed");
                    goto got_exception;
                }
#endif
                else {
                    end_addr = NULL;
                }
                PUSH_CSP(LABEL_TYPE_BLOCK, param_cell_num, cell_num, end_addr);
                HANDLE_OP_END();
            }

            HANDLE_OP(EXT_OP_LOOP)
            {
                read_leb_uint32(frame_ip, frame_ip_end, type_index);
                param_cell_num =
                    ((WASMFuncType *)wasm_types[type_index])->param_cell_num;
                cell_num =
                    ((WASMFuncType *)wasm_types[type_index])->param_cell_num;
                goto handle_op_loop;
            }

            HANDLE_OP(WASM_OP_LOOP)
            {
                value_type = *frame_ip++;
                param_cell_num = 0;
                cell_num = 0;
            handle_op_loop:
                PUSH_CSP(LABEL_TYPE_LOOP, param_cell_num, cell_num, frame_ip);
                HANDLE_OP_END();
            }

            HANDLE_OP(EXT_OP_IF)
            {
                read_leb_uint32(frame_ip, frame_ip_end, type_index);
                param_cell_num =
                    ((WASMFuncType *)wasm_types[type_index])->param_cell_num;
                cell_num =
                    ((WASMFuncType *)wasm_types[type_index])->ret_cell_num;
                goto handle_op_if;
            }

            HANDLE_OP(WASM_OP_IF)
            {
                value_type = *frame_ip++;
                param_cell_num = 0;
                cell_num = wasm_value_type_cell_num(value_type);
            handle_op_if:
                cache_index = ((uintptr_t)frame_ip)
                              & (uintptr_t)(BLOCK_ADDR_CACHE_SIZE - 1);
                cache_items = exec_env->block_addr_cache[cache_index];
                if (cache_items[0].start_addr == frame_ip) {
                    else_addr = cache_items[0].else_addr;
                    end_addr = cache_items[0].end_addr;
                }
                else if (cache_items[1].start_addr == frame_ip) {
                    else_addr = cache_items[1].else_addr;
                    end_addr = cache_items[1].end_addr;
                }
                else if (!wasm_loader_find_block_addr(
                             exec_env, (BlockAddr *)exec_env->block_addr_cache,
                             frame_ip, (uint8 *)-1, LABEL_TYPE_IF, &else_addr,
                             &end_addr)) {
                    wasm_set_exception(module, "find block address failed");
                    goto got_exception;
                }

                cond = (uint32)POP_I32();

                if (cond) { /* if branch is met */
                    PUSH_CSP(LABEL_TYPE_IF, param_cell_num, cell_num, end_addr);
                }
                else { /* if branch is not met */
                    /* if there is no else branch, go to the end addr */
                    if (else_addr == NULL) {
                        frame_ip = end_addr + 1;
                    }
                    /* if there is an else branch, go to the else addr */
                    else {
                        PUSH_CSP(LABEL_TYPE_IF, param_cell_num, cell_num,
                                 end_addr);
                        frame_ip = else_addr + 1;
                    }
                }
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_ELSE)
            {
                /* comes from the if branch in WASM_OP_IF */
                frame_ip = (frame_csp - 1)->target_addr;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_END)
            {
                if (frame_csp > frame->csp_bottom + 1) {
                    POP_CSP();
                }
                else { /* end of function, treat as WASM_OP_RETURN */
                    frame_sp -= cur_func->ret_cell_num;
                    for (i = 0; i < cur_func->ret_cell_num; i++) {
#if WASM_ENABLE_GC != 0
                        if (prev_frame->ip) {
                            /* prev frame is not a glue frame and has
                               the frame ref area */
                            *FRAME_REF_FOR(prev_frame, prev_frame->sp) =
                                *FRAME_REF(frame_sp + i);
                        }
#endif
                        *prev_frame->sp++ = frame_sp[i];
                    }
                    goto return_func;
                }
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_BR)
            {
#if WASM_ENABLE_THREAD_MGR != 0
                CHECK_SUSPEND_FLAGS();
#endif
                read_leb_uint32(frame_ip, frame_ip_end, depth);
            label_pop_csp_n:
                POP_CSP_N(depth);
                if (!frame_ip) { /* must be label pushed by WASM_OP_BLOCK */
                    if (!wasm_loader_find_block_addr(
                            exec_env, (BlockAddr *)exec_env->block_addr_cache,
                            (frame_csp - 1)->begin_addr, (uint8 *)-1,
                            LABEL_TYPE_BLOCK, &else_addr, &end_addr)) {
                        wasm_set_exception(module, "find block address failed");
                        goto got_exception;
                    }
                    frame_ip = end_addr;
                }
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_BR_IF)
            {
#if WASM_ENABLE_THREAD_MGR != 0
                CHECK_SUSPEND_FLAGS();
#endif
                read_leb_uint32(frame_ip, frame_ip_end, depth);
                cond = (uint32)POP_I32();
                if (cond)
                    goto label_pop_csp_n;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_BR_TABLE)
            {
#if WASM_ENABLE_THREAD_MGR != 0
                CHECK_SUSPEND_FLAGS();
#endif
                read_leb_uint32(frame_ip, frame_ip_end, count);
                lidx = POP_I32();
                if (lidx > count)
                    lidx = count;
                depth = frame_ip[lidx];
                goto label_pop_csp_n;
            }

            HANDLE_OP(EXT_OP_BR_TABLE_CACHE)
            {
                BrTableCache *node_cache =
                    bh_list_first_elem(module->module->br_table_cache_list);
                BrTableCache *node_next;

#if WASM_ENABLE_THREAD_MGR != 0
                CHECK_SUSPEND_FLAGS();
#endif
                lidx = POP_I32();

                while (node_cache) {
                    node_next = bh_list_elem_next(node_cache);
                    if (node_cache->br_table_op_addr == frame_ip - 1) {
                        if (lidx > node_cache->br_count)
                            lidx = node_cache->br_count;
                        depth = node_cache->br_depths[lidx];
                        goto label_pop_csp_n;
                    }
                    node_cache = node_next;
                }
                bh_assert(0);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_RETURN)
            {
                frame_sp -= cur_func->ret_cell_num;
                for (i = 0; i < cur_func->ret_cell_num; i++) {
#if WASM_ENABLE_GC != 0
                    if (prev_frame->ip) {
                        /* prev frame is not a glue frame and has
                           the frame ref area */
                        *FRAME_REF_FOR(prev_frame, prev_frame->sp) =
                            *FRAME_REF(frame_sp + i);
                    }
#endif
                    *prev_frame->sp++ = frame_sp[i];
                }
                goto return_func;
            }

            HANDLE_OP(WASM_OP_CALL)
            {
#if WASM_ENABLE_THREAD_MGR != 0
                CHECK_SUSPEND_FLAGS();
#endif
                read_leb_uint32(frame_ip, frame_ip_end, fidx);
#if WASM_ENABLE_MULTI_MODULE != 0
                if (fidx >= module->e->function_count) {
                    wasm_set_exception(module, "unknown function");
                    goto got_exception;
                }
#endif

                cur_func = module->e->functions + fidx;
                goto call_func_from_interp;
            }

#if WASM_ENABLE_TAIL_CALL != 0
            HANDLE_OP(WASM_OP_RETURN_CALL)
            {
#if WASM_ENABLE_THREAD_MGR != 0
                CHECK_SUSPEND_FLAGS();
#endif
                read_leb_uint32(frame_ip, frame_ip_end, fidx);
#if WASM_ENABLE_MULTI_MODULE != 0
                if (fidx >= module->e->function_count) {
                    wasm_set_exception(module, "unknown function");
                    goto got_exception;
                }
#endif
                cur_func = module->e->functions + fidx;

                goto call_func_from_return_call;
            }
#endif /* WASM_ENABLE_TAIL_CALL */

            HANDLE_OP(WASM_OP_CALL_INDIRECT)
#if WASM_ENABLE_TAIL_CALL != 0
            HANDLE_OP(WASM_OP_RETURN_CALL_INDIRECT)
#endif
            {
                WASMFuncType *cur_type, *cur_func_type;
                WASMTableInstance *tbl_inst;
                uint32 tbl_idx;

#if WASM_ENABLE_TAIL_CALL != 0
                opcode = *(frame_ip - 1);
#endif
#if WASM_ENABLE_THREAD_MGR != 0
                CHECK_SUSPEND_FLAGS();
#endif

                /**
                 * type check. compiler will make sure all like
                 * (call_indirect (type $x) (i32.const 1))
                 * the function type has to be defined in the module also
                 * no matter it is used or not
                 */
                read_leb_uint32(frame_ip, frame_ip_end, tidx);
                bh_assert(tidx < module->module->type_count);
                cur_type = wasm_types[tidx];

                read_leb_uint32(frame_ip, frame_ip_end, tbl_idx);
                bh_assert(tbl_idx < module->table_count);

                tbl_inst = wasm_get_table_inst(module, tbl_idx);

                val = POP_I32();
                if ((uint32)val >= tbl_inst->cur_size) {
                    wasm_set_exception(module, "undefined element");
                    goto got_exception;
                }

                /* clang-format off */
#if WASM_ENABLE_GC == 0
                fidx = tbl_inst->elems[val];
                if (fidx == (uint32)-1) {
                    wasm_set_exception(module, "uninitialized element");
                    goto got_exception;
                }
#else
                func_obj = (WASMFuncObjectRef)tbl_inst->elems[val];
                if (!func_obj) {
                    wasm_set_exception(module, "uninitialized element");
                    goto got_exception;
                }
                fidx = wasm_func_obj_get_func_idx_bound(func_obj);
#endif
                /* clang-format on */

                /*
                 * we might be using a table injected by host or
                 * another module. In that case, we don't validate
                 * the elem value while loading
                 */
                if (fidx >= module->e->function_count) {
                    wasm_set_exception(module, "unknown function");
                    goto got_exception;
                }

                /* always call module own functions */
                cur_func = module->e->functions + fidx;

                if (cur_func->is_import_func)
                    cur_func_type = cur_func->u.func_import->func_type;
                else
                    cur_func_type = cur_func->u.func->func_type;

                    /* clang-format off */
#if WASM_ENABLE_GC == 0
                if (cur_type != cur_func_type) {
                    wasm_set_exception(module, "indirect call type mismatch");
                    goto got_exception;
                }
#else
                if (!wasm_func_type_is_super_of(cur_type, cur_func_type)) {
                    wasm_set_exception(module, "indirect call type mismatch");
                    goto got_exception;
                }
#endif
                /* clang-format on */

#if WASM_ENABLE_TAIL_CALL != 0
                if (opcode == WASM_OP_RETURN_CALL_INDIRECT)
                    goto call_func_from_return_call;
#endif
                goto call_func_from_interp;
            }

            /* parametric instructions */
            HANDLE_OP(WASM_OP_DROP)
            {
                frame_sp--;

#if WASM_ENABLE_GC != 0
                frame_ref_tmp = FRAME_REF(frame_sp);
                *frame_ref_tmp = 0;
#endif
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_DROP_64)
            {
                frame_sp -= 2;

#if WASM_ENABLE_GC != 0
                frame_ref_tmp = FRAME_REF(frame_sp);
                *frame_ref_tmp = 0;
                *(frame_ref_tmp + 1) = 0;
#endif

                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_SELECT)
            {
                cond = (uint32)POP_I32();
                frame_sp--;
                if (!cond)
                    *(frame_sp - 1) = *frame_sp;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_SELECT_64)
            {
                cond = (uint32)POP_I32();
                frame_sp -= 2;
                if (!cond) {
                    *(frame_sp - 2) = *frame_sp;
                    *(frame_sp - 1) = *(frame_sp + 1);
                }
                HANDLE_OP_END();
            }

#if WASM_ENABLE_REF_TYPES != 0 || WASM_ENABLE_GC != 0
            HANDLE_OP(WASM_OP_SELECT_T)
            {
                uint32 vec_len;
                uint8 type;

                read_leb_uint32(frame_ip, frame_ip_end, vec_len);
                type = *frame_ip++;

                cond = (uint32)POP_I32();
                if (type == VALUE_TYPE_I64 || type == VALUE_TYPE_F64
#if WASM_ENABLE_GC != 0 && UINTPTR_MAX == UINT64_MAX
                    || wasm_is_type_reftype(type)
#endif
                ) {
                    frame_sp -= 2;
                    if (!cond) {
                        *(frame_sp - 2) = *frame_sp;
                        *(frame_sp - 1) = *(frame_sp + 1);
                    }
                }
                else {
                    frame_sp--;
                    if (!cond)
                        *(frame_sp - 1) = *frame_sp;
                }

#if WASM_ENABLE_GC != 0
                frame_ref_tmp = FRAME_REF(frame_sp);
                *frame_ref_tmp = 0;
#if UINTPTR_MAX == UINT64_MAX
                *(frame_ref_tmp + 1) = 0;
#endif
#endif
                (void)vec_len;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_TABLE_GET)
            {
                uint32 tbl_idx, elem_idx;
                WASMTableInstance *tbl_inst;

                read_leb_uint32(frame_ip, frame_ip_end, tbl_idx);
                bh_assert(tbl_idx < module->table_count);

                tbl_inst = wasm_get_table_inst(module, tbl_idx);

                elem_idx = POP_I32();
                if (elem_idx >= tbl_inst->cur_size) {
                    wasm_set_exception(module, "out of bounds table access");
                    goto got_exception;
                }

#if WASM_ENABLE_GC == 0
                PUSH_I32(tbl_inst->elems[elem_idx]);
#else
                PUSH_REF(tbl_inst->elems[elem_idx]);
#endif
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_TABLE_SET)
            {
                WASMTableInstance *tbl_inst;
                uint32 tbl_idx, elem_idx;
                table_elem_type_t elem_val;

                read_leb_uint32(frame_ip, frame_ip_end, tbl_idx);
                bh_assert(tbl_idx < module->table_count);

                tbl_inst = wasm_get_table_inst(module, tbl_idx);

#if WASM_ENABLE_GC == 0
                elem_val = POP_I32();
#else
                elem_val = POP_REF();
#endif
                elem_idx = POP_I32();
                if (elem_idx >= tbl_inst->cur_size) {
                    wasm_set_exception(module, "out of bounds table access");
                    goto got_exception;
                }

                tbl_inst->elems[elem_idx] = elem_val;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_REF_NULL)
            {
                uint32 ref_type;
                read_leb_uint32(frame_ip, frame_ip_end, ref_type);
#if WASM_ENABLE_GC == 0
                PUSH_I32(NULL_REF);
#else
                PUSH_REF(NULL_REF);
#endif
                (void)ref_type;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_REF_IS_NULL)
            {
#if WASM_ENABLE_GC == 0
                uint32 ref_val;
                ref_val = POP_I32();
#else
                void *ref_val;
                ref_val = POP_REF();
#endif
                PUSH_I32(ref_val == NULL_REF ? 1 : 0);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_REF_FUNC)
            {
                uint32 func_idx;
                read_leb_uint32(frame_ip, frame_ip_end, func_idx);
#if WASM_ENABLE_GC == 0
                PUSH_I32(func_idx);
#else
                SYNC_ALL_TO_FRAME();
                if (!(gc_obj = wasm_create_func_obj(module, func_idx, true,
                                                    NULL, 0))) {
                    goto got_exception;
                }
                PUSH_REF(gc_obj);
#endif
                HANDLE_OP_END();
            }
#endif /* end of WASM_ENABLE_REF_TYPES != 0 || WASM_ENABLE_GC != 0 */

#if WASM_ENABLE_GC != 0
            HANDLE_OP(WASM_OP_CALL_REF)
            {
#if WASM_ENABLE_THREAD_MGR != 0
                CHECK_SUSPEND_FLAGS();
#endif
                read_leb_uint32(frame_ip, frame_ip_end, type_index);
                func_obj = POP_REF();
                if (!func_obj) {
                    wasm_set_exception(module, "null function object");
                    goto got_exception;
                }

                fidx = wasm_func_obj_get_func_idx_bound(func_obj);
                cur_func = module->e->functions + fidx;
                goto call_func_from_interp;
            }

            HANDLE_OP(WASM_OP_RETURN_CALL_REF)
            {
#if WASM_ENABLE_THREAD_MGR != 0
                CHECK_SUSPEND_FLAGS();
#endif
                read_leb_uint32(frame_ip, frame_ip_end, type_index);
                func_obj = POP_REF();
                if (!func_obj) {
                    wasm_set_exception(module, "null function object");
                    goto got_exception;
                }

                fidx = wasm_func_obj_get_func_idx_bound(func_obj);
                cur_func = module->e->functions + fidx;
                goto call_func_from_return_call;
            }

            HANDLE_OP(WASM_OP_REF_EQ)
            {
                WASMObjectRef gc_obj1, gc_obj2;
                gc_obj2 = POP_REF();
                gc_obj1 = POP_REF();
                val = wasm_obj_equal(gc_obj1, gc_obj2);
                PUSH_I32(val);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_REF_AS_NON_NULL)
            {
                gc_obj = POP_REF();
                if (gc_obj == NULL_REF) {
                    wasm_set_exception(module, "null reference");
                    goto got_exception;
                }
                PUSH_REF(gc_obj);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_BR_ON_NULL)
            {
#if WASM_ENABLE_THREAD_MGR != 0
                CHECK_SUSPEND_FLAGS();
#endif
                read_leb_uint32(frame_ip, frame_ip_end, depth);
                gc_obj = GET_REF_FROM_ADDR(frame_sp - REF_CELL_NUM);
                if (gc_obj == NULL_REF) {
                    frame_sp -= REF_CELL_NUM;
                    CLEAR_FRAME_REF(frame_sp, REF_CELL_NUM);
                    goto label_pop_csp_n;
                }
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_BR_ON_NON_NULL)
            {
#if WASM_ENABLE_THREAD_MGR != 0
                CHECK_SUSPEND_FLAGS();
#endif
                read_leb_uint32(frame_ip, frame_ip_end, depth);
                gc_obj = GET_REF_FROM_ADDR(frame_sp - REF_CELL_NUM);
                if (gc_obj != NULL_REF) {
                    goto label_pop_csp_n;
                }
                else {
                    frame_sp -= REF_CELL_NUM;
                    CLEAR_FRAME_REF(frame_sp, REF_CELL_NUM);
                }
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_GC_PREFIX)
            {
                uint32 opcode1;

                read_leb_uint32(frame_ip, frame_ip_end, opcode1);
                /* opcode1 was checked in loader and is no larger than
                   UINT8_MAX */
                opcode = (uint8)opcode1;

                switch (opcode) {
                    case WASM_OP_STRUCT_NEW:
                    case WASM_OP_STRUCT_NEW_DEFAULT:
                    {
                        WASMModule *wasm_module = module->module;
                        WASMStructType *struct_type;
                        WASMRttType *rtt_type;
                        WASMValue field_value = { 0 };

                        read_leb_uint32(frame_ip, frame_ip_end, type_index);
                        struct_type =
                            (WASMStructType *)module->module->types[type_index];

                        if (!(rtt_type = wasm_rtt_type_new(
                                  (WASMType *)struct_type, type_index,
                                  wasm_module->rtt_types,
                                  wasm_module->type_count,
                                  &wasm_module->rtt_type_lock))) {
                            wasm_set_exception(module,
                                               "create rtt type failed");
                            goto got_exception;
                        }

                        SYNC_ALL_TO_FRAME();
                        struct_obj = wasm_struct_obj_new(exec_env, rtt_type);
                        if (!struct_obj) {
                            wasm_set_exception(module,
                                               "create struct object failed");
                            goto got_exception;
                        }

                        if (opcode == WASM_OP_STRUCT_NEW) {
                            WASMStructFieldType *fields = struct_type->fields;
                            int32 field_count = (int32)struct_type->field_count;
                            int32 field_idx;
                            uint8 field_type;

                            for (field_idx = field_count - 1; field_idx >= 0;
                                 field_idx--) {
                                field_type = fields[field_idx].field_type;
                                if (wasm_is_type_reftype(field_type)) {
                                    field_value.gc_obj = POP_REF();
                                }
                                else if (field_type == VALUE_TYPE_I32
                                         || field_type == VALUE_TYPE_F32
                                         || field_type == PACKED_TYPE_I8
                                         || field_type == PACKED_TYPE_I16) {
                                    field_value.i32 = POP_I32();
                                }
                                else {
                                    field_value.i64 = POP_I64();
                                }
                                wasm_struct_obj_set_field(struct_obj, field_idx,
                                                          &field_value);
                            }
                        }
                        PUSH_REF(struct_obj);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRUCT_GET:
                    case WASM_OP_STRUCT_GET_S:
                    case WASM_OP_STRUCT_GET_U:
                    {
                        WASMStructType *struct_type;
                        WASMValue field_value = { 0 };
                        uint32 field_idx;
                        uint8 field_type;

                        read_leb_uint32(frame_ip, frame_ip_end, type_index);
                        read_leb_uint32(frame_ip, frame_ip_end, field_idx);
                        struct_type =
                            (WASMStructType *)module->module->types[type_index];

                        struct_obj = POP_REF();

                        if (!struct_obj) {
                            wasm_set_exception(module, "null structure object");
                            goto got_exception;
                        }

                        wasm_struct_obj_get_field(
                            struct_obj, field_idx,
                            opcode == WASM_OP_STRUCT_GET_S ? true : false,
                            &field_value);

                        field_type = struct_type->fields[field_idx].field_type;
                        if (wasm_is_reftype_i31ref(field_type)) {
                            PUSH_I31REF(field_value.gc_obj);
                        }
                        else if (wasm_is_type_reftype(field_type)) {
                            PUSH_REF(field_value.gc_obj);
                        }
                        else if (field_type == VALUE_TYPE_I32
                                 || field_type == VALUE_TYPE_F32
                                 || field_type == PACKED_TYPE_I8
                                 || field_type == PACKED_TYPE_I16) {
                            PUSH_I32(field_value.i32);
                        }
                        else {
                            PUSH_I64(field_value.i64);
                        }
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRUCT_SET:
                    {
                        WASMStructType *struct_type;
                        WASMValue field_value = { 0 };
                        uint32 field_idx;
                        uint8 field_type;

                        read_leb_uint32(frame_ip, frame_ip_end, type_index);
                        read_leb_uint32(frame_ip, frame_ip_end, field_idx);

                        struct_type =
                            (WASMStructType *)module->module->types[type_index];
                        field_type = struct_type->fields[field_idx].field_type;

                        if (wasm_is_type_reftype(field_type)) {
                            field_value.gc_obj = POP_REF();
                        }
                        else if (field_type == VALUE_TYPE_I32
                                 || field_type == VALUE_TYPE_F32
                                 || field_type == PACKED_TYPE_I8
                                 || field_type == PACKED_TYPE_I16) {
                            field_value.i32 = POP_I32();
                        }
                        else {
                            field_value.i64 = POP_I64();
                        }

                        struct_obj = POP_REF();
                        if (!struct_obj) {
                            wasm_set_exception(module, "null structure object");
                            goto got_exception;
                        }

                        wasm_struct_obj_set_field(struct_obj, field_idx,
                                                  &field_value);
                        HANDLE_OP_END();
                    }

                    case WASM_OP_ARRAY_NEW:
                    case WASM_OP_ARRAY_NEW_DEFAULT:
                    case WASM_OP_ARRAY_NEW_FIXED:
                    {
                        WASMModule *wasm_module = module->module;
                        WASMArrayType *array_type;
                        WASMRttType *rtt_type;
                        WASMValue array_elem = { 0 };
                        uint32 array_len;

                        read_leb_uint32(frame_ip, frame_ip_end, type_index);
                        array_type =
                            (WASMArrayType *)wasm_module->types[type_index];

                        if (!(rtt_type = wasm_rtt_type_new(
                                  (WASMType *)array_type, type_index,
                                  wasm_module->rtt_types,
                                  wasm_module->type_count,
                                  &wasm_module->rtt_type_lock))) {
                            wasm_set_exception(module,
                                               "create rtt type failed");
                            goto got_exception;
                        }

                        if (opcode != WASM_OP_ARRAY_NEW_FIXED)
                            array_len = POP_I32();
                        else
                            read_leb_uint32(frame_ip, frame_ip_end, array_len);

                        if (opcode == WASM_OP_ARRAY_NEW) {
                            if (wasm_is_type_reftype(array_type->elem_type)) {
                                array_elem.gc_obj = POP_REF();
                            }
                            else if (array_type->elem_type == VALUE_TYPE_I32
                                     || array_type->elem_type == VALUE_TYPE_F32
                                     || array_type->elem_type == PACKED_TYPE_I8
                                     || array_type->elem_type
                                            == PACKED_TYPE_I16) {
                                array_elem.i32 = POP_I32();
                            }
                            else {
                                array_elem.i64 = POP_I64();
                            }
                        }

                        SYNC_ALL_TO_FRAME();
                        array_obj = wasm_array_obj_new(exec_env, rtt_type,
                                                       array_len, &array_elem);
                        if (!array_obj) {
                            wasm_set_exception(module,
                                               "create array object failed");
                            goto got_exception;
                        }

                        if (opcode == WASM_OP_ARRAY_NEW_FIXED) {
                            for (i = 0; i < array_len; i++) {
                                if (wasm_is_type_reftype(
                                        array_type->elem_type)) {
                                    array_elem.gc_obj = POP_REF();
                                }
                                else if (array_type->elem_type == VALUE_TYPE_I32
                                         || array_type->elem_type
                                                == VALUE_TYPE_F32
                                         || array_type->elem_type
                                                == PACKED_TYPE_I8
                                         || array_type->elem_type
                                                == PACKED_TYPE_I16) {
                                    array_elem.i32 = POP_I32();
                                }
                                else {
                                    array_elem.i64 = POP_I64();
                                }
                                wasm_array_obj_set_elem(
                                    array_obj, array_len - 1 - i, &array_elem);
                            }
                        }

                        PUSH_REF(array_obj);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_ARRAY_NEW_DATA:
                    {
                        WASMModule *wasm_module = module->module;
                        WASMArrayType *array_type;
                        WASMRttType *rtt_type;
                        WASMValue array_elem = { 0 };
                        WASMDataSeg *data_seg;
                        uint8 *array_elem_base;
                        uint32 array_len, data_seg_idx, data_seg_offset;
                        uint32 elem_size = 0;
                        uint64 total_size;

                        read_leb_uint32(frame_ip, frame_ip_end, type_index);
                        read_leb_uint32(frame_ip, frame_ip_end, data_seg_idx);
                        data_seg = wasm_module->data_segments[data_seg_idx];

                        array_type =
                            (WASMArrayType *)wasm_module->types[type_index];

                        if (!(rtt_type = wasm_rtt_type_new(
                                  (WASMType *)array_type, type_index,
                                  wasm_module->rtt_types,
                                  wasm_module->type_count,
                                  &wasm_module->rtt_type_lock))) {
                            wasm_set_exception(module,
                                               "create rtt type failed");
                            goto got_exception;
                        }

                        array_len = POP_I32();
                        data_seg_offset = POP_I32();

                        switch (array_type->elem_type) {
                            case PACKED_TYPE_I8:
                                elem_size = 1;
                                break;
                            case PACKED_TYPE_I16:
                                elem_size = 2;
                                break;
                            case VALUE_TYPE_I32:
                            case VALUE_TYPE_F32:
                                elem_size = 4;
                                break;
                            case VALUE_TYPE_I64:
                            case VALUE_TYPE_F64:
                                elem_size = 8;
                                break;
                            default:
                                bh_assert(0);
                        }

                        total_size = (uint64)elem_size * array_len;
                        if (data_seg_offset >= data_seg->data_length
                            || total_size
                                   > data_seg->data_length - data_seg_offset) {
                            wasm_set_exception(module,
                                               "data segment out of bounds");
                            goto got_exception;
                        }

                        SYNC_ALL_TO_FRAME();
                        array_obj = wasm_array_obj_new(exec_env, rtt_type,
                                                       array_len, &array_elem);
                        if (!array_obj) {
                            wasm_set_exception(module,
                                               "create array object failed");
                            goto got_exception;
                        }

                        array_elem_base =
                            (uint8 *)wasm_array_obj_first_elem_addr(array_obj);
                        bh_memcpy_s(array_elem_base, (uint32)total_size,
                                    data_seg->data + data_seg_offset,
                                    (uint32)total_size);

                        PUSH_REF(array_obj);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_ARRAY_NEW_ELEM:
                    {
                        /* TODO */
                        wasm_set_exception(module, "unsupported opcode");
                        goto got_exception;
                    }
                    case WASM_OP_ARRAY_GET:
                    case WASM_OP_ARRAY_GET_S:
                    case WASM_OP_ARRAY_GET_U:
                    {
                        WASMArrayType *array_type;
                        WASMValue array_elem = { 0 };
                        uint32 elem_idx, elem_size_log;

                        read_leb_uint32(frame_ip, frame_ip_end, type_index);
                        array_type =
                            (WASMArrayType *)module->module->types[type_index];

                        elem_idx = POP_I32();
                        array_obj = POP_REF();

                        if (!array_obj) {
                            wasm_set_exception(module, "null array reference");
                            goto got_exception;
                        }
                        if (elem_idx >= wasm_array_obj_length(array_obj)) {
                            wasm_set_exception(module,
                                               "out of bounds array access");
                            goto got_exception;
                        }

                        wasm_array_obj_get_elem(
                            array_obj, elem_idx,
                            opcode == WASM_OP_ARRAY_GET_S ? true : false,
                            &array_elem);
                        elem_size_log = wasm_array_obj_elem_size_log(array_obj);

                        if (wasm_is_reftype_i31ref(array_type->elem_type)) {
                            PUSH_I31REF(array_elem.gc_obj);
                        }
                        else if (wasm_is_type_reftype(array_type->elem_type)) {
                            PUSH_REF(array_elem.gc_obj);
                        }
                        else if (elem_size_log < 3) {
                            PUSH_I32(array_elem.i32);
                        }
                        else {
                            PUSH_I64(array_elem.i64);
                        }
                        HANDLE_OP_END();
                    }
                    case WASM_OP_ARRAY_SET:
                    {
                        WASMArrayType *array_type;
                        WASMValue array_elem = { 0 };
                        uint32 elem_idx;

                        read_leb_uint32(frame_ip, frame_ip_end, type_index);
                        array_type =
                            (WASMArrayType *)module->module->types[type_index];
                        if (wasm_is_type_reftype(array_type->elem_type)) {
                            array_elem.gc_obj = POP_REF();
                        }
                        else if (array_type->elem_type == VALUE_TYPE_I32
                                 || array_type->elem_type == VALUE_TYPE_F32
                                 || array_type->elem_type == PACKED_TYPE_I8
                                 || array_type->elem_type == PACKED_TYPE_I16) {
                            array_elem.i32 = POP_I32();
                        }
                        else {
                            array_elem.i64 = POP_I64();
                        }

                        elem_idx = POP_I32();
                        array_obj = POP_REF();

                        if (!array_obj) {
                            wasm_set_exception(module, "null array reference");
                            goto got_exception;
                        }
                        if (elem_idx >= wasm_array_obj_length(array_obj)) {
                            wasm_set_exception(module,
                                               "out of bounds array access");
                            goto got_exception;
                        }

                        wasm_array_obj_set_elem(array_obj, elem_idx,
                                                &array_elem);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_ARRAY_LEN:
                    {
                        uint32 array_len;

                        array_obj = POP_REF();
                        if (!array_obj) {
                            wasm_set_exception(module, "null array reference");
                            goto got_exception;
                        }
                        array_len = wasm_array_obj_length(array_obj);
                        PUSH_I32(array_len);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_ARRAY_FILL:
                    {
                        WASMArrayType *array_type;
                        WASMValue fill_value = { 0 };
                        uint32 start_offset, len;
                        read_leb_uint32(frame_ip, frame_ip_end, type_index);

                        array_type =
                            (WASMArrayType *)module->module->types[type_index];

                        len = POP_I32();
                        if (wasm_is_type_reftype(array_type->elem_type)) {
                            fill_value.gc_obj = POP_REF();
                        }
                        else if (array_type->elem_type == VALUE_TYPE_I32
                                 || array_type->elem_type == VALUE_TYPE_F32
                                 || array_type->elem_type == PACKED_TYPE_I8
                                 || array_type->elem_type == PACKED_TYPE_I16) {
                            fill_value.i32 = POP_I32();
                        }
                        else {
                            fill_value.i64 = POP_I64();
                        }
                        start_offset = POP_I32();
                        array_obj = POP_REF();

                        if (!array_obj) {
                            wasm_set_exception(module, "null array reference");
                            goto got_exception;
                        }

                        if (len > 0) {
                            if ((uint64)start_offset + len
                                >= wasm_array_obj_length(array_obj)) {
                                wasm_set_exception(
                                    module, "out of bounds array access");
                                goto got_exception;
                            }

                            wasm_array_obj_fill(array_obj, start_offset, len,
                                                &fill_value);
                        }

                        HANDLE_OP_END();
                    }
                    case WASM_OP_ARRAY_COPY:
                    {
                        uint32 dst_offset, src_offset, len, src_type_index;
                        WASMArrayObjectRef src_obj, dst_obj;

                        read_leb_uint32(frame_ip, frame_ip_end, type_index);
                        read_leb_uint32(frame_ip, frame_ip_end, src_type_index);

                        len = POP_I32();
                        src_offset = POP_I32();
                        src_obj = POP_REF();
                        dst_offset = POP_I32();
                        dst_obj = POP_REF();

                        if (!src_obj || !dst_obj) {
                            wasm_set_exception(module, "null array reference");
                            goto got_exception;
                        }

                        if (len > 0) {
                            if ((dst_offset > UINT32_MAX - len)
                                || (dst_offset + len
                                    > wasm_array_obj_length(dst_obj))
                                || (src_offset > UINT32_MAX - len)
                                || (src_offset + len
                                    > wasm_array_obj_length(src_obj))) {
                                wasm_set_exception(
                                    module, "out of bounds array access");
                                goto got_exception;
                            }

                            wasm_array_obj_copy(dst_obj, dst_offset, src_obj,
                                                src_offset, len);
                        }

                        (void)src_type_index;
                        HANDLE_OP_END();
                    }

                    case WASM_OP_REF_I31:
                    {
                        uint32 i31_val;

                        i31_val = POP_I32();
                        i31_obj = wasm_i31_obj_new(i31_val);
                        PUSH_I31REF(i31_obj);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_I31_GET_S:
                    case WASM_OP_I31_GET_U:
                    {
                        uint32 i31_val;

                        i31_obj = (WASMI31ObjectRef)POP_REF();
                        if (!i31_obj) {
                            wasm_set_exception(module, "null i31 reference");
                            goto got_exception;
                        }
                        i31_val = (uint32)(((uintptr_t)i31_obj) >> 1);
                        if (opcode == WASM_OP_I31_GET_S
                            && (i31_val & 0x40000000) /* bit 30 is 1 */)
                            /* set bit 31 to 1 */
                            i31_val |= 0x80000000;
                        PUSH_I32(i31_val);
                        HANDLE_OP_END();
                    }

                    case WASM_OP_REF_TEST:
                    case WASM_OP_REF_CAST:
                    case WASM_OP_REF_TEST_NULLABLE:
                    case WASM_OP_REF_CAST_NULLABLE:
                    {
                        int32 heap_type;

                        read_leb_int32(frame_ip, frame_ip_end, heap_type);

                        gc_obj = GET_REF_FROM_ADDR(frame_sp - REF_CELL_NUM);
                        if (!gc_obj) {
                            if (opcode == WASM_OP_REF_TEST
                                || opcode == WASM_OP_REF_TEST_NULLABLE) {
                                (void)POP_REF();
                                if (opcode == WASM_OP_REF_TEST)
                                    PUSH_I32(0);
                                else
                                    PUSH_I32(1);
                            }
                            else if (opcode == WASM_OP_REF_CAST) {
                                wasm_set_exception(module, "cast failure");
                                goto got_exception;
                            }
                            else {
                                /* Do nothing for WASM_OP_REF_CAST_NULLABLE */
                            }
                        }
                        else {
                            bool castable = false;

                            if (heap_type >= 0) {
                                WASMModule *wasm_module = module->module;
                                castable = wasm_obj_is_instance_of(
                                    gc_obj, (uint32)heap_type,
                                    wasm_module->types,
                                    wasm_module->type_count);
                            }
                            else {
                                castable =
                                    wasm_obj_is_type_of(gc_obj, heap_type);
                            }

                            if (opcode == WASM_OP_REF_TEST
                                || opcode == WASM_OP_REF_TEST_NULLABLE) {
                                (void)POP_REF();
                                if (castable)
                                    PUSH_I32(1);
                                else
                                    PUSH_I32(0);
                            }
                            else if (!castable) {
                                wasm_set_exception(module, "cast failure");
                                goto got_exception;
                            }
                        }
                        HANDLE_OP_END();
                    }

                    case WASM_OP_BR_ON_CAST:
                    case WASM_OP_BR_ON_CAST_FAIL:
                    {
                        int32 heap_type, heap_type_dst;
                        uint8 castflags;

#if WASM_ENABLE_THREAD_MGR != 0
                        CHECK_SUSPEND_FLAGS();
#endif
                        castflags = *frame_ip++;
                        read_leb_uint32(frame_ip, frame_ip_end, depth);
                        read_leb_int32(frame_ip, frame_ip_end, heap_type);
                        read_leb_int32(frame_ip, frame_ip_end, heap_type_dst);

                        gc_obj = GET_REF_FROM_ADDR(frame_sp - REF_CELL_NUM);
                        if (!gc_obj) {
                            /*
                             * castflags should be 0~3:
                             *  0: (non-null, non-null)
                             *  1: (null, non-null)
                             *  2: (non-null, null)
                             *  3: (null, null)
                             */
                            if (
                                /* op is BR_ON_CAST and dst reftype is nullable
                                 */
                                ((opcode1 == WASM_OP_BR_ON_CAST)
                                 && ((castflags == 2) || (castflags == 3)))
                                /* op is BR_ON_CAST_FAIL and dst reftype is
                                   non-nullable */
                                || ((opcode1 == WASM_OP_BR_ON_CAST_FAIL)
                                    && ((castflags == 0) || (castflags == 1))))
                                goto label_pop_csp_n;
                        }
                        else {
                            bool castable = false;

                            if (heap_type_dst >= 0) {
                                WASMModule *wasm_module = module->module;
                                castable = wasm_obj_is_instance_of(
                                    gc_obj, (uint32)heap_type_dst,
                                    wasm_module->types,
                                    wasm_module->type_count);
                            }
                            else {
                                castable =
                                    wasm_obj_is_type_of(gc_obj, heap_type_dst);
                            }

                            if ((castable && (opcode == WASM_OP_BR_ON_CAST))
                                || (!castable
                                    && (opcode == WASM_OP_BR_ON_CAST_FAIL))) {
                                goto label_pop_csp_n;
                            }
                        }

                        (void)heap_type;
                        HANDLE_OP_END();
                    }

                    case WASM_OP_ANY_CONVERT_EXTERN:
                    {
                        externref_obj = POP_REF();
                        if (externref_obj == NULL_REF)
                            PUSH_REF(NULL_REF);
                        else {
                            gc_obj = wasm_externref_obj_to_internal_obj(
                                externref_obj);
                            PUSH_REF(gc_obj);
                        }
                        HANDLE_OP_END();
                    }
                    case WASM_OP_EXTERN_CONVERT_ANY:
                    {
                        gc_obj = POP_REF();
                        if (gc_obj == NULL_REF)
                            PUSH_REF(NULL_REF);
                        else {
                            if (!(externref_obj =
                                      wasm_internal_obj_to_externref_obj(
                                          exec_env, gc_obj))) {
                                wasm_set_exception(
                                    module, "create externref object failed");
                                goto got_exception;
                            }
                            PUSH_REF(externref_obj);
                        }
                        HANDLE_OP_END();
                    }

#if WASM_ENABLE_STRINGREF != 0
                    case WASM_OP_STRING_NEW_UTF8:
                    case WASM_OP_STRING_NEW_WTF16:
                    case WASM_OP_STRING_NEW_LOSSY_UTF8:
                    case WASM_OP_STRING_NEW_WTF8:
                    {
                        uint32 mem_idx, addr, bytes_length, offset = 0;
                        EncodingFlag flag = WTF8;

                        read_leb_uint32(frame_ip, frame_ip_end, mem_idx);
                        bytes_length = POP_I32();
                        addr = POP_I32();

                        CHECK_MEMORY_OVERFLOW(bytes_length);

                        if (opcode == WASM_OP_STRING_NEW_WTF16) {
                            flag = WTF16;
                        }
                        else if (opcode == WASM_OP_STRING_NEW_UTF8) {
                            flag = UTF8;
                        }
                        else if (opcode == WASM_OP_STRING_NEW_LOSSY_UTF8) {
                            flag = LOSSY_UTF8;
                        }
                        else if (opcode == WASM_OP_STRING_NEW_WTF8) {
                            flag = WTF8;
                        }

                        str_obj = wasm_string_new_with_encoding(
                            maddr, bytes_length, flag);
                        if (!str_obj) {
                            wasm_set_exception(module,
                                               "create string object failed");
                            goto got_exception;
                        }

                        SYNC_ALL_TO_FRAME();
                        stringref_obj =
                            wasm_stringref_obj_new(exec_env, str_obj);
                        if (!stringref_obj) {
                            wasm_set_exception(module,
                                               "create stringref failed");
                            goto got_exception;
                        }

                        PUSH_REF(stringref_obj);

                        (void)mem_idx;
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRING_CONST:
                    {
                        WASMModule *wasm_module = module->module;
                        uint32 contents;

                        read_leb_uint32(frame_ip, frame_ip_end, contents);

                        str_obj = wasm_string_new_const(
                            (const char *)
                                wasm_module->string_literal_ptrs[contents],
                            wasm_module->string_literal_lengths[contents]);
                        if (!str_obj) {
                            wasm_set_exception(module,
                                               "create string object failed");
                            goto got_exception;
                        }

                        SYNC_ALL_TO_FRAME();
                        stringref_obj =
                            wasm_stringref_obj_new(exec_env, str_obj);
                        if (!stringref_obj) {
                            wasm_set_exception(module,
                                               "create stringref failed");
                            goto got_exception;
                        }

                        PUSH_REF(stringref_obj);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRING_MEASURE_UTF8:
                    case WASM_OP_STRING_MEASURE_WTF8:
                    case WASM_OP_STRING_MEASURE_WTF16:
                    {
                        int32 target_bytes_length;
                        EncodingFlag flag = WTF8;

                        stringref_obj = POP_REF();

                        if (opcode == WASM_OP_STRING_MEASURE_WTF16) {
                            flag = WTF16;
                        }
                        else if (opcode == WASM_OP_STRING_MEASURE_UTF8) {
                            flag = UTF8;
                        }
                        else if (opcode == WASM_OP_STRING_MEASURE_WTF8) {
                            flag = LOSSY_UTF8;
                        }
                        target_bytes_length = wasm_string_measure(
                            (WASMString)wasm_stringref_obj_get_value(
                                stringref_obj),
                            flag);

                        PUSH_I32(target_bytes_length);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRING_ENCODE_UTF8:
                    case WASM_OP_STRING_ENCODE_WTF16:
                    case WASM_OP_STRING_ENCODE_LOSSY_UTF8:
                    case WASM_OP_STRING_ENCODE_WTF8:
                    {
                        uint32 mem_idx, addr;
                        int32 target_bytes_length;
                        WASMMemoryInstance *memory_inst;
                        EncodingFlag flag = WTF8;

                        read_leb_uint32(frame_ip, frame_ip_end, mem_idx);
                        addr = POP_I32();
                        stringref_obj = POP_REF();

                        str_obj = (WASMString)wasm_stringref_obj_get_value(
                            stringref_obj);

                        memory_inst = module->memories[mem_idx];
                        maddr = memory_inst->memory_data + addr;

                        if (opcode == WASM_OP_STRING_ENCODE_WTF16) {
                            flag = WTF16;
                            count = wasm_string_measure(str_obj, flag);
                            target_bytes_length = wasm_string_encode(
                                str_obj, 0, count, maddr, NULL, flag);
                        }
                        else {
                            if (opcode == WASM_OP_STRING_ENCODE_UTF8) {
                                flag = UTF8;
                            }
                            else if (opcode
                                     == WASM_OP_STRING_ENCODE_LOSSY_UTF8) {
                                flag = LOSSY_UTF8;
                            }
                            else if (opcode == WASM_OP_STRING_ENCODE_WTF8) {
                                flag = WTF8;
                            }
                            count = wasm_string_measure(str_obj, flag);
                            target_bytes_length = wasm_string_encode(
                                str_obj, 0, count, maddr, NULL, flag);

                            if (target_bytes_length == -1) {
                                wasm_set_exception(
                                    module, "isolated surrogate is seen");
                                goto got_exception;
                            }
                        }
                        if (target_bytes_length < 0) {
                            wasm_set_exception(module,
                                               "stringref encode failed");
                            goto got_exception;
                        }

                        PUSH_I32(target_bytes_length);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRING_CONCAT:
                    {
                        WASMStringrefObjectRef stringref_obj1, stringref_obj2;

                        stringref_obj2 = POP_REF();
                        stringref_obj1 = POP_REF();

                        str_obj = wasm_string_concat(
                            (WASMString)wasm_stringref_obj_get_value(
                                stringref_obj1),
                            (WASMString)wasm_stringref_obj_get_value(
                                stringref_obj2));
                        if (!str_obj) {
                            wasm_set_exception(module,
                                               "create string object failed");
                            goto got_exception;
                        }

                        SYNC_ALL_TO_FRAME();
                        stringref_obj =
                            wasm_stringref_obj_new(exec_env, str_obj);
                        if (!stringref_obj) {
                            wasm_set_exception(module,
                                               "create stringref failed");
                            goto got_exception;
                        }

                        PUSH_REF(stringref_obj);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRING_EQ:
                    {
                        WASMStringrefObjectRef stringref_obj1, stringref_obj2;
                        int32 is_eq;

                        stringref_obj2 = POP_REF();
                        stringref_obj1 = POP_REF();

                        is_eq = wasm_string_eq(
                            (WASMString)wasm_stringref_obj_get_value(
                                stringref_obj1),
                            (WASMString)wasm_stringref_obj_get_value(
                                stringref_obj2));

                        PUSH_I32(is_eq);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRING_IS_USV_SEQUENCE:
                    {
                        int32 is_usv_sequence;

                        stringref_obj = POP_REF();

                        is_usv_sequence = wasm_string_is_usv_sequence(
                            (WASMString)wasm_stringref_obj_get_value(
                                stringref_obj));

                        PUSH_I32(is_usv_sequence);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRING_AS_WTF8:
                    {
                        stringref_obj = POP_REF();

                        str_obj = wasm_string_create_view(
                            (WASMString)wasm_stringref_obj_get_value(
                                stringref_obj),
                            STRING_VIEW_WTF8);
                        if (!str_obj) {
                            wasm_set_exception(module,
                                               "create string object failed");
                            goto got_exception;
                        }

                        SYNC_ALL_TO_FRAME();
                        stringview_wtf8_obj =
                            wasm_stringview_wtf8_obj_new(exec_env, str_obj);
                        if (!stringview_wtf8_obj) {
                            wasm_set_exception(module,
                                               "create stringview wtf8 failed");
                            goto got_exception;
                        }

                        PUSH_REF(stringview_wtf8_obj);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRINGVIEW_WTF8_ADVANCE:
                    {
                        uint32 next_pos, bytes, pos;

                        bytes = POP_I32();
                        pos = POP_I32();
                        stringview_wtf8_obj = POP_REF();

                        next_pos = wasm_string_advance(
                            (WASMString)wasm_stringview_wtf8_obj_get_value(
                                stringview_wtf8_obj),
                            pos, bytes, NULL);

                        PUSH_I32(next_pos);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRINGVIEW_WTF8_ENCODE_UTF8:
                    case WASM_OP_STRINGVIEW_WTF8_ENCODE_LOSSY_UTF8:
                    case WASM_OP_STRINGVIEW_WTF8_ENCODE_WTF8:
                    {
                        uint32 mem_idx, addr, pos, bytes, next_pos;
                        int32 bytes_written;
                        WASMMemoryInstance *memory_inst;
                        EncodingFlag flag = WTF8;

                        if (opcode == WASM_OP_STRINGVIEW_WTF8_ENCODE_UTF8) {
                            flag = UTF8;
                        }
                        else if (opcode
                                 == WASM_OP_STRINGVIEW_WTF8_ENCODE_LOSSY_UTF8) {
                            flag = LOSSY_UTF8;
                        }
                        else if (opcode
                                 == WASM_OP_STRINGVIEW_WTF8_ENCODE_WTF8) {
                            flag = WTF8;
                        }

                        read_leb_uint32(frame_ip, frame_ip_end, mem_idx);
                        bytes = POP_I32();
                        pos = POP_I32();
                        addr = POP_I32();
                        stringview_wtf8_obj = POP_REF();

                        memory_inst = module->memories[mem_idx];
                        maddr = memory_inst->memory_data + addr;

                        bytes_written = wasm_string_encode(
                            (WASMString)wasm_stringview_wtf8_obj_get_value(
                                stringview_wtf8_obj),
                            pos, bytes, maddr, &next_pos, flag);

                        if (bytes_written < 0) {
                            if (bytes_written == Isolated_Surrogate) {
                                wasm_set_exception(
                                    module, "isolated surrogate is seen");
                            }
                            else {
                                wasm_set_exception(module, "encode failed");
                            }

                            goto got_exception;
                        }

                        PUSH_I32(next_pos);
                        PUSH_I32(bytes_written);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRINGVIEW_WTF8_SLICE:
                    {
                        uint32 start, end;

                        end = POP_I32();
                        start = POP_I32();
                        stringview_wtf8_obj = POP_REF();

                        str_obj = wasm_string_slice(
                            (WASMString)wasm_stringview_wtf8_obj_get_value(
                                stringview_wtf8_obj),
                            start, end, STRING_VIEW_WTF8);
                        if (!str_obj) {
                            wasm_set_exception(module,
                                               "create string object failed");
                            goto got_exception;
                        }

                        SYNC_ALL_TO_FRAME();
                        stringref_obj =
                            wasm_stringref_obj_new(exec_env, str_obj);
                        if (!stringref_obj) {
                            wasm_set_exception(module,
                                               "create stringref failed");
                            goto got_exception;
                        }

                        PUSH_REF(stringref_obj);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRING_AS_WTF16:
                    {
                        stringref_obj = POP_REF();

                        str_obj = wasm_string_create_view(
                            (WASMString)wasm_stringref_obj_get_value(
                                stringref_obj),
                            STRING_VIEW_WTF16);
                        if (!str_obj) {
                            wasm_set_exception(module,
                                               "create string object failed");
                            goto got_exception;
                        }

                        SYNC_ALL_TO_FRAME();
                        stringview_wtf16_obj =
                            wasm_stringview_wtf16_obj_new(exec_env, str_obj);
                        if (!stringview_wtf16_obj) {
                            wasm_set_exception(
                                module, "create stringview wtf16 failed");
                            goto got_exception;
                        }

                        PUSH_REF(stringview_wtf16_obj);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRINGVIEW_WTF16_LENGTH:
                    {
                        int32 code_units_length;

                        stringview_wtf16_obj = POP_REF();

                        code_units_length = wasm_string_wtf16_get_length(
                            (WASMString)wasm_stringview_wtf16_obj_get_value(
                                stringview_wtf16_obj));

                        PUSH_I32(code_units_length);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRINGVIEW_WTF16_GET_CODEUNIT:
                    {
                        int32 pos;
                        uint32 code_unit;

                        pos = POP_I32();
                        stringview_wtf16_obj = POP_REF();

                        code_unit = (uint32)wasm_string_get_wtf16_codeunit(
                            (WASMString)wasm_stringview_wtf16_obj_get_value(
                                stringview_wtf16_obj),
                            pos);

                        PUSH_I32(code_unit);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRINGVIEW_WTF16_ENCODE:
                    {
                        uint32 mem_idx, addr, pos, len, offset = 0;
                        int32 written_code_units = 0;

                        read_leb_uint32(frame_ip, frame_ip_end, mem_idx);
                        len = POP_I32();
                        pos = POP_I32();
                        addr = POP_I32();
                        stringview_wtf16_obj = POP_REF();

                        CHECK_MEMORY_OVERFLOW(len * sizeof(uint16));

                        /* check 2-byte alignment */
                        if (((uintptr_t)maddr & (((uintptr_t)1 << 2) - 1))
                            != 0) {
                            wasm_set_exception(module,
                                               "unaligned memory access");
                            goto got_exception;
                        }

                        written_code_units = wasm_string_encode(
                            (WASMString)wasm_stringview_wtf16_obj_get_value(
                                stringview_wtf16_obj),
                            pos, len, maddr, NULL, WTF16);
                        if (written_code_units < 0) {
                            wasm_set_exception(module, "encode failed");
                            goto got_exception;
                        }

                        PUSH_I32(written_code_units);
                        (void)mem_idx;
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRINGVIEW_WTF16_SLICE:
                    {
                        uint32 start, end;

                        end = POP_I32();
                        start = POP_I32();
                        stringview_wtf16_obj = POP_REF();

                        str_obj = wasm_string_slice(
                            (WASMString)wasm_stringview_wtf16_obj_get_value(
                                stringview_wtf16_obj),
                            start, end, STRING_VIEW_WTF16);
                        if (!str_obj) {
                            wasm_set_exception(module,
                                               "create string object failed");
                            goto got_exception;
                        }

                        SYNC_ALL_TO_FRAME();
                        stringref_obj =
                            wasm_stringref_obj_new(exec_env, str_obj);
                        if (!stringref_obj) {
                            wasm_set_exception(module,
                                               "create stringref failed");
                            goto got_exception;
                        }

                        PUSH_REF(stringref_obj);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRING_AS_ITER:
                    {
                        stringref_obj = POP_REF();

                        str_obj = wasm_string_create_view(
                            (WASMString)wasm_stringref_obj_get_value(
                                stringref_obj),
                            STRING_VIEW_ITER);

                        if (!str_obj) {
                            wasm_set_exception(module,
                                               "create string object failed");
                            goto got_exception;
                        }

                        SYNC_ALL_TO_FRAME();
                        stringview_iter_obj =
                            wasm_stringview_iter_obj_new(exec_env, str_obj, 0);
                        if (!stringview_iter_obj) {
                            wasm_set_exception(module,
                                               "create stringview iter failed");
                            goto got_exception;
                        }

                        PUSH_REF(stringview_iter_obj);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRINGVIEW_ITER_NEXT:
                    {
                        uint32 code_point;

                        stringview_iter_obj = POP_REF();

                        code_point = wasm_string_next_codepoint(
                            (WASMString)wasm_stringview_iter_obj_get_value(
                                stringview_iter_obj),
                            wasm_stringview_iter_obj_get_pos(
                                stringview_iter_obj));

                        PUSH_I32(code_point);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRINGVIEW_ITER_ADVANCE:
                    case WASM_OP_STRINGVIEW_ITER_REWIND:
                    {
                        uint32 code_points_count, code_points_consumed = 0,
                                                  cur_pos, next_pos = 0;

                        code_points_count = POP_I32();
                        stringview_iter_obj = POP_REF();

                        str_obj =
                            (WASMString)wasm_stringview_iter_obj_get_value(
                                stringview_iter_obj);
                        cur_pos = wasm_stringview_iter_obj_get_pos(
                            stringview_iter_obj);

                        if (opcode == WASM_OP_STRINGVIEW_ITER_ADVANCE) {
                            next_pos = wasm_string_advance(
                                str_obj, cur_pos, code_points_count,
                                &code_points_consumed);
                        }
                        else if (opcode == WASM_OP_STRINGVIEW_ITER_REWIND) {
                            next_pos = wasm_string_rewind(
                                str_obj, cur_pos, code_points_count,
                                &code_points_consumed);
                        }

                        wasm_stringview_iter_obj_update_pos(stringview_iter_obj,
                                                            next_pos);

                        PUSH_I32(code_points_consumed);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRINGVIEW_ITER_SLICE:
                    {
                        uint32 code_points_count, cur_pos;

                        code_points_count = POP_I32();
                        stringview_iter_obj = POP_REF();

                        cur_pos = wasm_stringview_iter_obj_get_pos(
                            stringview_iter_obj);

                        str_obj = wasm_string_slice(
                            (WASMString)wasm_stringview_iter_obj_get_value(
                                stringview_iter_obj),
                            cur_pos, cur_pos + code_points_count,
                            STRING_VIEW_ITER);
                        if (!str_obj) {
                            wasm_set_exception(module,
                                               "create string object failed");
                            goto got_exception;
                        }

                        SYNC_ALL_TO_FRAME();
                        stringref_obj =
                            wasm_stringref_obj_new(exec_env, str_obj);
                        if (!stringref_obj) {
                            wasm_set_exception(module,
                                               "create stringref failed");
                            goto got_exception;
                        }

                        PUSH_REF(stringref_obj);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRING_NEW_UTF8_ARRAY:
                    case WASM_OP_STRING_NEW_WTF16_ARRAY:
                    case WASM_OP_STRING_NEW_LOSSY_UTF8_ARRAY:
                    case WASM_OP_STRING_NEW_WTF8_ARRAY:
                    {
                        uint32 start, end, array_len;
                        EncodingFlag flag = WTF8;
                        WASMArrayType *array_type;
                        void *arr_start_addr;

                        end = POP_I32();
                        start = POP_I32();
                        array_obj = POP_REF();

                        array_type = (WASMArrayType *)wasm_obj_get_defined_type(
                            (WASMObjectRef)array_obj);
                        arr_start_addr =
                            wasm_array_obj_elem_addr(array_obj, start);
                        array_len = wasm_array_obj_length(array_obj);

                        if (start > end || end > array_len) {
                            wasm_set_exception(module,
                                               "out of bounds array access");
                            goto got_exception;
                        }

                        if (opcode == WASM_OP_STRING_NEW_WTF16_ARRAY) {
                            if (array_type->elem_type != VALUE_TYPE_I16) {
                                wasm_set_exception(module,
                                                   "array type mismatch");
                                goto got_exception;
                            }
                            flag = WTF16;
                        }
                        else {
                            if (array_type->elem_type != VALUE_TYPE_I8) {
                                wasm_set_exception(module,
                                                   "array type mismatch");
                                goto got_exception;
                            }
                            if (opcode == WASM_OP_STRING_NEW_UTF8_ARRAY) {
                                flag = UTF8;
                            }
                            else if (opcode == WASM_OP_STRING_NEW_WTF8_ARRAY) {
                                flag = WTF8;
                            }
                            else if (opcode
                                     == WASM_OP_STRING_NEW_LOSSY_UTF8_ARRAY) {
                                flag = LOSSY_UTF8;
                            }
                        }

                        str_obj = wasm_string_new_with_encoding(
                            arr_start_addr, (end - start), flag);
                        if (!str_obj) {
                            wasm_set_exception(module,
                                               "create string object failed");
                            goto got_exception;
                        }

                        SYNC_ALL_TO_FRAME();
                        stringref_obj =
                            wasm_stringref_obj_new(exec_env, str_obj);
                        if (!stringref_obj) {
                            wasm_set_exception(module,
                                               "create stringref failed");
                            goto got_exception;
                        }

                        PUSH_REF(stringref_obj);
                        HANDLE_OP_END();
                    }
                    case WASM_OP_STRING_ENCODE_UTF8_ARRAY:
                    case WASM_OP_STRING_ENCODE_WTF16_ARRAY:
                    case WASM_OP_STRING_ENCODE_LOSSY_UTF8_ARRAY:
                    case WASM_OP_STRING_ENCODE_WTF8_ARRAY:
                    {
                        uint32 start, array_len, count;
                        int32 bytes_written;
                        EncodingFlag flag = WTF8;
                        WASMArrayType *array_type;
                        void *arr_start_addr;

                        start = POP_I32();
                        array_obj = POP_REF();
                        stringref_obj = POP_REF();

                        str_obj = (WASMString)wasm_stringref_obj_get_value(
                            stringref_obj);

                        array_type = (WASMArrayType *)wasm_obj_get_defined_type(
                            (WASMObjectRef)array_obj);
                        arr_start_addr =
                            wasm_array_obj_elem_addr(array_obj, start);
                        array_len = wasm_array_obj_length(array_obj);

                        if (start > array_len) {
                            wasm_set_exception(module,
                                               "out of bounds array access");
                            goto got_exception;
                        }

                        if (opcode == WASM_OP_STRING_ENCODE_WTF16_ARRAY) {
                            if (array_type->elem_type != VALUE_TYPE_I16) {
                                wasm_set_exception(module,
                                                   "array type mismatch");
                                goto got_exception;
                            }
                            flag = WTF16;
                        }
                        else {
                            if (array_type->elem_type != VALUE_TYPE_I8) {
                                wasm_set_exception(module,
                                                   "array type mismatch");
                                goto got_exception;
                            }
                            if (opcode == WASM_OP_STRING_ENCODE_UTF8_ARRAY) {
                                flag = UTF8;
                            }
                            else if (opcode
                                     == WASM_OP_STRING_ENCODE_WTF8_ARRAY) {
                                flag = WTF8;
                            }
                            else if (
                                opcode
                                == WASM_OP_STRING_ENCODE_LOSSY_UTF8_ARRAY) {
                                flag = LOSSY_UTF8;
                            }
                        }

                        count = wasm_string_measure(str_obj, flag);

                        bytes_written = wasm_string_encode(
                            str_obj, 0, count, arr_start_addr, NULL, flag);

                        if (bytes_written < 0) {
                            if (bytes_written == Isolated_Surrogate) {
                                wasm_set_exception(
                                    module, "isolated surrogate is seen");
                            }
                            else if (bytes_written == Insufficient_Space) {
                                wasm_set_exception(
                                    module, "array space is insufficient");
                            }
                            else {
                                wasm_set_exception(module, "encode failed");
                            }

                            goto got_exception;
                        }

                        PUSH_I32(bytes_written);
                        HANDLE_OP_END();
                    }
#endif /* end of WASM_ENABLE_STRINGREF != 0 */
                    default:
                    {
                        wasm_set_exception(module, "unsupported opcode");
                        goto got_exception;
                    }
                }
            }
#endif /* end of WASM_ENABLE_GC != 0 */

            /* variable instructions */
            HANDLE_OP(WASM_OP_GET_LOCAL)
            {
                GET_LOCAL_INDEX_TYPE_AND_OFFSET();

                switch (local_type) {
                    case VALUE_TYPE_I32:
                    case VALUE_TYPE_F32:
#if WASM_ENABLE_REF_TYPES != 0 && WASM_ENABLE_GC == 0
                    case VALUE_TYPE_FUNCREF:
                    case VALUE_TYPE_EXTERNREF:
#endif
                        PUSH_I32(*(int32 *)(frame_lp + local_offset));
                        break;
                    case VALUE_TYPE_I64:
                    case VALUE_TYPE_F64:
                        PUSH_I64(GET_I64_FROM_ADDR(frame_lp + local_offset));
                        break;
                    default:
#if WASM_ENABLE_GC != 0
                        if (wasm_is_type_reftype(local_type)) {
                            if (wasm_is_reftype_i31ref(local_type)) {
                                PUSH_I31REF(
                                    GET_REF_FROM_ADDR(frame_lp + local_offset));
                            }
                            else {
                                PUSH_REF(
                                    GET_REF_FROM_ADDR(frame_lp + local_offset));
                            }
                        }
                        else
#endif
                        {
                            wasm_set_exception(module, "invalid local type");
                            goto got_exception;
                        }
                }

                HANDLE_OP_END();
            }

            HANDLE_OP(EXT_OP_GET_LOCAL_FAST)
            {
                local_offset = *frame_ip++;
                if (local_offset & 0x80)
                    PUSH_I64(
                        GET_I64_FROM_ADDR(frame_lp + (local_offset & 0x7F)));
                else
                    PUSH_I32(*(int32 *)(frame_lp + local_offset));
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_SET_LOCAL)
            {
                GET_LOCAL_INDEX_TYPE_AND_OFFSET();

                switch (local_type) {
                    case VALUE_TYPE_I32:
                    case VALUE_TYPE_F32:
#if WASM_ENABLE_REF_TYPES != 0 && WASM_ENABLE_GC == 0
                    case VALUE_TYPE_FUNCREF:
                    case VALUE_TYPE_EXTERNREF:
#endif
                        *(int32 *)(frame_lp + local_offset) = POP_I32();
                        break;
                    case VALUE_TYPE_I64:
                    case VALUE_TYPE_F64:
                        PUT_I64_TO_ADDR((uint32 *)(frame_lp + local_offset),
                                        POP_I64());
                        break;
                    default:
#if WASM_ENABLE_GC != 0
                        if (wasm_is_type_reftype(local_type)) {
                            PUT_REF_TO_ADDR(frame_lp + local_offset, POP_REF());
                        }
                        else
#endif
                        {
                            wasm_set_exception(module, "invalid local type");
                            goto got_exception;
                        }
                }

                HANDLE_OP_END();
            }

            HANDLE_OP(EXT_OP_SET_LOCAL_FAST)
            {
                local_offset = *frame_ip++;
                if (local_offset & 0x80)
                    PUT_I64_TO_ADDR(
                        (uint32 *)(frame_lp + (local_offset & 0x7F)),
                        POP_I64());
                else
                    *(int32 *)(frame_lp + local_offset) = POP_I32();
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_TEE_LOCAL)
            {
                GET_LOCAL_INDEX_TYPE_AND_OFFSET();

                switch (local_type) {
                    case VALUE_TYPE_I32:
                    case VALUE_TYPE_F32:
#if WASM_ENABLE_REF_TYPES != 0 && WASM_ENABLE_GC == 0
                    case VALUE_TYPE_FUNCREF:
                    case VALUE_TYPE_EXTERNREF:
#endif
                        *(int32 *)(frame_lp + local_offset) =
                            *(int32 *)(frame_sp - 1);
                        break;
                    case VALUE_TYPE_I64:
                    case VALUE_TYPE_F64:
                        PUT_I64_TO_ADDR((uint32 *)(frame_lp + local_offset),
                                        GET_I64_FROM_ADDR(frame_sp - 2));
                        break;
                    default:
#if WASM_ENABLE_GC != 0
                        if (wasm_is_type_reftype(local_type)) {
                            PUT_REF_TO_ADDR(
                                frame_lp + local_offset,
                                GET_REF_FROM_ADDR(frame_sp - REF_CELL_NUM));
                        }
                        else
#endif
                        {
                            wasm_set_exception(module, "invalid local type");
                            goto got_exception;
                        }
                }

                HANDLE_OP_END();
            }

            HANDLE_OP(EXT_OP_TEE_LOCAL_FAST)
            {
                local_offset = *frame_ip++;
                if (local_offset & 0x80)
                    PUT_I64_TO_ADDR(
                        (uint32 *)(frame_lp + (local_offset & 0x7F)),
                        GET_I64_FROM_ADDR(frame_sp - 2));
                else
                    *(int32 *)(frame_lp + local_offset) =
                        *(int32 *)(frame_sp - 1);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_GET_GLOBAL)
            {
                read_leb_uint32(frame_ip, frame_ip_end, global_idx);
                bh_assert(global_idx < module->e->global_count);
                global = globals + global_idx;
                global_addr = get_global_addr(global_data, global);
                /* clang-format off */
#if WASM_ENABLE_GC == 0
                PUSH_I32(*(uint32 *)global_addr);
#else
                if (!wasm_is_type_reftype(global->type)) {
                    PUSH_I32(*(uint32 *)global_addr);
                }
                else if (wasm_is_reftype_i31ref(global->type)) {
                    PUSH_I31REF(GET_REF_FROM_ADDR((uint32 *)global_addr));
                }
                else {
                    PUSH_REF(GET_REF_FROM_ADDR((uint32 *)global_addr));
                }
#endif
                /* clang-format on */
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_GET_GLOBAL_64)
            {
                read_leb_uint32(frame_ip, frame_ip_end, global_idx);
                bh_assert(global_idx < module->e->global_count);
                global = globals + global_idx;
                global_addr = get_global_addr(global_data, global);
                PUSH_I64(GET_I64_FROM_ADDR((uint32 *)global_addr));
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_SET_GLOBAL)
            {
                read_leb_uint32(frame_ip, frame_ip_end, global_idx);
                bh_assert(global_idx < module->e->global_count);
                global = globals + global_idx;
                global_addr = get_global_addr(global_data, global);
                /* clang-format off */
#if WASM_ENABLE_GC == 0
                *(int32 *)global_addr = POP_I32();
#else
                if (!wasm_is_type_reftype(global->type))
                    *(int32 *)global_addr = POP_I32();
                else
                    PUT_REF_TO_ADDR((uint32 *)global_addr, POP_REF());
#endif
                /* clang-format on */
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_SET_GLOBAL_AUX_STACK)
            {
                uint64 aux_stack_top;

                read_leb_uint32(frame_ip, frame_ip_end, global_idx);
                bh_assert(global_idx < module->e->global_count);
                global = globals + global_idx;
                global_addr = get_global_addr(global_data, global);
#if WASM_ENABLE_MEMORY64 != 0
                if (is_memory64) {
                    aux_stack_top = *(uint64 *)(frame_sp - 2);
                }
                else
#endif
                {
                    aux_stack_top = (uint64)(*(uint32 *)(frame_sp - 1));
                }
                if (aux_stack_top <= (uint64)exec_env->aux_stack_boundary) {
                    wasm_set_exception(module, "wasm auxiliary stack overflow");
                    goto got_exception;
                }
                if (aux_stack_top > (uint64)exec_env->aux_stack_bottom) {
                    wasm_set_exception(module,
                                       "wasm auxiliary stack underflow");
                    goto got_exception;
                }
#if WASM_ENABLE_MEMORY64 != 0
                if (is_memory64) {
                    *(uint64 *)global_addr = aux_stack_top;
                    frame_sp -= 2;
                }
                else
#endif
                {
                    *(uint32 *)global_addr = (uint32)aux_stack_top;
                    frame_sp--;
                }
#if WASM_ENABLE_MEMORY_PROFILING != 0
                if (module->module->aux_stack_top_global_index != (uint32)-1) {
                    uint32 aux_stack_used =
                        (uint32)(module->module->aux_stack_bottom
                                 - *(uint32 *)global_addr);
                    if (aux_stack_used > module->e->max_aux_stack_used)
                        module->e->max_aux_stack_used = aux_stack_used;
                }
#endif
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_SET_GLOBAL_64)
            {
                read_leb_uint32(frame_ip, frame_ip_end, global_idx);
                bh_assert(global_idx < module->e->global_count);
                global = globals + global_idx;
                global_addr = get_global_addr(global_data, global);
                PUT_I64_TO_ADDR((uint32 *)global_addr, POP_I64());
                HANDLE_OP_END();
            }

            /* memory load instructions */
            HANDLE_OP(WASM_OP_I32_LOAD)
            HANDLE_OP(WASM_OP_F32_LOAD)
            {
                uint32 flags;
                mem_offset_t offset, addr;

                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                addr = POP_MEM_OFFSET();
                CHECK_MEMORY_OVERFLOW(4);
                PUSH_I32(LOAD_I32(maddr));
                CHECK_READ_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_LOAD)
            HANDLE_OP(WASM_OP_F64_LOAD)
            {
                uint32 flags;
                mem_offset_t offset, addr;

                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                addr = POP_MEM_OFFSET();
                CHECK_MEMORY_OVERFLOW(8);
                PUSH_I64(LOAD_I64(maddr));
                CHECK_READ_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_LOAD8_S)
            {
                uint32 flags;
                mem_offset_t offset, addr;

                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                addr = POP_MEM_OFFSET();
                CHECK_MEMORY_OVERFLOW(1);
                PUSH_I32(sign_ext_8_32(*(int8 *)maddr));
                CHECK_READ_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_LOAD8_U)
            {
                uint32 flags;
                mem_offset_t offset, addr;

                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                addr = POP_MEM_OFFSET();
                CHECK_MEMORY_OVERFLOW(1);
                PUSH_I32((uint32)(*(uint8 *)maddr));
                CHECK_READ_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_LOAD16_S)
            {
                uint32 flags;
                mem_offset_t offset, addr;

                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                addr = POP_MEM_OFFSET();
                CHECK_MEMORY_OVERFLOW(2);
                PUSH_I32(sign_ext_16_32(LOAD_I16(maddr)));
                CHECK_READ_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_LOAD16_U)
            {
                uint32 flags;
                mem_offset_t offset, addr;

                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                addr = POP_MEM_OFFSET();
                CHECK_MEMORY_OVERFLOW(2);
                PUSH_I32((uint32)(LOAD_U16(maddr)));
                CHECK_READ_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_LOAD8_S)
            {
                uint32 flags;
                mem_offset_t offset, addr;

                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                addr = POP_MEM_OFFSET();
                CHECK_MEMORY_OVERFLOW(1);
                PUSH_I64(sign_ext_8_64(*(int8 *)maddr));
                CHECK_READ_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_LOAD8_U)
            {
                uint32 flags;
                mem_offset_t offset, addr;

                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                addr = POP_MEM_OFFSET();
                CHECK_MEMORY_OVERFLOW(1);
                PUSH_I64((uint64)(*(uint8 *)maddr));
                CHECK_READ_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_LOAD16_S)
            {
                uint32 flags;
                mem_offset_t offset, addr;

                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                addr = POP_MEM_OFFSET();
                CHECK_MEMORY_OVERFLOW(2);
                PUSH_I64(sign_ext_16_64(LOAD_I16(maddr)));
                CHECK_READ_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_LOAD16_U)
            {
                uint32 flags;
                mem_offset_t offset, addr;

                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                addr = POP_MEM_OFFSET();
                CHECK_MEMORY_OVERFLOW(2);
                PUSH_I64((uint64)(LOAD_U16(maddr)));
                CHECK_READ_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_LOAD32_S)
            {
                uint32 flags;
                mem_offset_t offset, addr;

                opcode = *(frame_ip - 1);
                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                addr = POP_MEM_OFFSET();
                CHECK_MEMORY_OVERFLOW(4);
                PUSH_I64(sign_ext_32_64(LOAD_I32(maddr)));
                CHECK_READ_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_LOAD32_U)
            {
                uint32 flags;
                mem_offset_t offset, addr;

                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                addr = POP_MEM_OFFSET();
                CHECK_MEMORY_OVERFLOW(4);
                PUSH_I64((uint64)(LOAD_U32(maddr)));
                CHECK_READ_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            /* memory store instructions */
            HANDLE_OP(WASM_OP_I32_STORE)
            HANDLE_OP(WASM_OP_F32_STORE)
            {
                uint32 flags;
                mem_offset_t offset, addr;

                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                frame_sp--;
                addr = POP_MEM_OFFSET();
                CHECK_MEMORY_OVERFLOW(4);
#if WASM_ENABLE_MEMORY64 != 0
                if (is_memory64) {
                    STORE_U32(maddr, frame_sp[2]);
                }
                else
#endif
                {
                    STORE_U32(maddr, frame_sp[1]);
                }
                CHECK_WRITE_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_STORE)
            HANDLE_OP(WASM_OP_F64_STORE)
            {
                uint32 flags;
                mem_offset_t offset, addr;

                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                frame_sp -= 2;
                addr = POP_MEM_OFFSET();
                CHECK_MEMORY_OVERFLOW(8);

#if WASM_ENABLE_MEMORY64 != 0
                if (is_memory64) {
                    PUT_I64_TO_ADDR((mem_offset_t *)maddr,
                                    GET_I64_FROM_ADDR(frame_sp + 2));
                }
                else
#endif
                {
                    PUT_I64_TO_ADDR((uint32 *)maddr,
                                    GET_I64_FROM_ADDR(frame_sp + 1));
                }
                CHECK_WRITE_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_STORE8)
            HANDLE_OP(WASM_OP_I32_STORE16)
            {
                uint32 flags;
                mem_offset_t offset, addr;
                uint32 sval;

                opcode = *(frame_ip - 1);
                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                sval = (uint32)POP_I32();
                addr = POP_MEM_OFFSET();

                if (opcode == WASM_OP_I32_STORE8) {
                    CHECK_MEMORY_OVERFLOW(1);
                    *(uint8 *)maddr = (uint8)sval;
                }
                else {
                    CHECK_MEMORY_OVERFLOW(2);
                    STORE_U16(maddr, (uint16)sval);
                }
                CHECK_WRITE_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_STORE8)
            HANDLE_OP(WASM_OP_I64_STORE16)
            HANDLE_OP(WASM_OP_I64_STORE32)
            {
                uint32 flags;
                mem_offset_t offset, addr;
                uint64 sval;

                opcode = *(frame_ip - 1);
                read_leb_uint32(frame_ip, frame_ip_end, flags);
                read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                sval = (uint64)POP_I64();
                addr = POP_MEM_OFFSET();

                if (opcode == WASM_OP_I64_STORE8) {
                    CHECK_MEMORY_OVERFLOW(1);
                    *(uint8 *)maddr = (uint8)sval;
                }
                else if (opcode == WASM_OP_I64_STORE16) {
                    CHECK_MEMORY_OVERFLOW(2);
                    STORE_U16(maddr, (uint16)sval);
                }
                else {
                    CHECK_MEMORY_OVERFLOW(4);
                    STORE_U32(maddr, (uint32)sval);
                }
                CHECK_WRITE_WATCHPOINT(addr, offset);
                (void)flags;
                HANDLE_OP_END();
            }

            /* memory size and memory grow instructions */
            HANDLE_OP(WASM_OP_MEMORY_SIZE)
            {
                uint32 reserved;
                read_leb_uint32(frame_ip, frame_ip_end, reserved);
                PUSH_PAGE_COUNT(memory->cur_page_count);
                (void)reserved;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_MEMORY_GROW)
            {
                uint32 reserved, delta,
                    prev_page_count = memory->cur_page_count;

                read_leb_uint32(frame_ip, frame_ip_end, reserved);
                delta = (uint32)POP_PAGE_COUNT();

                if (!wasm_enlarge_memory(module, delta)) {
                    /* failed to memory.grow, return -1 */
                    PUSH_PAGE_COUNT(-1);
                }
                else {
                    /* success, return previous page count */
                    PUSH_PAGE_COUNT(prev_page_count);
                    /* update memory size, no need to update memory ptr as
                       it isn't changed in wasm_enlarge_memory */
#if !defined(OS_ENABLE_HW_BOUND_CHECK)              \
    || WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0 \
    || WASM_ENABLE_BULK_MEMORY != 0
                    linear_mem_size = GET_LINEAR_MEMORY_SIZE(memory);
#endif
                }

                (void)reserved;
                HANDLE_OP_END();
            }

            /* constant instructions */
            HANDLE_OP(WASM_OP_I32_CONST)
            DEF_OP_I_CONST(int32, I32);
            HANDLE_OP_END();

            HANDLE_OP(WASM_OP_I64_CONST)
            DEF_OP_I_CONST(int64, I64);
            HANDLE_OP_END();

            HANDLE_OP(WASM_OP_F32_CONST)
            {
                uint8 *p_float = (uint8 *)frame_sp++;
                for (i = 0; i < sizeof(float32); i++)
                    *p_float++ = *frame_ip++;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_CONST)
            {
                uint8 *p_float = (uint8 *)frame_sp++;
                frame_sp++;
                for (i = 0; i < sizeof(float64); i++)
                    *p_float++ = *frame_ip++;
                HANDLE_OP_END();
            }

            /* comparison instructions of i32 */
            HANDLE_OP(WASM_OP_I32_EQZ)
            {
                DEF_OP_EQZ(I32);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_EQ)
            {
                DEF_OP_CMP(uint32, I32, ==);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_NE)
            {
                DEF_OP_CMP(uint32, I32, !=);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_LT_S)
            {
                DEF_OP_CMP(int32, I32, <);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_LT_U)
            {
                DEF_OP_CMP(uint32, I32, <);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_GT_S)
            {
                DEF_OP_CMP(int32, I32, >);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_GT_U)
            {
                DEF_OP_CMP(uint32, I32, >);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_LE_S)
            {
                DEF_OP_CMP(int32, I32, <=);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_LE_U)
            {
                DEF_OP_CMP(uint32, I32, <=);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_GE_S)
            {
                DEF_OP_CMP(int32, I32, >=);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_GE_U)
            {
                DEF_OP_CMP(uint32, I32, >=);
                HANDLE_OP_END();
            }

            /* comparison instructions of i64 */
            HANDLE_OP(WASM_OP_I64_EQZ)
            {
                DEF_OP_EQZ(I64);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_EQ)
            {
                DEF_OP_CMP(uint64, I64, ==);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_NE)
            {
                DEF_OP_CMP(uint64, I64, !=);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_LT_S)
            {
                DEF_OP_CMP(int64, I64, <);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_LT_U)
            {
                DEF_OP_CMP(uint64, I64, <);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_GT_S)
            {
                DEF_OP_CMP(int64, I64, >);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_GT_U)
            {
                DEF_OP_CMP(uint64, I64, >);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_LE_S)
            {
                DEF_OP_CMP(int64, I64, <=);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_LE_U)
            {
                DEF_OP_CMP(uint64, I64, <=);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_GE_S)
            {
                DEF_OP_CMP(int64, I64, >=);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_GE_U)
            {
                DEF_OP_CMP(uint64, I64, >=);
                HANDLE_OP_END();
            }

            /* comparison instructions of f32 */
            HANDLE_OP(WASM_OP_F32_EQ)
            {
                DEF_OP_CMP(float32, F32, ==);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_NE)
            {
                DEF_OP_CMP(float32, F32, !=);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_LT)
            {
                DEF_OP_CMP(float32, F32, <);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_GT)
            {
                DEF_OP_CMP(float32, F32, >);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_LE)
            {
                DEF_OP_CMP(float32, F32, <=);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_GE)
            {
                DEF_OP_CMP(float32, F32, >=);
                HANDLE_OP_END();
            }

            /* comparison instructions of f64 */
            HANDLE_OP(WASM_OP_F64_EQ)
            {
                DEF_OP_CMP(float64, F64, ==);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_NE)
            {
                DEF_OP_CMP(float64, F64, !=);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_LT)
            {
                DEF_OP_CMP(float64, F64, <);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_GT)
            {
                DEF_OP_CMP(float64, F64, >);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_LE)
            {
                DEF_OP_CMP(float64, F64, <=);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_GE)
            {
                DEF_OP_CMP(float64, F64, >=);
                HANDLE_OP_END();
            }

            /* numberic instructions of i32 */
            HANDLE_OP(WASM_OP_I32_CLZ)
            {
                DEF_OP_BIT_COUNT(uint32, I32, clz32);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_CTZ)
            {
                DEF_OP_BIT_COUNT(uint32, I32, ctz32);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_POPCNT)
            {
                DEF_OP_BIT_COUNT(uint32, I32, popcount32);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_ADD)
            {
                DEF_OP_NUMERIC(uint32, uint32, I32, +);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_SUB)
            {
                DEF_OP_NUMERIC(uint32, uint32, I32, -);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_MUL)
            {
                DEF_OP_NUMERIC(uint32, uint32, I32, *);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_DIV_S)
            {
                int32 a, b;

                b = POP_I32();
                a = POP_I32();
                if (a == (int32)0x80000000 && b == -1) {
                    wasm_set_exception(module, "integer overflow");
                    goto got_exception;
                }
                if (b == 0) {
                    wasm_set_exception(module, "integer divide by zero");
                    goto got_exception;
                }
                PUSH_I32(a / b);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_DIV_U)
            {
                uint32 a, b;

                b = (uint32)POP_I32();
                a = (uint32)POP_I32();
                if (b == 0) {
                    wasm_set_exception(module, "integer divide by zero");
                    goto got_exception;
                }
                PUSH_I32(a / b);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_REM_S)
            {
                int32 a, b;

                b = POP_I32();
                a = POP_I32();
                if (a == (int32)0x80000000 && b == -1) {
                    PUSH_I32(0);
                    HANDLE_OP_END();
                }
                if (b == 0) {
                    wasm_set_exception(module, "integer divide by zero");
                    goto got_exception;
                }
                PUSH_I32(a % b);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_REM_U)
            {
                uint32 a, b;

                b = (uint32)POP_I32();
                a = (uint32)POP_I32();
                if (b == 0) {
                    wasm_set_exception(module, "integer divide by zero");
                    goto got_exception;
                }
                PUSH_I32(a % b);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_AND)
            {
                DEF_OP_NUMERIC(uint32, uint32, I32, &);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_OR)
            {
                DEF_OP_NUMERIC(uint32, uint32, I32, |);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_XOR)
            {
                DEF_OP_NUMERIC(uint32, uint32, I32, ^);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_SHL)
            {
                DEF_OP_NUMERIC2(uint32, uint32, I32, <<);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_SHR_S)
            {
                DEF_OP_NUMERIC2(int32, uint32, I32, >>);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_SHR_U)
            {
                DEF_OP_NUMERIC2(uint32, uint32, I32, >>);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_ROTL)
            {
                uint32 a, b;

                b = (uint32)POP_I32();
                a = (uint32)POP_I32();
                PUSH_I32(rotl32(a, b));
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_ROTR)
            {
                uint32 a, b;

                b = (uint32)POP_I32();
                a = (uint32)POP_I32();
                PUSH_I32(rotr32(a, b));
                HANDLE_OP_END();
            }

            /* numberic instructions of i64 */
            HANDLE_OP(WASM_OP_I64_CLZ)
            {
                DEF_OP_BIT_COUNT(uint64, I64, clz64);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_CTZ)
            {
                DEF_OP_BIT_COUNT(uint64, I64, ctz64);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_POPCNT)
            {
                DEF_OP_BIT_COUNT(uint64, I64, popcount64);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_ADD)
            {
                DEF_OP_NUMERIC_64(uint64, uint64, I64, +);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_SUB)
            {
                DEF_OP_NUMERIC_64(uint64, uint64, I64, -);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_MUL)
            {
                DEF_OP_NUMERIC_64(uint64, uint64, I64, *);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_DIV_S)
            {
                int64 a, b;

                b = POP_I64();
                a = POP_I64();
                if (a == (int64)0x8000000000000000LL && b == -1) {
                    wasm_set_exception(module, "integer overflow");
                    goto got_exception;
                }
                if (b == 0) {
                    wasm_set_exception(module, "integer divide by zero");
                    goto got_exception;
                }
                PUSH_I64(a / b);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_DIV_U)
            {
                uint64 a, b;

                b = (uint64)POP_I64();
                a = (uint64)POP_I64();
                if (b == 0) {
                    wasm_set_exception(module, "integer divide by zero");
                    goto got_exception;
                }
                PUSH_I64(a / b);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_REM_S)
            {
                int64 a, b;

                b = POP_I64();
                a = POP_I64();
                if (a == (int64)0x8000000000000000LL && b == -1) {
                    PUSH_I64(0);
                    HANDLE_OP_END();
                }
                if (b == 0) {
                    wasm_set_exception(module, "integer divide by zero");
                    goto got_exception;
                }
                PUSH_I64(a % b);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_REM_U)
            {
                uint64 a, b;

                b = (uint64)POP_I64();
                a = (uint64)POP_I64();
                if (b == 0) {
                    wasm_set_exception(module, "integer divide by zero");
                    goto got_exception;
                }
                PUSH_I64(a % b);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_AND)
            {
                DEF_OP_NUMERIC_64(uint64, uint64, I64, &);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_OR)
            {
                DEF_OP_NUMERIC_64(uint64, uint64, I64, |);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_XOR)
            {
                DEF_OP_NUMERIC_64(uint64, uint64, I64, ^);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_SHL)
            {
                DEF_OP_NUMERIC2_64(uint64, uint64, I64, <<);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_SHR_S)
            {
                DEF_OP_NUMERIC2_64(int64, uint64, I64, >>);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_SHR_U)
            {
                DEF_OP_NUMERIC2_64(uint64, uint64, I64, >>);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_ROTL)
            {
                uint64 a, b;

                b = (uint64)POP_I64();
                a = (uint64)POP_I64();
                PUSH_I64(rotl64(a, b));
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_ROTR)
            {
                uint64 a, b;

                b = (uint64)POP_I64();
                a = (uint64)POP_I64();
                PUSH_I64(rotr64(a, b));
                HANDLE_OP_END();
            }

            /* numberic instructions of f32 */
            HANDLE_OP(WASM_OP_F32_ABS)
            {
                DEF_OP_MATH(float32, F32, fabsf);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_NEG)
            {
                uint32 u32 = frame_sp[-1];
                uint32 sign_bit = u32 & ((uint32)1 << 31);
                if (sign_bit)
                    frame_sp[-1] = u32 & ~((uint32)1 << 31);
                else
                    frame_sp[-1] = u32 | ((uint32)1 << 31);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_CEIL)
            {
                DEF_OP_MATH(float32, F32, ceilf);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_FLOOR)
            {
                DEF_OP_MATH(float32, F32, floorf);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_TRUNC)
            {
                DEF_OP_MATH(float32, F32, truncf);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_NEAREST)
            {
                DEF_OP_MATH(float32, F32, rintf);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_SQRT)
            {
                DEF_OP_MATH(float32, F32, sqrtf);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_ADD)
            {
                DEF_OP_NUMERIC(float32, float32, F32, +);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_SUB)
            {
                DEF_OP_NUMERIC(float32, float32, F32, -);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_MUL)
            {
                DEF_OP_NUMERIC(float32, float32, F32, *);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_DIV)
            {
                DEF_OP_NUMERIC(float32, float32, F32, /);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_MIN)
            {
                float32 a, b;

                b = POP_F32();
                a = POP_F32();

                PUSH_F32(f32_min(a, b));
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_MAX)
            {
                float32 a, b;

                b = POP_F32();
                a = POP_F32();

                PUSH_F32(f32_max(a, b));
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_COPYSIGN)
            {
                float32 a, b;

                b = POP_F32();
                a = POP_F32();
                PUSH_F32(local_copysignf(a, b));
                HANDLE_OP_END();
            }

            /* numberic instructions of f64 */
            HANDLE_OP(WASM_OP_F64_ABS)
            {
                DEF_OP_MATH(float64, F64, fabs);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_NEG)
            {
                uint64 u64 = GET_I64_FROM_ADDR(frame_sp - 2);
                uint64 sign_bit = u64 & (((uint64)1) << 63);
                if (sign_bit)
                    PUT_I64_TO_ADDR(frame_sp - 2, (u64 & ~(((uint64)1) << 63)));
                else
                    PUT_I64_TO_ADDR(frame_sp - 2, (u64 | (((uint64)1) << 63)));
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_CEIL)
            {
                DEF_OP_MATH(float64, F64, ceil);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_FLOOR)
            {
                DEF_OP_MATH(float64, F64, floor);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_TRUNC)
            {
                DEF_OP_MATH(float64, F64, trunc);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_NEAREST)
            {
                DEF_OP_MATH(float64, F64, rint);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_SQRT)
            {
                DEF_OP_MATH(float64, F64, sqrt);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_ADD)
            {
                DEF_OP_NUMERIC_64(float64, float64, F64, +);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_SUB)
            {
                DEF_OP_NUMERIC_64(float64, float64, F64, -);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_MUL)
            {
                DEF_OP_NUMERIC_64(float64, float64, F64, *);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_DIV)
            {
                DEF_OP_NUMERIC_64(float64, float64, F64, /);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_MIN)
            {
                float64 a, b;

                b = POP_F64();
                a = POP_F64();

                PUSH_F64(f64_min(a, b));
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_MAX)
            {
                float64 a, b;

                b = POP_F64();
                a = POP_F64();

                PUSH_F64(f64_max(a, b));
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_COPYSIGN)
            {
                float64 a, b;

                b = POP_F64();
                a = POP_F64();
                PUSH_F64(local_copysign(a, b));
                HANDLE_OP_END();
            }

            /* conversions of i32 */
            HANDLE_OP(WASM_OP_I32_WRAP_I64)
            {
                int32 value = (int32)(POP_I64() & 0xFFFFFFFFLL);
                PUSH_I32(value);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_TRUNC_S_F32)
            {
                /* We don't use INT32_MIN/INT32_MAX/UINT32_MIN/UINT32_MAX,
                   since float/double values of ieee754 cannot precisely
                   represent all int32/uint32/int64/uint64 values, e.g.
                   UINT32_MAX is 4294967295, but (float32)4294967295 is
                   4294967296.0f, but not 4294967295.0f. */
                DEF_OP_TRUNC_F32(-2147483904.0f, 2147483648.0f, true, true);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_TRUNC_U_F32)
            {
                DEF_OP_TRUNC_F32(-1.0f, 4294967296.0f, true, false);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_TRUNC_S_F64)
            {
                DEF_OP_TRUNC_F64(-2147483649.0, 2147483648.0, true, true);
                /* frame_sp can't be moved in trunc function, we need to
                  manually adjust it if src and dst op's cell num is
                  different */
                frame_sp--;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_TRUNC_U_F64)
            {
                DEF_OP_TRUNC_F64(-1.0, 4294967296.0, true, false);
                frame_sp--;
                HANDLE_OP_END();
            }

            /* conversions of i64 */
            HANDLE_OP(WASM_OP_I64_EXTEND_S_I32)
            {
                DEF_OP_CONVERT(int64, I64, int32, I32);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_EXTEND_U_I32)
            {
                DEF_OP_CONVERT(int64, I64, uint32, I32);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_TRUNC_S_F32)
            {
                DEF_OP_TRUNC_F32(-9223373136366403584.0f,
                                 9223372036854775808.0f, false, true);
                frame_sp++;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_TRUNC_U_F32)
            {
                DEF_OP_TRUNC_F32(-1.0f, 18446744073709551616.0f, false, false);
                frame_sp++;
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_TRUNC_S_F64)
            {
                DEF_OP_TRUNC_F64(-9223372036854777856.0, 9223372036854775808.0,
                                 false, true);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_TRUNC_U_F64)
            {
                DEF_OP_TRUNC_F64(-1.0, 18446744073709551616.0, false, false);
                HANDLE_OP_END();
            }

            /* conversions of f32 */
            HANDLE_OP(WASM_OP_F32_CONVERT_S_I32)
            {
                DEF_OP_CONVERT(float32, F32, int32, I32);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_CONVERT_U_I32)
            {
                DEF_OP_CONVERT(float32, F32, uint32, I32);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_CONVERT_S_I64)
            {
                DEF_OP_CONVERT(float32, F32, int64, I64);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_CONVERT_U_I64)
            {
                DEF_OP_CONVERT(float32, F32, uint64, I64);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F32_DEMOTE_F64)
            {
                DEF_OP_CONVERT(float32, F32, float64, F64);
                HANDLE_OP_END();
            }

            /* conversions of f64 */
            HANDLE_OP(WASM_OP_F64_CONVERT_S_I32)
            {
                DEF_OP_CONVERT(float64, F64, int32, I32);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_CONVERT_U_I32)
            {
                DEF_OP_CONVERT(float64, F64, uint32, I32);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_CONVERT_S_I64)
            {
                DEF_OP_CONVERT(float64, F64, int64, I64);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_CONVERT_U_I64)
            {
                DEF_OP_CONVERT(float64, F64, uint64, I64);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_F64_PROMOTE_F32)
            {
                DEF_OP_CONVERT(float64, F64, float32, F32);
                HANDLE_OP_END();
            }

            /* reinterpretations */
            HANDLE_OP(WASM_OP_I32_REINTERPRET_F32)
            HANDLE_OP(WASM_OP_I64_REINTERPRET_F64)
            HANDLE_OP(WASM_OP_F32_REINTERPRET_I32)
            HANDLE_OP(WASM_OP_F64_REINTERPRET_I64) { HANDLE_OP_END(); }

            HANDLE_OP(WASM_OP_I32_EXTEND8_S)
            {
                DEF_OP_CONVERT(int32, I32, int8, I32);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I32_EXTEND16_S)
            {
                DEF_OP_CONVERT(int32, I32, int16, I32);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_EXTEND8_S)
            {
                DEF_OP_CONVERT(int64, I64, int8, I64);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_EXTEND16_S)
            {
                DEF_OP_CONVERT(int64, I64, int16, I64);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_I64_EXTEND32_S)
            {
                DEF_OP_CONVERT(int64, I64, int32, I64);
                HANDLE_OP_END();
            }

            HANDLE_OP(WASM_OP_MISC_PREFIX)
            {
                uint32 opcode1;

                read_leb_uint32(frame_ip, frame_ip_end, opcode1);
                /* opcode1 was checked in loader and is no larger than
                   UINT8_MAX */
                opcode = (uint8)opcode1;

                switch (opcode) {
                    case WASM_OP_I32_TRUNC_SAT_S_F32:
                        DEF_OP_TRUNC_SAT_F32(-2147483904.0f, 2147483648.0f,
                                             true, true);
                        break;
                    case WASM_OP_I32_TRUNC_SAT_U_F32:
                        DEF_OP_TRUNC_SAT_F32(-1.0f, 4294967296.0f, true, false);
                        break;
                    case WASM_OP_I32_TRUNC_SAT_S_F64:
                        DEF_OP_TRUNC_SAT_F64(-2147483649.0, 2147483648.0, true,
                                             true);
                        frame_sp--;
                        break;
                    case WASM_OP_I32_TRUNC_SAT_U_F64:
                        DEF_OP_TRUNC_SAT_F64(-1.0, 4294967296.0, true, false);
                        frame_sp--;
                        break;
                    case WASM_OP_I64_TRUNC_SAT_S_F32:
                        DEF_OP_TRUNC_SAT_F32(-9223373136366403584.0f,
                                             9223372036854775808.0f, false,
                                             true);
                        frame_sp++;
                        break;
                    case WASM_OP_I64_TRUNC_SAT_U_F32:
                        DEF_OP_TRUNC_SAT_F32(-1.0f, 18446744073709551616.0f,
                                             false, false);
                        frame_sp++;
                        break;
                    case WASM_OP_I64_TRUNC_SAT_S_F64:
                        DEF_OP_TRUNC_SAT_F64(-9223372036854777856.0,
                                             9223372036854775808.0, false,
                                             true);
                        break;
                    case WASM_OP_I64_TRUNC_SAT_U_F64:
                        DEF_OP_TRUNC_SAT_F64(-1.0f, 18446744073709551616.0,
                                             false, false);
                        break;
#if WASM_ENABLE_BULK_MEMORY != 0
                    case WASM_OP_MEMORY_INIT:
                    {
                        uint32 segment;
                        mem_offset_t addr;
                        uint64 bytes, offset, seg_len;
                        uint8 *data;

                        read_leb_uint32(frame_ip, frame_ip_end, segment);
                        /* skip memory index */
                        frame_ip++;

                        bytes = (uint64)(uint32)POP_I32();
                        offset = (uint64)(uint32)POP_I32();
                        addr = (mem_offset_t)POP_MEM_OFFSET();

#if WASM_ENABLE_THREAD_MGR != 0
                        linear_mem_size = get_linear_mem_size();
#endif

#ifndef OS_ENABLE_HW_BOUND_CHECK
                        CHECK_BULK_MEMORY_OVERFLOW(addr, bytes, maddr);
#else
                        if ((uint64)(uint32)addr + bytes > linear_mem_size)
                            goto out_of_bounds;
                        maddr = memory->memory_data + (uint32)addr;
#endif

                        if (bh_bitmap_get_bit(module->e->common.data_dropped,
                                              segment)) {
                            seg_len = 0;
                            data = NULL;
                        }
                        else {
                            seg_len =
                                (uint64)module->module->data_segments[segment]
                                    ->data_length;
                            data = module->module->data_segments[segment]->data;
                        }
                        if (offset + bytes > seg_len)
                            goto out_of_bounds;

                        bh_memcpy_s(maddr, (uint32)(linear_mem_size - addr),
                                    data + offset, (uint32)bytes);
                        break;
                    }
                    case WASM_OP_DATA_DROP:
                    {
                        uint32 segment;

                        read_leb_uint32(frame_ip, frame_ip_end, segment);
                        bh_bitmap_set_bit(module->e->common.data_dropped,
                                          segment);
                        break;
                    }
                    case WASM_OP_MEMORY_COPY:
                    {
                        mem_offset_t dst, src, len;
                        uint8 *mdst, *msrc;

                        frame_ip += 2;
                        len = POP_MEM_OFFSET();
                        src = POP_MEM_OFFSET();
                        dst = POP_MEM_OFFSET();

#if WASM_ENABLE_THREAD_MGR != 0
                        linear_mem_size = get_linear_mem_size();
#endif

#ifndef OS_ENABLE_HW_BOUND_CHECK
                        CHECK_BULK_MEMORY_OVERFLOW(src, len, msrc);
                        CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst);
#else
                        if ((uint64)(uint32)src + len > linear_mem_size)
                            goto out_of_bounds;
                        msrc = memory->memory_data + (uint32)src;

                        if ((uint64)(uint32)dst + len > linear_mem_size)
                            goto out_of_bounds;
                        mdst = memory->memory_data + (uint32)dst;
#endif

                        /* allowing the destination and source to overlap */
                        bh_memmove_s(mdst, (uint32)(linear_mem_size - dst),
                                     msrc, len);
                        break;
                    }
                    case WASM_OP_MEMORY_FILL:
                    {
                        mem_offset_t dst, len;
                        uint8 fill_val, *mdst;
                        frame_ip++;

                        len = POP_MEM_OFFSET();
                        fill_val = POP_I32();
                        dst = POP_MEM_OFFSET();

#if WASM_ENABLE_THREAD_MGR != 0
                        linear_mem_size = get_linear_mem_size();
#endif

#ifndef OS_ENABLE_HW_BOUND_CHECK
                        CHECK_BULK_MEMORY_OVERFLOW(dst, len, mdst);
#else
                        if ((uint64)(uint32)dst + len > linear_mem_size)
                            goto out_of_bounds;
                        mdst = memory->memory_data + (uint32)dst;
#endif

                        memset(mdst, fill_val, len);
                        break;
                    }
#endif /* WASM_ENABLE_BULK_MEMORY */
#if WASM_ENABLE_REF_TYPES != 0 || WASM_ENABLE_GC != 0
                    case WASM_OP_TABLE_INIT:
                    {
                        uint32 tbl_idx, elem_idx;
                        uint32 n, s, d;
                        WASMTableInstance *tbl_inst;
                        table_elem_type_t *table_elems;
                        InitializerExpression *tbl_seg_init_values = NULL,
                                              *init_values;
                        uint32 tbl_seg_len = 0;

                        read_leb_uint32(frame_ip, frame_ip_end, elem_idx);
                        bh_assert(elem_idx < module->module->table_seg_count);

                        read_leb_uint32(frame_ip, frame_ip_end, tbl_idx);
                        bh_assert(tbl_idx < module->module->table_count);

                        tbl_inst = wasm_get_table_inst(module, tbl_idx);

                        n = (uint32)POP_I32();
                        s = (uint32)POP_I32();
                        d = (uint32)POP_I32();

                        if (!bh_bitmap_get_bit(module->e->common.elem_dropped,
                                               elem_idx)) {
                            /* table segment isn't dropped */
                            tbl_seg_init_values =
                                module->module->table_segments[elem_idx]
                                    .init_values;
                            tbl_seg_len =
                                module->module->table_segments[elem_idx]
                                    .value_count;
                        }

                        if (offset_len_out_of_bounds(s, n, tbl_seg_len)
                            || offset_len_out_of_bounds(d, n,
                                                        tbl_inst->cur_size)) {
                            wasm_set_exception(module,
                                               "out of bounds table access");
                            goto got_exception;
                        }

                        if (!n) {
                            break;
                        }

                        table_elems = tbl_inst->elems + d;
                        init_values = tbl_seg_init_values + s;
#if WASM_ENABLE_GC != 0
                        SYNC_ALL_TO_FRAME();
#endif
                        for (i = 0; i < n; i++) {
                            /* UINT32_MAX indicates that it is a null ref */
                            bh_assert(init_values[i].init_expr_type
                                          == INIT_EXPR_TYPE_REFNULL_CONST
                                      || init_values[i].init_expr_type
                                             == INIT_EXPR_TYPE_FUNCREF_CONST);
#if WASM_ENABLE_GC == 0
                            table_elems[i] =
                                (table_elem_type_t)init_values[i].u.ref_index;
#else
                            if (init_values[i].u.ref_index != UINT32_MAX) {
                                if (!(func_obj = wasm_create_func_obj(
                                          module, init_values[i].u.ref_index,
                                          true, NULL, 0))) {
                                    goto got_exception;
                                }
                                table_elems[i] = func_obj;
                            }
                            else {
                                table_elems[i] = NULL_REF;
                            }
#endif
                        }
                        break;
                    }
                    case WASM_OP_ELEM_DROP:
                    {
                        uint32 elem_idx;
                        read_leb_uint32(frame_ip, frame_ip_end, elem_idx);
                        bh_assert(elem_idx < module->module->table_seg_count);

                        bh_bitmap_set_bit(module->e->common.elem_dropped,
                                          elem_idx);
                        break;
                    }
                    case WASM_OP_TABLE_COPY:
                    {
                        uint32 src_tbl_idx, dst_tbl_idx;
                        uint32 n, s, d;
                        WASMTableInstance *src_tbl_inst, *dst_tbl_inst;

                        read_leb_uint32(frame_ip, frame_ip_end, dst_tbl_idx);
                        bh_assert(dst_tbl_idx < module->table_count);

                        dst_tbl_inst = wasm_get_table_inst(module, dst_tbl_idx);

                        read_leb_uint32(frame_ip, frame_ip_end, src_tbl_idx);
                        bh_assert(src_tbl_idx < module->table_count);

                        src_tbl_inst = wasm_get_table_inst(module, src_tbl_idx);

                        n = (uint32)POP_I32();
                        s = (uint32)POP_I32();
                        d = (uint32)POP_I32();

                        if (offset_len_out_of_bounds(d, n,
                                                     dst_tbl_inst->cur_size)
                            || offset_len_out_of_bounds(
                                s, n, src_tbl_inst->cur_size)) {
                            wasm_set_exception(module,
                                               "out of bounds table access");
                            goto got_exception;
                        }

                        /* if s >= d, copy from front to back */
                        /* if s < d, copy from back to front */
                        /* merge all together */
                        bh_memmove_s((uint8 *)dst_tbl_inst
                                         + offsetof(WASMTableInstance, elems)
                                         + d * sizeof(table_elem_type_t),
                                     (uint32)((dst_tbl_inst->cur_size - d)
                                              * sizeof(table_elem_type_t)),
                                     (uint8 *)src_tbl_inst
                                         + offsetof(WASMTableInstance, elems)
                                         + s * sizeof(table_elem_type_t),
                                     (uint32)(n * sizeof(table_elem_type_t)));
                        break;
                    }
                    case WASM_OP_TABLE_GROW:
                    {
                        WASMTableInstance *tbl_inst;
                        uint32 tbl_idx, n, orig_tbl_sz;
                        table_elem_type_t init_val;

                        read_leb_uint32(frame_ip, frame_ip_end, tbl_idx);
                        bh_assert(tbl_idx < module->table_count);

                        tbl_inst = wasm_get_table_inst(module, tbl_idx);

                        orig_tbl_sz = tbl_inst->cur_size;

                        n = POP_I32();
#if WASM_ENABLE_GC == 0
                        init_val = POP_I32();
#else
                        init_val = POP_REF();
#endif

                        if (!wasm_enlarge_table(module, tbl_idx, n, init_val)) {
                            PUSH_I32(-1);
                        }
                        else {
                            PUSH_I32(orig_tbl_sz);
                        }
                        break;
                    }
                    case WASM_OP_TABLE_SIZE:
                    {
                        uint32 tbl_idx;
                        WASMTableInstance *tbl_inst;

                        read_leb_uint32(frame_ip, frame_ip_end, tbl_idx);
                        bh_assert(tbl_idx < module->table_count);

                        tbl_inst = wasm_get_table_inst(module, tbl_idx);

                        PUSH_I32(tbl_inst->cur_size);
                        break;
                    }
                    case WASM_OP_TABLE_FILL:
                    {
                        uint32 tbl_idx, n;
                        WASMTableInstance *tbl_inst;
                        table_elem_type_t fill_val;

                        read_leb_uint32(frame_ip, frame_ip_end, tbl_idx);
                        bh_assert(tbl_idx < module->table_count);

                        tbl_inst = wasm_get_table_inst(module, tbl_idx);

                        n = POP_I32();
#if WASM_ENABLE_GC == 0
                        fill_val = POP_I32();
#else
                        fill_val = POP_REF();
#endif
                        i = POP_I32();

                        if (offset_len_out_of_bounds(i, n,
                                                     tbl_inst->cur_size)) {
                            wasm_set_exception(module,
                                               "out of bounds table access");
                            goto got_exception;
                        }

                        for (; n != 0; i++, n--) {
                            tbl_inst->elems[i] = fill_val;
                        }
                        break;
                    }
#endif /* end of WASM_ENABLE_REF_TYPES != 0 || WASM_ENABLE_GC != 0 */
                    default:
                        wasm_set_exception(module, "unsupported opcode");
                        goto got_exception;
                }
                HANDLE_OP_END();
            }

#if WASM_ENABLE_SHARED_MEMORY != 0
            HANDLE_OP(WASM_OP_ATOMIC_PREFIX)
            {
                mem_offset_t offset = 0, addr;
                uint32 align = 0;
                uint32 opcode1;

                read_leb_uint32(frame_ip, frame_ip_end, opcode1);
                /* opcode1 was checked in loader and is no larger than
                   UINT8_MAX */
                opcode = (uint8)opcode1;

                if (opcode != WASM_OP_ATOMIC_FENCE) {
                    read_leb_uint32(frame_ip, frame_ip_end, align);
                    read_leb_mem_offset(frame_ip, frame_ip_end, offset);
                }

                switch (opcode) {
                    case WASM_OP_ATOMIC_NOTIFY:
                    {
                        uint32 notify_count, ret;

                        notify_count = POP_I32();
                        addr = POP_MEM_OFFSET();
                        CHECK_MEMORY_OVERFLOW(4);
                        CHECK_ATOMIC_MEMORY_ACCESS();

                        ret = wasm_runtime_atomic_notify(
                            (WASMModuleInstanceCommon *)module, maddr,
                            notify_count);
                        if (ret == (uint32)-1)
                            goto got_exception;

                        PUSH_I32(ret);
                        break;
                    }
                    case WASM_OP_ATOMIC_WAIT32:
                    {
                        uint64 timeout;
                        uint32 expect, ret;

                        timeout = POP_I64();
                        expect = POP_I32();
                        addr = POP_MEM_OFFSET();
                        CHECK_MEMORY_OVERFLOW(4);
                        CHECK_ATOMIC_MEMORY_ACCESS();

                        ret = wasm_runtime_atomic_wait(
                            (WASMModuleInstanceCommon *)module, maddr,
                            (uint64)expect, timeout, false);
                        if (ret == (uint32)-1)
                            goto got_exception;

#if WASM_ENABLE_THREAD_MGR != 0
                        CHECK_SUSPEND_FLAGS();
#endif

                        PUSH_I32(ret);
                        break;
                    }
                    case WASM_OP_ATOMIC_WAIT64:
                    {
                        uint64 timeout, expect;
                        uint32 ret;

                        timeout = POP_I64();
                        expect = POP_I64();
                        addr = POP_MEM_OFFSET();
                        CHECK_MEMORY_OVERFLOW(8);
                        CHECK_ATOMIC_MEMORY_ACCESS();

                        ret = wasm_runtime_atomic_wait(
                            (WASMModuleInstanceCommon *)module, maddr, expect,
                            timeout, true);
                        if (ret == (uint32)-1)
                            goto got_exception;

#if WASM_ENABLE_THREAD_MGR != 0
                        CHECK_SUSPEND_FLAGS();
#endif

                        PUSH_I32(ret);
                        break;
                    }
                    case WASM_OP_ATOMIC_FENCE:
                    {
                        /* Skip the memory index */
                        frame_ip++;
                        os_atomic_thread_fence(os_memory_order_seq_cst);
                        break;
                    }

                    case WASM_OP_ATOMIC_I32_LOAD:
                    case WASM_OP_ATOMIC_I32_LOAD8_U:
                    case WASM_OP_ATOMIC_I32_LOAD16_U:
                    {
                        uint32 readv;

                        addr = POP_MEM_OFFSET();

                        if (opcode == WASM_OP_ATOMIC_I32_LOAD8_U) {
                            CHECK_MEMORY_OVERFLOW(1);
                            CHECK_ATOMIC_MEMORY_ACCESS();
                            shared_memory_lock(memory);
                            readv = (uint32)(*(uint8 *)maddr);
                            shared_memory_unlock(memory);
                        }
                        else if (opcode == WASM_OP_ATOMIC_I32_LOAD16_U) {
                            CHECK_MEMORY_OVERFLOW(2);
                            CHECK_ATOMIC_MEMORY_ACCESS();
                            shared_memory_lock(memory);
                            readv = (uint32)LOAD_U16(maddr);
                            shared_memory_unlock(memory);
                        }
                        else {
                            CHECK_MEMORY_OVERFLOW(4);
                            CHECK_ATOMIC_MEMORY_ACCESS();
                            shared_memory_lock(memory);
                            readv = LOAD_I32(maddr);
                            shared_memory_unlock(memory);
                        }

                        PUSH_I32(readv);
                        break;
                    }

                    case WASM_OP_ATOMIC_I64_LOAD:
                    case WASM_OP_ATOMIC_I64_LOAD8_U:
                    case WASM_OP_ATOMIC_I64_LOAD16_U:
                    case WASM_OP_ATOMIC_I64_LOAD32_U:
                    {
                        uint64 readv;

                        addr = POP_MEM_OFFSET();

                        if (opcode == WASM_OP_ATOMIC_I64_LOAD8_U) {
                            CHECK_MEMORY_OVERFLOW(1);
                            CHECK_ATOMIC_MEMORY_ACCESS();
                            shared_memory_lock(memory);
                            readv = (uint64)(*(uint8 *)maddr);
                            shared_memory_unlock(memory);
                        }
                        else if (opcode == WASM_OP_ATOMIC_I64_LOAD16_U) {
                            CHECK_MEMORY_OVERFLOW(2);
                            CHECK_ATOMIC_MEMORY_ACCESS();
                            shared_memory_lock(memory);
                            readv = (uint64)LOAD_U16(maddr);
                            shared_memory_unlock(memory);
                        }
                        else if (opcode == WASM_OP_ATOMIC_I64_LOAD32_U) {
                            CHECK_MEMORY_OVERFLOW(4);
                            CHECK_ATOMIC_MEMORY_ACCESS();
                            shared_memory_lock(memory);
                            readv = (uint64)LOAD_U32(maddr);
                            shared_memory_unlock(memory);
                        }
                        else {
                            CHECK_MEMORY_OVERFLOW(8);
                            CHECK_ATOMIC_MEMORY_ACCESS();
                            shared_memory_lock(memory);
                            readv = LOAD_I64(maddr);
                            shared_memory_unlock(memory);
                        }

                        PUSH_I64(readv);
                        break;
                    }

                    case WASM_OP_ATOMIC_I32_STORE:
                    case WASM_OP_ATOMIC_I32_STORE8:
                    case WASM_OP_ATOMIC_I32_STORE16:
                    {
                        uint32 sval;

                        sval = (uint32)POP_I32();
                        addr = POP_MEM_OFFSET();

                        if (opcode == WASM_OP_ATOMIC_I32_STORE8) {
                            CHECK_MEMORY_OVERFLOW(1);
                            CHECK_ATOMIC_MEMORY_ACCESS();
                            shared_memory_lock(memory);
                            *(uint8 *)maddr = (uint8)sval;
                            shared_memory_unlock(memory);
                        }
                        else if (opcode == WASM_OP_ATOMIC_I32_STORE16) {
                            CHECK_MEMORY_OVERFLOW(2);
                            CHECK_ATOMIC_MEMORY_ACCESS();
                            shared_memory_lock(memory);
                            STORE_U16(maddr, (uint16)sval);
                            shared_memory_unlock(memory);
                        }
                        else {
                            CHECK_MEMORY_OVERFLOW(4);
                            CHECK_ATOMIC_MEMORY_ACCESS();
                            shared_memory_lock(memory);
                            STORE_U32(maddr, sval);
                            shared_memory_unlock(memory);
                        }
                        break;
                    }

                    case WASM_OP_ATOMIC_I64_STORE:
                    case WASM_OP_ATOMIC_I64_STORE8:
                    case WASM_OP_ATOMIC_I64_STORE16:
                    case WASM_OP_ATOMIC_I64_STORE32:
                    {
                        uint64 sval;

                        sval = (uint64)POP_I64();
                        addr = POP_MEM_OFFSET();

                        if (opcode == WASM_OP_ATOMIC_I64_STORE8) {
                            CHECK_MEMORY_OVERFLOW(1);
                            CHECK_ATOMIC_MEMORY_ACCESS();
                            shared_memory_lock(memory);
                            *(uint8 *)maddr = (uint8)sval;
                            shared_memory_unlock(memory);
                        }
                        else if (opcode == WASM_OP_ATOMIC_I64_STORE16) {
                            CHECK_MEMORY_OVERFLOW(2);
                            CHECK_ATOMIC_MEMORY_ACCESS();
                            shared_memory_lock(memory);
                            STORE_U16(maddr, (uint16)sval);
                            shared_memory_unlock(memory);
                        }
                        else if (opcode == WASM_OP_ATOMIC_I64_STORE32) {
                            CHECK_MEMORY_OVERFLOW(4);
                            CHECK_ATOMIC_MEMORY_ACCESS();
                            shared_memory_lock(memory);
                            STORE_U32(maddr, (uint32)sval);
                            shared_memory_unlock(memory);
                        }
                        else {
                            CHECK_MEMORY_OVERFLOW(8);
                            CHECK_ATOMIC_MEMORY_ACCESS();
                            shared_memory_lock(memory);
                            STORE_I64(maddr, sval);
                            shared_memory_unlock(memory);
                        }
                        break;
                    }

                    case WASM_OP_ATOMIC_RMW_I32_CMPXCHG:
                    case WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U:
                    case WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U:
                    {
                        uint32 readv, sval, expect;

                        sval = POP_I32();
                        expect = POP_I32();
                        addr = POP_MEM_OFFSET();

                        if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG8_U) {
                            CHECK_MEMORY_OVERFLOW(1);
                            CHECK_ATOMIC_MEMORY_ACCESS();

                            expect = (uint8)expect;
                            shared_memory_lock(memory);
                            readv = (uint32)(*(uint8 *)maddr);
                            if (readv == expect)
                                *(uint8 *)maddr = (uint8)(sval);
                            shared_memory_unlock(memory);
                        }
                        else if (opcode == WASM_OP_ATOMIC_RMW_I32_CMPXCHG16_U) {
                            CHECK_MEMORY_OVERFLOW(2);
                            CHECK_ATOMIC_MEMORY_ACCESS();

                            expect = (uint16)expect;
                            shared_memory_lock(memory);
                            readv = (uint32)LOAD_U16(maddr);
                            if (readv == expect)
                                STORE_U16(maddr, (uint16)(sval));
                            shared_memory_unlock(memory);
                        }
                        else {
                            CHECK_MEMORY_OVERFLOW(4);
                            CHECK_ATOMIC_MEMORY_ACCESS();

                            shared_memory_lock(memory);
                            readv = LOAD_I32(maddr);
                            if (readv == expect)
                                STORE_U32(maddr, sval);
                            shared_memory_unlock(memory);
                        }
                        PUSH_I32(readv);
                        break;
                    }
                    case WASM_OP_ATOMIC_RMW_I64_CMPXCHG:
                    case WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U:
                    case WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U:
                    case WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U:
                    {
                        uint64 readv, sval, expect;

                        sval = (uint64)POP_I64();
                        expect = (uint64)POP_I64();
                        addr = POP_MEM_OFFSET();

                        if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG8_U) {
                            CHECK_MEMORY_OVERFLOW(1);
                            CHECK_ATOMIC_MEMORY_ACCESS();

                            expect = (uint8)expect;
                            shared_memory_lock(memory);
                            readv = (uint64)(*(uint8 *)maddr);
                            if (readv == expect)
                                *(uint8 *)maddr = (uint8)(sval);
                            shared_memory_unlock(memory);
                        }
                        else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG16_U) {
                            CHECK_MEMORY_OVERFLOW(2);
                            CHECK_ATOMIC_MEMORY_ACCESS();

                            expect = (uint16)expect;
                            shared_memory_lock(memory);
                            readv = (uint64)LOAD_U16(maddr);
                            if (readv == expect)
                                STORE_U16(maddr, (uint16)(sval));
                            shared_memory_unlock(memory);
                        }
                        else if (opcode == WASM_OP_ATOMIC_RMW_I64_CMPXCHG32_U) {
                            CHECK_MEMORY_OVERFLOW(4);
                            CHECK_ATOMIC_MEMORY_ACCESS();

                            expect = (uint32)expect;
                            shared_memory_lock(memory);
                            readv = (uint64)LOAD_U32(maddr);
                            if (readv == expect)
                                STORE_U32(maddr, (uint32)(sval));
                            shared_memory_unlock(memory);
                        }
                        else {
                            CHECK_MEMORY_OVERFLOW(8);
                            CHECK_ATOMIC_MEMORY_ACCESS();

                            shared_memory_lock(memory);
                            readv = (uint64)LOAD_I64(maddr);
                            if (readv == expect)
                                STORE_I64(maddr, sval);
                            shared_memory_unlock(memory);
                        }
                        PUSH_I64(readv);
                        break;
                    }

                        DEF_ATOMIC_RMW_OPCODE(ADD, +);
                        DEF_ATOMIC_RMW_OPCODE(SUB, -);
                        DEF_ATOMIC_RMW_OPCODE(AND, &);
                        DEF_ATOMIC_RMW_OPCODE(OR, |);
                        DEF_ATOMIC_RMW_OPCODE(XOR, ^);
                        /* xchg, ignore the read value, and store the given
                          value: readv * 0 + sval */
                        DEF_ATOMIC_RMW_OPCODE(XCHG, *0 +);
                }

                HANDLE_OP_END();
            }
#endif

            HANDLE_OP(WASM_OP_IMPDEP)
            {
                frame = prev_frame;
                frame_ip = frame->ip;
                frame_sp = frame->sp;
                frame_csp = frame->csp;
#if WASM_ENABLE_TAIL_CALL != 0 || WASM_ENABLE_GC != 0
                is_return_call = false;
#endif
                goto call_func_from_entry;
            }

#if WASM_ENABLE_DEBUG_INTERP != 0
            HANDLE_OP(DEBUG_OP_BREAK)
            {
                wasm_cluster_thread_send_signal(exec_env, WAMR_SIG_TRAP);
                WASM_SUSPEND_FLAGS_FETCH_OR(exec_env->suspend_flags,
                                            WASM_SUSPEND_FLAG_SUSPEND);
                frame_ip--;
                SYNC_ALL_TO_FRAME();
                CHECK_SUSPEND_FLAGS();
                HANDLE_OP_END();
            }
#endif
#if WASM_ENABLE_LABELS_AS_VALUES == 0
            default:
                wasm_set_exception(module, "unsupported opcode");
                goto got_exception;
        }
#endif

#if WASM_ENABLE_LABELS_AS_VALUES != 0
        HANDLE_OP(WASM_OP_UNUSED_0x0a)
#if WASM_ENABLE_TAIL_CALL == 0
        HANDLE_OP(WASM_OP_RETURN_CALL)
        HANDLE_OP(WASM_OP_RETURN_CALL_INDIRECT)
#endif
#if WASM_ENABLE_SHARED_MEMORY == 0
        HANDLE_OP(WASM_OP_ATOMIC_PREFIX)
#endif
#if WASM_ENABLE_REF_TYPES == 0 && WASM_ENABLE_GC == 0
        HANDLE_OP(WASM_OP_SELECT_T)
        HANDLE_OP(WASM_OP_TABLE_GET)
        HANDLE_OP(WASM_OP_TABLE_SET)
        HANDLE_OP(WASM_OP_REF_NULL)
        HANDLE_OP(WASM_OP_REF_IS_NULL)
        HANDLE_OP(WASM_OP_REF_FUNC)
#endif
#if WASM_ENABLE_GC == 0
        HANDLE_OP(WASM_OP_CALL_REF)
        HANDLE_OP(WASM_OP_RETURN_CALL_REF)
        HANDLE_OP(WASM_OP_REF_EQ)
        HANDLE_OP(WASM_OP_REF_AS_NON_NULL)
        HANDLE_OP(WASM_OP_BR_ON_NULL)
        HANDLE_OP(WASM_OP_BR_ON_NON_NULL)
        HANDLE_OP(WASM_OP_GC_PREFIX)
#endif
#if WASM_ENABLE_EXCE_HANDLING == 0
        HANDLE_OP(WASM_OP_TRY)
        HANDLE_OP(WASM_OP_CATCH)
        HANDLE_OP(WASM_OP_THROW)
        HANDLE_OP(WASM_OP_RETHROW)
        HANDLE_OP(WASM_OP_DELEGATE)
        HANDLE_OP(WASM_OP_CATCH_ALL)
        HANDLE_OP(EXT_OP_TRY)
#endif
#if WASM_ENABLE_JIT != 0 && WASM_ENABLE_SIMD != 0
        /* SIMD isn't supported by interpreter, but when JIT is
           enabled, `iwasm --interp <wasm_file>` may be run to
           trigger the SIMD opcode in interpreter */
        HANDLE_OP(WASM_OP_SIMD_PREFIX)
#endif
        HANDLE_OP(WASM_OP_UNUSED_0x16)
        HANDLE_OP(WASM_OP_UNUSED_0x17)
        HANDLE_OP(WASM_OP_UNUSED_0x27)
        /* Used by fast interpreter */
        HANDLE_OP(EXT_OP_SET_LOCAL_FAST_I64)
        HANDLE_OP(EXT_OP_TEE_LOCAL_FAST_I64)
        HANDLE_OP(EXT_OP_COPY_STACK_TOP)
        HANDLE_OP(EXT_OP_COPY_STACK_TOP_I64)
        HANDLE_OP(EXT_OP_COPY_STACK_VALUES)
        {
            wasm_set_exception(module, "unsupported opcode");
            goto got_exception;
        }
#endif /* end of WASM_ENABLE_LABELS_AS_VALUES != 0 */

#if WASM_ENABLE_LABELS_AS_VALUES == 0
        continue;
#else
    FETCH_OPCODE_AND_DISPATCH();
#endif

#if WASM_ENABLE_TAIL_CALL != 0 || WASM_ENABLE_GC != 0
    call_func_from_return_call:
    {
        POP(cur_func->param_cell_num);
        if (cur_func->param_cell_num > 0) {
            word_copy(frame->lp, frame_sp, cur_func->param_cell_num);
        }
        FREE_FRAME(exec_env, frame);
        wasm_exec_env_set_cur_frame(exec_env, prev_frame);
        is_return_call = true;
        goto call_func_from_entry;
    }
#endif
    call_func_from_interp:
    {
        /* Only do the copy when it's called from interpreter.  */
        WASMInterpFrame *outs_area = wasm_exec_env_wasm_stack_top(exec_env);
        if (cur_func->param_cell_num > 0) {
            POP(cur_func->param_cell_num);
            word_copy(outs_area->lp, frame_sp, cur_func->param_cell_num);
        }
        SYNC_ALL_TO_FRAME();
        prev_frame = frame;
#if WASM_ENABLE_TAIL_CALL != 0 || WASM_ENABLE_GC != 0
        is_return_call = false;
#endif
    }

    call_func_from_entry:
    {
        if (cur_func->is_import_func) {
#if WASM_ENABLE_MULTI_MODULE != 0
            if (cur_func->import_func_inst) {
                wasm_interp_call_func_import(module, exec_env, cur_func,
                                             prev_frame);
#if WASM_ENABLE_TAIL_CALL != 0 || WASM_ENABLE_GC != 0
                if (is_return_call) {
                    /* the frame was freed before tail calling and
                       the prev_frame was set as exec_env's cur_frame,
                       so here we recover context from prev_frame */
                    RECOVER_CONTEXT(prev_frame);
                }
                else
#endif
                {
                    prev_frame = frame->prev_frame;
                    cur_func = frame->function;
                    UPDATE_ALL_FROM_FRAME();
                }

#if WASM_ENABLE_EXCE_HANDLING != 0
                char uncaught_exception[128] = { 0 };
                bool has_exception =
                    wasm_copy_exception(module, uncaught_exception);
                if (has_exception
                    && strstr(uncaught_exception, "uncaught wasm exception")) {
                    uint32 import_exception;
                    /* initialize imported exception index to be invalid */
                    SET_INVALID_TAGINDEX(import_exception);

                    /* pull external exception */
                    uint32 ext_exception = POP_I32();

                    /* external function came back with an exception or trap */
                    /* lookup exception in import tags */
                    WASMTagInstance *tag = module->e->tags;
                    for (uint32 t = 0; t < module->module->import_tag_count;
                         tag++, t++) {

                        /* compare the module and the external index with the
                         * imort tag data */
                        if ((cur_func->u.func_import->import_module
                             == tag->u.tag_import->import_module)
                            && (ext_exception
                                == tag->u.tag_import
                                       ->import_tag_index_linked)) {
                            /* set the import_exception to the import tag */
                            import_exception = t;
                            break;
                        }
                    }
                    /*
                     * excange the thrown exception (index valid in submodule)
                     * with the imported exception index (valid in this module)
                     * if the module did not import the exception,
                     * that results in a "INVALID_TAGINDEX", that triggers
                     * an CATCH_ALL block, if there is one.
                     */
                    PUSH_I32(import_exception);
                }
#endif /* end of WASM_ENABLE_EXCE_HANDLING != 0 */
            }
            else
#endif /* end of WASM_ENABLE_MULTI_MODULE != 0 */
            {
                wasm_interp_call_func_native(module, exec_env, cur_func,
                                             prev_frame);
#if WASM_ENABLE_TAIL_CALL != 0 || WASM_ENABLE_GC != 0
                if (is_return_call) {
                    /* the frame was freed before tail calling and
                       the prev_frame was set as exec_env's cur_frame,
                       so here we recover context from prev_frame */
                    RECOVER_CONTEXT(prev_frame);
                }
                else
#endif
                {
                    prev_frame = frame->prev_frame;
                    cur_func = frame->function;
                    UPDATE_ALL_FROM_FRAME();
                }
            }

            /* update memory size, no need to update memory ptr as
               it isn't changed in wasm_enlarge_memory */
#if !defined(OS_ENABLE_HW_BOUND_CHECK)              \
    || WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0 \
    || WASM_ENABLE_BULK_MEMORY != 0
            if (memory)
                linear_mem_size = get_linear_mem_size();
#endif
            if (wasm_copy_exception(module, NULL)) {
#if WASM_ENABLE_EXCE_HANDLING != 0
                /* the caller raised an exception */
                char uncaught_exception[128] = { 0 };
                bool has_exception =
                    wasm_copy_exception(module, uncaught_exception);

                /* libc_builtin signaled a "exception thrown by stdc++" trap */
                if (has_exception
                    && strstr(uncaught_exception,
                              "exception thrown by stdc++")) {
                    wasm_set_exception(module, NULL);

                    /* setup internal c++ rethrow */
                    exception_tag_index = 0;
                    goto find_a_catch_handler;
                }

                /* when throw hits the end of a function it signalles with a
                 * "uncaught wasm exception" trap */
                if (has_exception
                    && strstr(uncaught_exception, "uncaught wasm exception")) {
                    wasm_set_exception(module, NULL);
                    exception_tag_index = POP_I32();

                    /* rethrow the exception into that frame */
                    goto find_a_catch_handler;
                }
#endif /* WASM_ENABLE_EXCE_HANDLING != 0 */
                goto got_exception;
            }
        }
        else {
            WASMFunction *cur_wasm_func = cur_func->u.func;
            WASMFuncType *func_type = cur_wasm_func->func_type;
            uint32 max_stack_cell_num = cur_wasm_func->max_stack_cell_num;
            uint32 cell_num_of_local_stack;

#if WASM_ENABLE_EXCE_HANDLING != 0
            /* account for exception handlers, bundle them here */
            uint32 eh_size =
                cur_wasm_func->exception_handler_count * sizeof(uint8 *);
            max_stack_cell_num += eh_size;
#endif

            cell_num_of_local_stack = cur_func->param_cell_num
                                      + cur_func->local_cell_num
                                      + max_stack_cell_num;
            all_cell_num = cell_num_of_local_stack
                           + cur_wasm_func->max_block_num
                                 * (uint32)sizeof(WASMBranchBlock) / 4;
#if WASM_ENABLE_GC != 0
            /* area of frame_ref */
            all_cell_num += (cell_num_of_local_stack + 3) / 4;
#endif

            /* param_cell_num, local_cell_num, max_stack_cell_num and
               max_block_num are all no larger than UINT16_MAX (checked
               in loader), all_cell_num must be smaller than 1MB */
            bh_assert(all_cell_num < 1 * BH_MB);

            frame_size = wasm_interp_interp_frame_size(all_cell_num);
            if (!(frame = ALLOC_FRAME(exec_env, frame_size, prev_frame))) {
                frame = prev_frame;
                goto got_exception;
            }

            /* Initialize the interpreter context. */
            frame->function = cur_func;
            frame_ip = wasm_get_func_code(cur_func);
            frame_ip_end = wasm_get_func_code_end(cur_func);
            frame_lp = frame->lp;

            frame_sp = frame->sp_bottom =
                frame_lp + cur_func->param_cell_num + cur_func->local_cell_num;
            frame->sp_boundary = frame->sp_bottom + max_stack_cell_num;

            frame_csp = frame->csp_bottom =
                (WASMBranchBlock *)frame->sp_boundary;
            frame->csp_boundary =
                frame->csp_bottom + cur_wasm_func->max_block_num;

#if WASM_ENABLE_GC != 0
            /* frame->sp and frame->ip are used during GC root set enumeration,
             * so we must initialized these fields here */
            frame->sp = frame_sp;
            frame->ip = frame_ip;
            frame_ref = (uint8 *)frame->csp_boundary;
            init_frame_refs(frame_ref, (uint32)cell_num_of_local_stack,
                            cur_func);
#endif

            /* Initialize the local variables */
            memset(frame_lp + cur_func->param_cell_num, 0,
                   (uint32)(cur_func->local_cell_num * 4));

            /* Push function block as first block */
            cell_num = func_type->ret_cell_num;
            PUSH_CSP(LABEL_TYPE_FUNCTION, 0, cell_num, frame_ip_end - 1);

            wasm_exec_env_set_cur_frame(exec_env, frame);
        }
#if WASM_ENABLE_THREAD_MGR != 0
        CHECK_SUSPEND_FLAGS();
#endif
        HANDLE_OP_END();
    }

    return_func:
    {
        FREE_FRAME(exec_env, frame);
        wasm_exec_env_set_cur_frame(exec_env, prev_frame);

        if (!prev_frame->ip) {
            /* Called from native. */
            return;
        }

        RECOVER_CONTEXT(prev_frame);
#if WASM_ENABLE_EXCE_HANDLING != 0
        if (wasm_get_exception(module)) {
            wasm_set_exception(module, NULL);
            exception_tag_index = POP_I32();
            goto find_a_catch_handler;
        }
#endif
        HANDLE_OP_END();
    }

#if WASM_ENABLE_SHARED_MEMORY != 0
    unaligned_atomic:
        wasm_set_exception(module, "unaligned atomic");
        goto got_exception;
#endif

#if !defined(OS_ENABLE_HW_BOUND_CHECK)              \
    || WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS == 0 \
    || WASM_ENABLE_BULK_MEMORY != 0
    out_of_bounds:
        wasm_set_exception(module, "out of bounds memory access");
#endif

    got_exception:
#if WASM_ENABLE_DEBUG_INTERP != 0
        if (wasm_exec_env_get_instance(exec_env) != NULL) {
            uint8 *frame_ip_temp = frame_ip;
            frame_ip = frame_ip_orig;
            wasm_cluster_thread_send_signal(exec_env, WAMR_SIG_TRAP);
            CHECK_SUSPEND_FLAGS();
            frame_ip = frame_ip_temp;
        }
#endif
        SYNC_ALL_TO_FRAME();
        return;

#if WASM_ENABLE_LABELS_AS_VALUES == 0
    }
#else
    FETCH_OPCODE_AND_DISPATCH();
#endif
}

#if WASM_ENABLE_GC != 0
bool
wasm_interp_traverse_gc_rootset(WASMExecEnv *exec_env, void *heap)
{
    WASMInterpFrame *frame;
    WASMObjectRef gc_obj;
    int i;

    frame = wasm_exec_env_get_cur_frame(exec_env);
    for (; frame; frame = frame->prev_frame) {
        uint8 *frame_ref = get_frame_ref(frame);
        for (i = 0; i < frame->sp - frame->lp; i++) {
            if (frame_ref[i]) {
                gc_obj = GET_REF_FROM_ADDR(frame->lp + i);
                if (wasm_obj_is_created_from_heap(gc_obj)) {
                    if (mem_allocator_add_root((mem_allocator_t)heap, gc_obj)) {
                        return false;
                    }
                }
#if UINTPTR_MAX == UINT64_MAX
                bh_assert(frame_ref[i + 1]);
                i++;
#endif
            }
        }
    }
    return true;
}
#endif

#if WASM_ENABLE_FAST_JIT != 0
/*
 * ASAN is not designed to work with custom stack unwind or other low-level
 * things. Ignore a function that does some low-level magic. (e.g. walking
 * through the thread's stack bypassing the frame boundaries)
 */
#if defined(__GNUC__) || defined(__clang__)
__attribute__((no_sanitize_address))
#endif
static void
fast_jit_call_func_bytecode(WASMModuleInstance *module_inst,
                            WASMExecEnv *exec_env,
                            WASMFunctionInstance *function,
                            WASMInterpFrame *frame)
{
    JitGlobals *jit_globals = jit_compiler_get_jit_globals();
    JitInterpSwitchInfo info;
    WASMModule *module = module_inst->module;
    WASMFuncType *func_type = function->u.func->func_type;
    uint8 type = func_type->result_count
                     ? func_type->types[func_type->param_count]
                     : VALUE_TYPE_VOID;
    uint32 func_idx = (uint32)(function - module_inst->e->functions);
    uint32 func_idx_non_import = func_idx - module->import_function_count;
    int32 action;

#if WASM_ENABLE_REF_TYPES != 0
    if (type == VALUE_TYPE_EXTERNREF || type == VALUE_TYPE_FUNCREF)
        type = VALUE_TYPE_I32;
#endif

#if WASM_ENABLE_LAZY_JIT != 0
    if (!jit_compiler_compile(module, func_idx)) {
        wasm_set_exception(module_inst, "failed to compile fast jit function");
        return;
    }
#endif
    bh_assert(jit_compiler_is_compiled(module, func_idx));

    /* Switch to jitted code to call the jit function */
    info.out.ret.last_return_type = type;
    info.frame = frame;
    frame->jitted_return_addr =
        (uint8 *)jit_globals->return_to_interp_from_jitted;
    action = jit_interp_switch_to_jitted(
        exec_env, &info, func_idx,
        module_inst->fast_jit_func_ptrs[func_idx_non_import]);
    bh_assert(action == JIT_INTERP_ACTION_NORMAL
              || (action == JIT_INTERP_ACTION_THROWN
                  && wasm_copy_exception(
                      (WASMModuleInstance *)exec_env->module_inst, NULL)));

    /* Get the return values form info.out.ret */
    if (func_type->result_count) {
        switch (type) {
            case VALUE_TYPE_I32:
                *(frame->sp - function->ret_cell_num) = info.out.ret.ival[0];
                break;
            case VALUE_TYPE_I64:
                *(frame->sp - function->ret_cell_num) = info.out.ret.ival[0];
                *(frame->sp - function->ret_cell_num + 1) =
                    info.out.ret.ival[1];
                break;
            case VALUE_TYPE_F32:
                *(frame->sp - function->ret_cell_num) = info.out.ret.fval[0];
                break;
            case VALUE_TYPE_F64:
                *(frame->sp - function->ret_cell_num) = info.out.ret.fval[0];
                *(frame->sp - function->ret_cell_num + 1) =
                    info.out.ret.fval[1];
                break;
            default:
                bh_assert(0);
                break;
        }
    }
    (void)action;
    (void)func_idx;
}
#endif /* end of WASM_ENABLE_FAST_JIT != 0 */

#if WASM_ENABLE_JIT != 0
#if WASM_ENABLE_DUMP_CALL_STACK != 0 || WASM_ENABLE_PERF_PROFILING != 0 \
    || WASM_ENABLE_AOT_STACK_FRAME != 0
#if WASM_ENABLE_GC == 0
bool
llvm_jit_alloc_frame(WASMExecEnv *exec_env, uint32 func_index)
{
    WASMModuleInstance *module_inst =
        (WASMModuleInstance *)exec_env->module_inst;
    WASMInterpFrame *cur_frame, *frame;
    uint32 size = (uint32)offsetof(WASMInterpFrame, lp);

    bh_assert(module_inst->module_type == Wasm_Module_Bytecode);

    cur_frame = exec_env->cur_frame;
    if (!cur_frame)
        frame = (WASMInterpFrame *)exec_env->wasm_stack.bottom;
    else
        frame = (WASMInterpFrame *)((uint8 *)cur_frame + size);

    if ((uint8 *)frame + size > exec_env->wasm_stack.top_boundary) {
        wasm_set_exception(module_inst, "wasm operand stack overflow");
        return false;
    }

    frame->function = module_inst->e->functions + func_index;
    /* No need to initialize ip, it will be committed in jitted code
       when needed */
    /* frame->ip = NULL; */
    frame->prev_frame = cur_frame;

#if WASM_ENABLE_PERF_PROFILING != 0
    frame->time_started = os_time_thread_cputime_us();
#endif
#if WASM_ENABLE_MEMORY_PROFILING != 0
    {
        uint32 wasm_stack_used =
            (uint8 *)frame + size - exec_env->wasm_stack.bottom;
        if (wasm_stack_used > exec_env->max_wasm_stack_used)
            exec_env->max_wasm_stack_used = wasm_stack_used;
    }
#endif

    exec_env->cur_frame = frame;

    return true;
}

static inline void
llvm_jit_free_frame_internal(WASMExecEnv *exec_env)
{
    WASMInterpFrame *frame = exec_env->cur_frame;
    WASMInterpFrame *prev_frame = frame->prev_frame;

    bh_assert(exec_env->module_inst->module_type == Wasm_Module_Bytecode);

#if WASM_ENABLE_PERF_PROFILING != 0
    if (frame->function) {
        uint64 time_elapsed = os_time_thread_cputime_us() - frame->time_started;

        frame->function->total_exec_time += time_elapsed;
        frame->function->total_exec_cnt++;

        /* parent function */
        if (prev_frame)
            prev_frame->function->children_exec_time += time_elapsed;
    }
#endif
    exec_env->cur_frame = prev_frame;
}

void
llvm_jit_free_frame(WASMExecEnv *exec_env)
{
    llvm_jit_free_frame_internal(exec_env);
}

#else /* else of WASM_ENABLE_GC == 0 */

bool
llvm_jit_alloc_frame(WASMExecEnv *exec_env, uint32 func_index)
{
    WASMModuleInstance *module_inst;
    WASMModule *module;
    WASMInterpFrame *frame;
    uint32 size, max_local_cell_num, max_stack_cell_num;

    bh_assert(exec_env->module_inst->module_type == Wasm_Module_Bytecode);

    module_inst = (WASMModuleInstance *)exec_env->module_inst;
    module = module_inst->module;

    if (func_index >= func_index - module->import_function_count) {
        WASMFunction *func =
            module->functions[func_index - module->import_function_count];

        max_local_cell_num = func->param_cell_num + func->local_cell_num;
        max_stack_cell_num = func->max_stack_cell_num;
    }
    else {
        WASMFunctionImport *func =
            &((module->import_functions + func_index)->u.function);

        max_local_cell_num = func->func_type->param_cell_num > 2
                                 ? func->func_type->param_cell_num
                                 : 2;
        max_stack_cell_num = 0;
    }

    size =
        wasm_interp_interp_frame_size(max_local_cell_num + max_stack_cell_num);

    frame = wasm_exec_env_alloc_wasm_frame(exec_env, size);
    if (!frame) {
        wasm_set_exception(module_inst, "wasm operand stack overflow");
        return false;
    }

    frame->function = module_inst->e->functions + func_index;
#if WASM_ENABLE_PERF_PROFILING != 0
    frame->time_started = os_time_thread_cputime_us();
#endif
    frame->prev_frame = wasm_exec_env_get_cur_frame(exec_env);

    /* No need to initialize ip, it will be committed in jitted code
       when needed */
    /* frame->ip = NULL; */

#if WASM_ENABLE_GC != 0
    frame->sp = frame->lp + max_local_cell_num;

    /* Initialize frame ref flags for import function */
    if (func_index < module->import_function_count) {
        WASMFunctionImport *func =
            &((module->import_functions + func_index)->u.function);
        WASMFuncType *func_type = func->func_type;
        /* native function doesn't have operand stack and label stack */
        uint8 *frame_ref = (uint8 *)frame->sp;
        uint32 i, j, k, value_type_cell_num;

        for (i = 0, j = 0; i < func_type->param_count; i++) {
            if (wasm_is_type_reftype(func_type->types[i])
                && !wasm_is_reftype_i31ref(func_type->types[i])) {
                frame_ref[j++] = 1;
#if UINTPTR_MAX == UINT64_MAX
                frame_ref[j++] = 1;
#endif
            }
            else {
                value_type_cell_num =
                    wasm_value_type_cell_num(func_type->types[i]);
                for (k = 0; k < value_type_cell_num; k++)
                    frame_ref[j++] = 0;
            }
        }
    }
#endif

    wasm_exec_env_set_cur_frame(exec_env, frame);

    return true;
}

static inline void
llvm_jit_free_frame_internal(WASMExecEnv *exec_env)
{
    WASMInterpFrame *frame;
    WASMInterpFrame *prev_frame;

    bh_assert(exec_env->module_inst->module_type == Wasm_Module_Bytecode);

    frame = wasm_exec_env_get_cur_frame(exec_env);
    prev_frame = frame->prev_frame;

#if WASM_ENABLE_PERF_PROFILING != 0
    if (frame->function) {
        uint64 time_elapsed = os_time_thread_cputime_us() - frame->time_started;

        frame->function->total_exec_time += time_elapsed;
        frame->function->total_exec_cnt++;

        /* parent function */
        if (prev_frame)
            prev_frame->function->children_exec_time += time_elapsed;
    }
#endif
    wasm_exec_env_free_wasm_frame(exec_env, frame);
    wasm_exec_env_set_cur_frame(exec_env, prev_frame);
}

void
llvm_jit_free_frame(WASMExecEnv *exec_env)
{
    llvm_jit_free_frame_internal(exec_env);
}
#endif /* end of WASM_ENABLE_GC == 0 */

void
llvm_jit_frame_update_profile_info(WASMExecEnv *exec_env, bool alloc_frame)
{
#if WASM_ENABLE_PERF_PROFILING != 0
    WASMInterpFrame *cur_frame = exec_env->cur_frame;

    if (alloc_frame) {
        cur_frame->time_started = os_time_thread_cputime_us();
    }
    else {
        if (cur_frame->function) {
            WASMInterpFrame *prev_frame = cur_frame->prev_frame;
            uint64 time_elapsed =
                os_time_thread_cputime_us() - cur_frame->time_started;

            cur_frame->function->total_exec_time += time_elapsed;
            cur_frame->function->total_exec_cnt++;

            /* parent function */
            if (prev_frame)
                prev_frame->function->children_exec_time += time_elapsed;
        }
    }
#endif

#if WASM_ENABLE_MEMORY_PROFILING != 0
    if (alloc_frame) {
#if WASM_ENABLE_GC == 0
        uint32 wasm_stack_used = (uint8 *)exec_env->cur_frame
                                 + (uint32)offsetof(WASMInterpFrame, lp)
                                 - exec_env->wasm_stack.bottom;
#else
        uint32 wasm_stack_used =
            exec_env->wasm_stack.top - exec_env->wasm_stack.bottom;
#endif
        if (wasm_stack_used > exec_env->max_wasm_stack_used)
            exec_env->max_wasm_stack_used = wasm_stack_used;
    }
#endif
}
#endif /* end of WASM_ENABLE_DUMP_CALL_STACK != 0 \
          || WASM_ENABLE_PERF_PROFILING != 0      \
          || WASM_ENABLE_AOT_STACK_FRAME != 0 */

static bool
llvm_jit_call_func_bytecode(WASMModuleInstance *module_inst,
                            WASMExecEnv *exec_env,
                            WASMFunctionInstance *function, uint32 argc,
                            uint32 argv[])
{
    WASMFuncType *func_type = function->u.func->func_type;
    uint32 result_count = func_type->result_count;
    uint32 ext_ret_count = result_count > 1 ? result_count - 1 : 0;
    uint32 func_idx = (uint32)(function - module_inst->e->functions);
    bool ret = false;

#if (WASM_ENABLE_DUMP_CALL_STACK != 0) || (WASM_ENABLE_PERF_PROFILING != 0) \
    || (WASM_ENABLE_AOT_STACK_FRAME != 0)
    if (!llvm_jit_alloc_frame(exec_env, function - module_inst->e->functions)) {
        /* wasm operand stack overflow has been thrown,
           no need to throw again */
        return false;
    }
#endif

    if (ext_ret_count > 0) {
        uint32 cell_num = 0, i;
        uint8 *ext_ret_types = func_type->types + func_type->param_count + 1;
        uint32 argv1_buf[32], *argv1 = argv1_buf, *ext_rets = NULL;
        uint32 *argv_ret = argv;
        uint32 ext_ret_cell = wasm_get_cell_num(ext_ret_types, ext_ret_count);
        uint64 size;

        /* Allocate memory all arguments */
        size =
            sizeof(uint32) * (uint64)argc /* original arguments */
            + sizeof(void *)
                  * (uint64)ext_ret_count /* extra result values' addr */
            + sizeof(uint32) * (uint64)ext_ret_cell; /* extra result values */
        if (size > sizeof(argv1_buf)) {
            if (size > UINT32_MAX
                || !(argv1 = wasm_runtime_malloc((uint32)size))) {
                wasm_set_exception(module_inst, "allocate memory failed");
                ret = false;
                goto fail;
            }
        }

        /* Copy original arguments */
        bh_memcpy_s(argv1, (uint32)size, argv, sizeof(uint32) * argc);

        /* Get the extra result value's address */
        ext_rets =
            argv1 + argc + sizeof(void *) / sizeof(uint32) * ext_ret_count;

        /* Append each extra result value's address to original arguments */
        for (i = 0; i < ext_ret_count; i++) {
            *(uintptr_t *)(argv1 + argc + sizeof(void *) / sizeof(uint32) * i) =
                (uintptr_t)(ext_rets + cell_num);
            cell_num += wasm_value_type_cell_num(ext_ret_types[i]);
        }

        ret = wasm_runtime_invoke_native(
            exec_env, module_inst->func_ptrs[func_idx], func_type, NULL, NULL,
            argv1, argc, argv);
        if (!ret) {
            if (argv1 != argv1_buf)
                wasm_runtime_free(argv1);
            goto fail;
        }

        /* Get extra result values */
        switch (func_type->types[func_type->param_count]) {
            case VALUE_TYPE_I32:
            case VALUE_TYPE_F32:
#if WASM_ENABLE_REF_TYPES != 0
            case VALUE_TYPE_FUNCREF:
            case VALUE_TYPE_EXTERNREF:
#endif
                argv_ret++;
                break;
            case VALUE_TYPE_I64:
            case VALUE_TYPE_F64:
                argv_ret += 2;
                break;
#if WASM_ENABLE_SIMD != 0
            case VALUE_TYPE_V128:
                argv_ret += 4;
                break;
#endif
            default:
                bh_assert(0);
                break;
        }

        ext_rets =
            argv1 + argc + sizeof(void *) / sizeof(uint32) * ext_ret_count;
        bh_memcpy_s(argv_ret, sizeof(uint32) * cell_num, ext_rets,
                    sizeof(uint32) * cell_num);

        if (argv1 != argv1_buf)
            wasm_runtime_free(argv1);
        ret = true;
    }
    else {
#if WASM_ENABLE_QUICK_AOT_ENTRY != 0
        /* Quick call if the quick jit entry is registered */
        if (func_type->quick_aot_entry) {
            void (*invoke_native)(void *func_ptr, void *exec_env, uint32 *argv,
                                  uint32 *argv_ret) =
                func_type->quick_aot_entry;
            invoke_native(module_inst->func_ptrs[func_idx], exec_env, argv,
                          argv);
            ret = !wasm_copy_exception(module_inst, NULL);
        }
        else
#endif
        {
            ret = wasm_runtime_invoke_native(
                exec_env, module_inst->func_ptrs[func_idx], func_type, NULL,
                NULL, argv, argc, argv);

            if (ret)
                ret = !wasm_copy_exception(module_inst, NULL);
        }
    }

fail:

#if (WASM_ENABLE_DUMP_CALL_STACK != 0) || (WASM_ENABLE_PERF_PROFILING != 0) \
    || (WASM_ENABLE_AOT_STACK_FRAME != 0)
    llvm_jit_free_frame_internal(exec_env);
#endif

    return ret;
}
#endif /* end of WASM_ENABLE_JIT != 0 */

void
wasm_interp_call_wasm(WASMModuleInstance *module_inst, WASMExecEnv *exec_env,
                      WASMFunctionInstance *function, uint32 argc,
                      uint32 argv[])
{
    WASMRuntimeFrame *frame = NULL, *prev_frame, *outs_area;
    RunningMode running_mode =
        wasm_runtime_get_running_mode((WASMModuleInstanceCommon *)module_inst);
    /* Allocate sufficient cells for all kinds of return values.  */
    bool alloc_frame = true;

    if (argc < function->param_cell_num) {
        char buf[128];
        snprintf(buf, sizeof(buf),
                 "invalid argument count %" PRIu32
                 ", must be no smaller than %u",
                 argc, function->param_cell_num);
        wasm_set_exception(module_inst, buf);
        return;
    }
    argc = function->param_cell_num;

#if defined(OS_ENABLE_HW_BOUND_CHECK) && WASM_DISABLE_STACK_HW_BOUND_CHECK == 0
    /*
     * wasm_runtime_detect_native_stack_overflow is done by
     * call_wasm_with_hw_bound_check.
     */
#else
    if (!wasm_runtime_detect_native_stack_overflow(exec_env)) {
        return;
    }
#endif

    if (!function->is_import_func) {
        /* No need to alloc frame when calling LLVM JIT function */
#if WASM_ENABLE_JIT != 0
        if (running_mode == Mode_LLVM_JIT) {
            alloc_frame = false;
        }
#if WASM_ENABLE_LAZY_JIT != 0 && WASM_ENABLE_FAST_JIT != 0
        else if (running_mode == Mode_Multi_Tier_JIT) {
            /* Tier-up from Fast JIT to LLVM JIT, call llvm jit function
               if it is compiled, else call fast jit function */
            uint32 func_idx = (uint32)(function - module_inst->e->functions);
            if (module_inst->module->func_ptrs_compiled
                    [func_idx - module_inst->module->import_function_count]) {
                alloc_frame = false;
            }
        }
#endif
#endif
    }

    if (alloc_frame) {
        unsigned all_cell_num =
            function->ret_cell_num > 2 ? function->ret_cell_num : 2;
        unsigned frame_size;

        prev_frame = wasm_exec_env_get_cur_frame(exec_env);
        /* This frame won't be used by JITed code, so only allocate interp
           frame here.  */
        frame_size = wasm_interp_interp_frame_size(all_cell_num);

        if (!(frame = ALLOC_FRAME(exec_env, frame_size, prev_frame)))
            return;

        outs_area = wasm_exec_env_wasm_stack_top(exec_env);
        frame->function = NULL;
        frame->ip = NULL;
        /* There is no local variable. */
        frame->sp = frame->lp + 0;

        if ((uint8 *)(outs_area->lp + function->param_cell_num)
            > exec_env->wasm_stack.top_boundary) {
            wasm_set_exception(module_inst, "wasm operand stack overflow");
            return;
        }

        if (argc > 0)
            word_copy(outs_area->lp, argv, argc);

        wasm_exec_env_set_cur_frame(exec_env, frame);
    }

#if defined(os_writegsbase)
    {
        WASMMemoryInstance *memory_inst = wasm_get_default_memory(module_inst);
        if (memory_inst)
            /* write base addr of linear memory to GS segment register */
            os_writegsbase(memory_inst->memory_data);
    }
#endif

    if (function->is_import_func) {
#if WASM_ENABLE_MULTI_MODULE != 0
        if (function->import_module_inst) {
            wasm_interp_call_func_import(module_inst, exec_env, function,
                                         frame);
        }
        else
#endif
        {
            /* it is a native function */
            wasm_interp_call_func_native(module_inst, exec_env, function,
                                         frame);
        }
    }
    else {
        if (running_mode == Mode_Interp) {
            wasm_interp_call_func_bytecode(module_inst, exec_env, function,
                                           frame);
        }
#if WASM_ENABLE_FAST_JIT != 0
        else if (running_mode == Mode_Fast_JIT) {
            fast_jit_call_func_bytecode(module_inst, exec_env, function, frame);
        }
#endif
#if WASM_ENABLE_JIT != 0
        else if (running_mode == Mode_LLVM_JIT) {
            llvm_jit_call_func_bytecode(module_inst, exec_env, function, argc,
                                        argv);
        }
#endif
#if WASM_ENABLE_LAZY_JIT != 0 && WASM_ENABLE_FAST_JIT != 0 \
    && WASM_ENABLE_JIT != 0
        else if (running_mode == Mode_Multi_Tier_JIT) {
            /* Tier-up from Fast JIT to LLVM JIT, call llvm jit function
               if it is compiled, else call fast jit function */
            uint32 func_idx = (uint32)(function - module_inst->e->functions);
            if (module_inst->module->func_ptrs_compiled
                    [func_idx - module_inst->module->import_function_count]) {
                llvm_jit_call_func_bytecode(module_inst, exec_env, function,
                                            argc, argv);
            }
            else {
                fast_jit_call_func_bytecode(module_inst, exec_env, function,
                                            frame);
            }
        }
#endif
        else {
            /* There should always be a supported running mode selected */
            bh_assert(0);
        }

        (void)wasm_interp_call_func_bytecode;
#if WASM_ENABLE_FAST_JIT != 0
        (void)fast_jit_call_func_bytecode;
#endif
    }

    /* Output the return value to the caller */
    if (!wasm_copy_exception(module_inst, NULL)) {
        if (alloc_frame) {
            uint32 i;
            for (i = 0; i < function->ret_cell_num; i++) {
                argv[i] = *(frame->sp + i - function->ret_cell_num);
            }
        }
    }
    else {
#if WASM_ENABLE_DUMP_CALL_STACK != 0
        if (wasm_interp_create_call_stack(exec_env)) {
            wasm_interp_dump_call_stack(exec_env, true, NULL, 0);
        }
#endif
    }

    if (alloc_frame) {
        wasm_exec_env_set_cur_frame(exec_env, prev_frame);
        FREE_FRAME(exec_env, frame);
    }
}