+

+

+ parser.add_argument('--enable-tail-call', action='store_true')

+ '--enable-tail-call': options.enable_tail_call,

+ '--enable-tail-call': options.enable_tail_call,

+#define CHECK_CALL_INDIRECT(table, ft, x) \

+ TRAP(CALL_INDIRECT))

+

+#define DO_CALL_INDIRECT(table, t, x, ...) ((t)table.data[x].func)(__VA_ARGS__)

+

+#define CALL_INDIRECT(table, t, ft, x, ...) \

+ (CHECK_CALL_INDIRECT(table, ft, x), \

+ DO_CALL_INDIRECT(table, t, x, __VA_ARGS__))

+ wasm_rt_tailcallee_t func_tailcallee;

+ src_expr->type, src_expr->func, src_expr->func_tailcallee,

+#if (__STDC_VERSION__ < 201112L) && !defined(static_assert)

+#define static_assert(X) \

+ extern int(*assertion(void))[!!sizeof(struct { int x : (X) ? 2 : -1; })];

+#endif

+

+#ifdef _MSC_VER

+#define WEAK_FUNC_DECL(func, fallback) \

+ __pragma(comment(linker, "/alternatename:" #func "=" #fallback)) \

+ \

+ void \

+ fallback(void** instance_ptr, void* tail_call_stack, \

+ wasm_rt_tailcallee_t* next)

+#else

+#define WEAK_FUNC_DECL(func, fallback) \

+ __attribute__((weak)) void func(void** instance_ptr, void* tail_call_stack, \

+ wasm_rt_tailcallee_t* next)

+#endif

+

+#define CHECK_CALL_INDIRECT(table, ft, x) \

+ TRAP(CALL_INDIRECT))

+

+#define DO_CALL_INDIRECT(table, t, x, ...) ((t)table.data[x].func)(__VA_ARGS__)

+

+#define CALL_INDIRECT(table, t, ft, x, ...) \

+ (CHECK_CALL_INDIRECT(table, ft, x), \

+ DO_CALL_INDIRECT(table, t, x, __VA_ARGS__))

+ wasm_rt_tailcallee_t func_tailcallee;

+ src_expr->type, src_expr->func, src_expr->func_tailcallee,

+#if (__STDC_VERSION__ < 201112L) && !defined(static_assert)

+#define static_assert(X) \

+ extern int(*assertion(void))[!!sizeof(struct { int x : (X) ? 2 : -1; })];

+#endif

+

+#ifdef _MSC_VER

+#define WEAK_FUNC_DECL(func, fallback) \

+ __pragma(comment(linker, "/alternatename:" #func "=" #fallback)) \

+ \

+ void \

+ fallback(void** instance_ptr, void* tail_call_stack, \

+ wasm_rt_tailcallee_t* next)

+#else

+#define WEAK_FUNC_DECL(func, fallback) \

+ __attribute__((weak)) void func(void** instance_ptr, void* tail_call_stack, \

+ wasm_rt_tailcallee_t* next)

+#endif

+

+ {RefFunc, w2c_test_t1, (wasm_rt_function_ptr_t)w2c_test_f1, {NULL}, 0},

+#define CHECK_CALL_INDIRECT(table, ft, x) \

+ TRAP(CALL_INDIRECT))

+

+#define DO_CALL_INDIRECT(table, t, x, ...) ((t)table.data[x].func)(__VA_ARGS__)

+

+#define CALL_INDIRECT(table, t, ft, x, ...) \

+ (CHECK_CALL_INDIRECT(table, ft, x), \

+ DO_CALL_INDIRECT(table, t, x, __VA_ARGS__))

+ wasm_rt_tailcallee_t func_tailcallee;

+ src_expr->type, src_expr->func, src_expr->func_tailcallee,

+#if (__STDC_VERSION__ < 201112L) && !defined(static_assert)

+#define static_assert(X) \

+ extern int(*assertion(void))[!!sizeof(struct { int x : (X) ? 2 : -1; })];

+#endif

+

+#ifdef _MSC_VER

+#define WEAK_FUNC_DECL(func, fallback) \

+ __pragma(comment(linker, "/alternatename:" #func "=" #fallback)) \

+ \

+ void \

+ fallback(void** instance_ptr, void* tail_call_stack, \

+ wasm_rt_tailcallee_t* next)

+#else

+#define WEAK_FUNC_DECL(func, fallback) \

+ __attribute__((weak)) void func(void** instance_ptr, void* tail_call_stack, \

+ wasm_rt_tailcallee_t* next)

+#endif

+

+#define CHECK_CALL_INDIRECT(table, ft, x) \

+ TRAP(CALL_INDIRECT))

+

+#define DO_CALL_INDIRECT(table, t, x, ...) ((t)table.data[x].func)(__VA_ARGS__)

+

+#define CALL_INDIRECT(table, t, ft, x, ...) \

+ (CHECK_CALL_INDIRECT(table, ft, x), \

+ DO_CALL_INDIRECT(table, t, x, __VA_ARGS__))

+ wasm_rt_tailcallee_t func_tailcallee;

+ src_expr->type, src_expr->func, src_expr->func_tailcallee,

+#if (__STDC_VERSION__ < 201112L) && !defined(static_assert)

+#define static_assert(X) \

+ extern int(*assertion(void))[!!sizeof(struct { int x : (X) ? 2 : -1; })];

+#endif

+

+#ifdef _MSC_VER

+#define WEAK_FUNC_DECL(func, fallback) \

+ __pragma(comment(linker, "/alternatename:" #func "=" #fallback)) \

+ \

+ void \

+ fallback(void** instance_ptr, void* tail_call_stack, \

+ wasm_rt_tailcallee_t* next)

+#else

+#define WEAK_FUNC_DECL(func, fallback) \

+ __attribute__((weak)) void func(void** instance_ptr, void* tail_call_stack, \

+ wasm_rt_tailcallee_t* next)

+#endif

+

+ {RefFunc, w2c_test_t0, (wasm_rt_function_ptr_t)w2c_wasi__snapshot__preview1_fd_write, {NULL}, offsetof(w2c_test, w2c_wasi__snapshot__preview1_instance)},

+#define CHECK_CALL_INDIRECT(table, ft, x) \

+ TRAP(CALL_INDIRECT))

+

+#define DO_CALL_INDIRECT(table, t, x, ...) ((t)table.data[x].func)(__VA_ARGS__)

+

+#define CALL_INDIRECT(table, t, ft, x, ...) \

+ (CHECK_CALL_INDIRECT(table, ft, x), \

+ DO_CALL_INDIRECT(table, t, x, __VA_ARGS__))

+ wasm_rt_tailcallee_t func_tailcallee;

+ src_expr->type, src_expr->func, src_expr->func_tailcallee,

+#if (__STDC_VERSION__ < 201112L) && !defined(static_assert)

+#define static_assert(X) \

+ extern int(*assertion(void))[!!sizeof(struct { int x : (X) ? 2 : -1; })];

+#endif

+

+#ifdef _MSC_VER

+#define WEAK_FUNC_DECL(func, fallback) \

+ __pragma(comment(linker, "/alternatename:" #func "=" #fallback)) \

+ \

+ void \

+ fallback(void** instance_ptr, void* tail_call_stack, \

+ wasm_rt_tailcallee_t* next)

+#else

+#define WEAK_FUNC_DECL(func, fallback) \

+ __attribute__((weak)) void func(void** instance_ptr, void* tail_call_stack, \

+ wasm_rt_tailcallee_t* next)

+#endif

+

+;;; TOOL: run-spec-wasm2c

+;;; STDIN_FILE: third_party/testsuite/proposals/tail-call/return_call.wast

+;;; ARGS*: --enable-tail-call

+(;; STDOUT ;;;

+31/31 tests passed.

+;;; STDOUT ;;)

+;;; TOOL: run-spec-wasm2c

+;;; STDIN_FILE: third_party/testsuite/proposals/tail-call/return_call_indirect.wast

+;;; ARGS*: --enable-tail-call

+(;; STDOUT ;;;

+47/47 tests passed.

+;;; STDOUT ;;)

+;;; TOOL: run-wasm2c

+;;; ARGS0: --debug-names

+;;; ARGS*: --enable-tail-call

+(type $i32_f32 (func (param i32 f32)))

+(import "spectest" "print_i32_f32" (func $print_i32_f32 (type $i32_f32)))

+(table $tab funcref (elem $print_i32_f32))

+(func (export "tailcaller")

+ (return_call_indirect (type $i32_f32)

+ (i32.const 1) (f32.const 2.0) (i32.const 0)))

+(func $infiniteloop (param i32 f64) (result i32 f64)

+ (return_call $infiniteloop (local.get 0) (local.get 1)))

+(;; STDOUT ;;;

+/* Automatically generated by wasm2c */

+#ifndef WASM_H_GENERATED_

+#define WASM_H_GENERATED_

+

+#include "wasm-rt.h"

+

+#include <stdint.h>

+

+#ifndef WASM_RT_CORE_TYPES_DEFINED

+#define WASM_RT_CORE_TYPES_DEFINED

+typedef uint8_t u8;

+typedef int8_t s8;

+typedef uint16_t u16;

+typedef int16_t s16;

+typedef uint32_t u32;

+typedef int32_t s32;

+typedef uint64_t u64;

+typedef int64_t s64;

+typedef float f32;

+typedef double f64;

+#endif

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+struct w2c_spectest;

+

+typedef struct w2c_test {

+ struct w2c_spectest* w2c_spectest_instance;

+ wasm_rt_funcref_table_t w2c_tab;

+} w2c_test;

+

+void wasm2c_test_instantiate(w2c_test*, struct w2c_spectest*);

+void wasm2c_test_free(w2c_test*);

+wasm_rt_func_type_t wasm2c_test_get_func_type(uint32_t param_count, uint32_t result_count, ...);

+

+#ifndef wasm_multi_id

+#define wasm_multi_id wasm_multi_id

+struct wasm_multi_id {

+ u32 i0;

+ f64 d1;

+};

+#endif /* wasm_multi_id */

+

+/* import: 'spectest' 'print_i32_f32' */

+void w2c_spectest_print_i32_f32(struct w2c_spectest*, u32, f32);

+void wasm_tailcall_w2c_spectest_print_i32_f32(void **instance_ptr, void *tail_call_stack, wasm_rt_tailcallee_t *next);

+

+/* export: 'tailcaller' */

+void w2c_test_tailcaller(w2c_test*);

+

+/* export for tail-call of 'tailcaller' */

+void wasm_tailcall_w2c_test_tailcaller(void **instance_ptr, void *tail_call_stack, wasm_rt_tailcallee_t *next);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif /* WASM_H_GENERATED_ */

+/* Automatically generated by wasm2c */

+#include <assert.h>

+#include <math.h>

+#include <stdarg.h>

+#include <stddef.h>

+#include <string.h>

+#if defined(__MINGW32__)

+#include <malloc.h>

+#elif defined(_MSC_VER)

+#include <intrin.h>

+#include <malloc.h>

+#define alloca _alloca

+#elif defined(__FreeBSD__) || defined(__OpenBSD__)

+#include <stdlib.h>

+#else

+#include <alloca.h>

+#endif

+

+#include "wasm.h"

+

+#define TRAP(x) (wasm_rt_trap(WASM_RT_TRAP_##x), 0)

+

+#if WASM_RT_USE_STACK_DEPTH_COUNT

+#define FUNC_PROLOGUE \

+ if (++wasm_rt_call_stack_depth > WASM_RT_MAX_CALL_STACK_DEPTH) \

+ TRAP(EXHAUSTION);

+

+#define FUNC_EPILOGUE --wasm_rt_call_stack_depth

+#else

+#define FUNC_PROLOGUE

+

+#define FUNC_EPILOGUE

+#endif

+

+#define UNREACHABLE TRAP(UNREACHABLE)

+

+static inline bool func_types_eq(const wasm_rt_func_type_t a,

+ const wasm_rt_func_type_t b) {

+ return (a == b) || LIKELY(a && b && !memcmp(a, b, 32));

+}

+

+#define CHECK_CALL_INDIRECT(table, ft, x) \

+ (LIKELY((x) < table.size && table.data[x].func && \

+ func_types_eq(ft, table.data[x].func_type)) || \

+ TRAP(CALL_INDIRECT))

+

+#define DO_CALL_INDIRECT(table, t, x, ...) ((t)table.data[x].func)(__VA_ARGS__)

+

+#define CALL_INDIRECT(table, t, ft, x, ...) \

+ (CHECK_CALL_INDIRECT(table, ft, x), \

+ DO_CALL_INDIRECT(table, t, x, __VA_ARGS__))

+

+#ifdef SUPPORT_MEMORY64

+#define RANGE_CHECK(mem, offset, len) \

+ do { \

+ uint64_t res; \

+ if (__builtin_add_overflow(offset, len, &res)) \

+ TRAP(OOB); \

+ if (UNLIKELY(res > mem->size)) \

+ TRAP(OOB); \

+ } while (0);

+#else

+#define RANGE_CHECK(mem, offset, len) \

+ if (UNLIKELY(offset + (uint64_t)len > mem->size)) \

+ TRAP(OOB);

+#endif

+

+#if WASM_RT_MEMCHECK_GUARD_PAGES

+#define MEMCHECK(mem, a, t)

+#else

+#define MEMCHECK(mem, a, t) RANGE_CHECK(mem, a, sizeof(t))

+#endif

+

+#ifdef __GNUC__

+#define FORCE_READ_INT(var) __asm__("" ::"r"(var));

+// Clang on Mips requires "f" constraints on floats

+// See https://github.com/llvm/llvm-project/issues/64241

+#if defined(__clang__) && \

+ (defined(mips) || defined(__mips__) || defined(__mips))

+#define FORCE_READ_FLOAT(var) __asm__("" ::"f"(var));

+#else

+#define FORCE_READ_FLOAT(var) __asm__("" ::"r"(var));

+#endif

+#else

+#define FORCE_READ_INT(var)

+#define FORCE_READ_FLOAT(var)

+#endif

+

+#if WABT_BIG_ENDIAN

+static inline void load_data(void* dest, const void* src, size_t n) {

+ if (!n) {

+ return;

+ }

+ size_t i = 0;

+ u8* dest_chars = dest;

+ wasm_rt_memcpy(dest, src, n);

+ for (i = 0; i < (n >> 1); i++) {

+ u8 cursor = dest_chars[i];

+ dest_chars[i] = dest_chars[n - i - 1];

+ dest_chars[n - i - 1] = cursor;

+ }

+}

+#define LOAD_DATA(m, o, i, s) \

+ do { \

+ RANGE_CHECK((&m), m.size - o - s, s); \

+ load_data(&(m.data[m.size - o - s]), i, s); \

+ } while (0)

+#define DEFINE_LOAD(name, t1, t2, t3, force_read) \

+ static inline t3 name(wasm_rt_memory_t* mem, u64 addr) { \

+ MEMCHECK(mem, addr, t1); \

+ t1 result; \

+ wasm_rt_memcpy(&result, &mem->data[mem->size - addr - sizeof(t1)], \

+ sizeof(t1)); \

+ force_read(result); \

+ return (t3)(t2)result; \

+ }

+

+#define DEFINE_STORE(name, t1, t2) \

+ static inline void name(wasm_rt_memory_t* mem, u64 addr, t2 value) { \

+ MEMCHECK(mem, addr, t1); \

+ t1 wrapped = (t1)value; \

+ wasm_rt_memcpy(&mem->data[mem->size - addr - sizeof(t1)], &wrapped, \

+ sizeof(t1)); \

+ }

+#else

+static inline void load_data(void* dest, const void* src, size_t n) {

+ if (!n) {

+ return;

+ }

+ wasm_rt_memcpy(dest, src, n);

+}

+#define LOAD_DATA(m, o, i, s) \

+ do { \

+ RANGE_CHECK((&m), o, s); \

+ load_data(&(m.data[o]), i, s); \

+ } while (0)

+#define DEFINE_LOAD(name, t1, t2, t3, force_read) \

+ static inline t3 name(wasm_rt_memory_t* mem, u64 addr) { \

+ MEMCHECK(mem, addr, t1); \

+ t1 result; \

+ wasm_rt_memcpy(&result, &mem->data[addr], sizeof(t1)); \

+ force_read(result); \

+ return (t3)(t2)result; \

+ }

+

+#define DEFINE_STORE(name, t1, t2) \

+ static inline void name(wasm_rt_memory_t* mem, u64 addr, t2 value) { \

+ MEMCHECK(mem, addr, t1); \

+ t1 wrapped = (t1)value; \

+ wasm_rt_memcpy(&mem->data[addr], &wrapped, sizeof(t1)); \

+ }

+#endif

+

+DEFINE_LOAD(i32_load, u32, u32, u32, FORCE_READ_INT)

+DEFINE_LOAD(i64_load, u64, u64, u64, FORCE_READ_INT)

+DEFINE_LOAD(f32_load, f32, f32, f32, FORCE_READ_FLOAT)

+DEFINE_LOAD(f64_load, f64, f64, f64, FORCE_READ_FLOAT)

+DEFINE_LOAD(i32_load8_s, s8, s32, u32, FORCE_READ_INT)

+DEFINE_LOAD(i64_load8_s, s8, s64, u64, FORCE_READ_INT)

+DEFINE_LOAD(i32_load8_u, u8, u32, u32, FORCE_READ_INT)

+DEFINE_LOAD(i64_load8_u, u8, u64, u64, FORCE_READ_INT)

+DEFINE_LOAD(i32_load16_s, s16, s32, u32, FORCE_READ_INT)

+DEFINE_LOAD(i64_load16_s, s16, s64, u64, FORCE_READ_INT)

+DEFINE_LOAD(i32_load16_u, u16, u32, u32, FORCE_READ_INT)

+DEFINE_LOAD(i64_load16_u, u16, u64, u64, FORCE_READ_INT)

+DEFINE_LOAD(i64_load32_s, s32, s64, u64, FORCE_READ_INT)

+DEFINE_LOAD(i64_load32_u, u32, u64, u64, FORCE_READ_INT)

+DEFINE_STORE(i32_store, u32, u32)

+DEFINE_STORE(i64_store, u64, u64)

+DEFINE_STORE(f32_store, f32, f32)

+DEFINE_STORE(f64_store, f64, f64)

+DEFINE_STORE(i32_store8, u8, u32)

+DEFINE_STORE(i32_store16, u16, u32)

+DEFINE_STORE(i64_store8, u8, u64)

+DEFINE_STORE(i64_store16, u16, u64)

+DEFINE_STORE(i64_store32, u32, u64)

+

+#if defined(_MSC_VER)

+

+// Adapted from

+// https://github.com/nemequ/portable-snippets/blob/master/builtin/builtin.h

+

+static inline int I64_CLZ(unsigned long long v) {

+ unsigned long r = 0;

+#if defined(_M_AMD64) || defined(_M_ARM)

+ if (_BitScanReverse64(&r, v)) {

+ return 63 - r;

+ }

+#else

+ if (_BitScanReverse(&r, (unsigned long)(v >> 32))) {

+ return 31 - r;

+ } else if (_BitScanReverse(&r, (unsigned long)v)) {

+ return 63 - r;

+ }

+#endif

+ return 64;

+}

+

+static inline int I32_CLZ(unsigned long v) {

+ unsigned long r = 0;

+ if (_BitScanReverse(&r, v)) {

+ return 31 - r;

+ }

+ return 32;

+}

+

+static inline int I64_CTZ(unsigned long long v) {

+ if (!v) {

+ return 64;

+ }

+ unsigned long r = 0;

+#if defined(_M_AMD64) || defined(_M_ARM)

+ _BitScanForward64(&r, v);

+ return (int)r;

+#else

+ if (_BitScanForward(&r, (unsigned int)(v))) {

+ return (int)(r);

+ }

+

+ _BitScanForward(&r, (unsigned int)(v >> 32));

+ return (int)(r + 32);

+#endif

+}

+

+static inline int I32_CTZ(unsigned long v) {

+ if (!v) {

+ return 32;

+ }

+ unsigned long r = 0;

+ _BitScanForward(&r, v);

+ return (int)r;

+}

+

+#define POPCOUNT_DEFINE_PORTABLE(f_n, T) \

+ static inline u32 f_n(T x) { \

+ x = x - ((x >> 1) & (T) ~(T)0 / 3); \

+ x = (x & (T) ~(T)0 / 15 * 3) + ((x >> 2) & (T) ~(T)0 / 15 * 3); \

+ x = (x + (x >> 4)) & (T) ~(T)0 / 255 * 15; \

+ return (T)(x * ((T) ~(T)0 / 255)) >> (sizeof(T) - 1) * 8; \

+ }

+

+POPCOUNT_DEFINE_PORTABLE(I32_POPCNT, u32)

+POPCOUNT_DEFINE_PORTABLE(I64_POPCNT, u64)

+

+#undef POPCOUNT_DEFINE_PORTABLE

+

+#else

+

+#define I32_CLZ(x) ((x) ? __builtin_clz(x) : 32)

+#define I64_CLZ(x) ((x) ? __builtin_clzll(x) : 64)

+#define I32_CTZ(x) ((x) ? __builtin_ctz(x) : 32)

+#define I64_CTZ(x) ((x) ? __builtin_ctzll(x) : 64)

+#define I32_POPCNT(x) (__builtin_popcount(x))

+#define I64_POPCNT(x) (__builtin_popcountll(x))

+

+#endif

+

+#define DIV_S(ut, min, x, y) \

+ ((UNLIKELY((y) == 0)) \

+ ? TRAP(DIV_BY_ZERO) \

+ : (UNLIKELY((x) == min && (y) == -1)) ? TRAP(INT_OVERFLOW) \

+ : (ut)((x) / (y)))

+

+#define REM_S(ut, min, x, y) \

+ ((UNLIKELY((y) == 0)) \

+ ? TRAP(DIV_BY_ZERO) \

+ : (UNLIKELY((x) == min && (y) == -1)) ? 0 : (ut)((x) % (y)))

+

+#define I32_DIV_S(x, y) DIV_S(u32, INT32_MIN, (s32)x, (s32)y)

+#define I64_DIV_S(x, y) DIV_S(u64, INT64_MIN, (s64)x, (s64)y)

+#define I32_REM_S(x, y) REM_S(u32, INT32_MIN, (s32)x, (s32)y)

+#define I64_REM_S(x, y) REM_S(u64, INT64_MIN, (s64)x, (s64)y)

+

+#define DIVREM_U(op, x, y) \

+ ((UNLIKELY((y) == 0)) ? TRAP(DIV_BY_ZERO) : ((x)op(y)))

+

+#define DIV_U(x, y) DIVREM_U(/, x, y)

+#define REM_U(x, y) DIVREM_U(%, x, y)

+

+#define ROTL(x, y, mask) \

+ (((x) << ((y) & (mask))) | ((x) >> (((mask) - (y) + 1) & (mask))))

+#define ROTR(x, y, mask) \

+ (((x) >> ((y) & (mask))) | ((x) << (((mask) - (y) + 1) & (mask))))

+

+#define I32_ROTL(x, y) ROTL(x, y, 31)

+#define I64_ROTL(x, y) ROTL(x, y, 63)

+#define I32_ROTR(x, y) ROTR(x, y, 31)

+#define I64_ROTR(x, y) ROTR(x, y, 63)

+

+#define FMIN(x, y) \

+ ((UNLIKELY((x) != (x))) \

+ ? NAN \

+ : (UNLIKELY((y) != (y))) \

+ ? NAN \

+ : (UNLIKELY((x) == 0 && (y) == 0)) ? (signbit(x) ? x : y) \

+ : (x < y) ? x : y)

+

+#define FMAX(x, y) \

+ ((UNLIKELY((x) != (x))) \

+ ? NAN \

+ : (UNLIKELY((y) != (y))) \

+ ? NAN \

+ : (UNLIKELY((x) == 0 && (y) == 0)) ? (signbit(x) ? y : x) \

+ : (x > y) ? x : y)

+

+#define TRUNC_S(ut, st, ft, min, minop, max, x) \

+ ((UNLIKELY((x) != (x))) \

+ ? TRAP(INVALID_CONVERSION) \

+ : (UNLIKELY(!((x)minop(min) && (x) < (max)))) ? TRAP(INT_OVERFLOW) \

+ : (ut)(st)(x))

+

+#define I32_TRUNC_S_F32(x) \

+ TRUNC_S(u32, s32, f32, (f32)INT32_MIN, >=, 2147483648.f, x)

+#define I64_TRUNC_S_F32(x) \

+ TRUNC_S(u64, s64, f32, (f32)INT64_MIN, >=, (f32)INT64_MAX, x)

+#define I32_TRUNC_S_F64(x) \

+ TRUNC_S(u32, s32, f64, -2147483649., >, 2147483648., x)

+#define I64_TRUNC_S_F64(x) \

+ TRUNC_S(u64, s64, f64, (f64)INT64_MIN, >=, (f64)INT64_MAX, x)

+

+#define TRUNC_U(ut, ft, max, x) \

+ ((UNLIKELY((x) != (x))) \

+ ? TRAP(INVALID_CONVERSION) \

+ : (UNLIKELY(!((x) > (ft)-1 && (x) < (max)))) ? TRAP(INT_OVERFLOW) \

+ : (ut)(x))

+

+#define I32_TRUNC_U_F32(x) TRUNC_U(u32, f32, 4294967296.f, x)

+#define I64_TRUNC_U_F32(x) TRUNC_U(u64, f32, (f32)UINT64_MAX, x)

+#define I32_TRUNC_U_F64(x) TRUNC_U(u32, f64, 4294967296., x)

+#define I64_TRUNC_U_F64(x) TRUNC_U(u64, f64, (f64)UINT64_MAX, x)

+

+#define TRUNC_SAT_S(ut, st, ft, min, smin, minop, max, smax, x) \

+ ((UNLIKELY((x) != (x))) \

+ ? 0 \

+ : (UNLIKELY(!((x)minop(min)))) \

+ ? smin \

+ : (UNLIKELY(!((x) < (max)))) ? smax : (ut)(st)(x))

+

+#define I32_TRUNC_SAT_S_F32(x) \

+ TRUNC_SAT_S(u32, s32, f32, (f32)INT32_MIN, INT32_MIN, >=, 2147483648.f, \

+ INT32_MAX, x)

+#define I64_TRUNC_SAT_S_F32(x) \

+ TRUNC_SAT_S(u64, s64, f32, (f32)INT64_MIN, INT64_MIN, >=, (f32)INT64_MAX, \

+ INT64_MAX, x)

+#define I32_TRUNC_SAT_S_F64(x) \

+ TRUNC_SAT_S(u32, s32, f64, -2147483649., INT32_MIN, >, 2147483648., \

+ INT32_MAX, x)

+#define I64_TRUNC_SAT_S_F64(x) \

+ TRUNC_SAT_S(u64, s64, f64, (f64)INT64_MIN, INT64_MIN, >=, (f64)INT64_MAX, \

+ INT64_MAX, x)

+

+#define TRUNC_SAT_U(ut, ft, max, smax, x) \

+ ((UNLIKELY((x) != (x))) ? 0 \

+ : (UNLIKELY(!((x) > (ft)-1))) \

+ ? 0 \

+ : (UNLIKELY(!((x) < (max)))) ? smax : (ut)(x))

+

+#define I32_TRUNC_SAT_U_F32(x) \

+ TRUNC_SAT_U(u32, f32, 4294967296.f, UINT32_MAX, x)

+#define I64_TRUNC_SAT_U_F32(x) \

+ TRUNC_SAT_U(u64, f32, (f32)UINT64_MAX, UINT64_MAX, x)

+#define I32_TRUNC_SAT_U_F64(x) TRUNC_SAT_U(u32, f64, 4294967296., UINT32_MAX, x)

+#define I64_TRUNC_SAT_U_F64(x) \

+ TRUNC_SAT_U(u64, f64, (f64)UINT64_MAX, UINT64_MAX, x)

+

+#define DEFINE_REINTERPRET(name, t1, t2) \

+ static inline t2 name(t1 x) { \

+ t2 result; \

+ wasm_rt_memcpy(&result, &x, sizeof(result)); \

+ return result; \

+ }

+

+DEFINE_REINTERPRET(f32_reinterpret_i32, u32, f32)

+DEFINE_REINTERPRET(i32_reinterpret_f32, f32, u32)

+DEFINE_REINTERPRET(f64_reinterpret_i64, u64, f64)

+DEFINE_REINTERPRET(i64_reinterpret_f64, f64, u64)

+

+static float quiet_nanf(float x) {

+ uint32_t tmp;

+ wasm_rt_memcpy(&tmp, &x, 4);

+ tmp |= 0x7fc00000lu;

+ wasm_rt_memcpy(&x, &tmp, 4);

+ return x;

+}

+

+static double quiet_nan(double x) {

+ uint64_t tmp;

+ wasm_rt_memcpy(&tmp, &x, 8);

+ tmp |= 0x7ff8000000000000llu;

+ wasm_rt_memcpy(&x, &tmp, 8);

+ return x;

+}

+

+static double wasm_quiet(double x) {

+ if (UNLIKELY(isnan(x))) {

+ return quiet_nan(x);

+ }

+ return x;

+}

+

+static float wasm_quietf(float x) {

+ if (UNLIKELY(isnan(x))) {

+ return quiet_nanf(x);

+ }

+ return x;

+}

+

+static double wasm_floor(double x) {

+ if (UNLIKELY(isnan(x))) {

+ return quiet_nan(x);

+ }

+ return floor(x);

+}

+

+static float wasm_floorf(float x) {

+ if (UNLIKELY(isnan(x))) {

+ return quiet_nanf(x);

+ }

+ return floorf(x);

+}

+

+static double wasm_ceil(double x) {

+ if (UNLIKELY(isnan(x))) {

+ return quiet_nan(x);

+ }

+ return ceil(x);

+}

+

+static float wasm_ceilf(float x) {

+ if (UNLIKELY(isnan(x))) {

+ return quiet_nanf(x);

+ }

+ return ceilf(x);

+}

+

+static double wasm_trunc(double x) {

+ if (UNLIKELY(isnan(x))) {

+ return quiet_nan(x);

+ }

+ return trunc(x);

+}

+

+static float wasm_truncf(float x) {

+ if (UNLIKELY(isnan(x))) {

+ return quiet_nanf(x);

+ }

+ return truncf(x);

+}

+

+static float wasm_nearbyintf(float x) {

+ if (UNLIKELY(isnan(x))) {

+ return quiet_nanf(x);

+ }

+ return nearbyintf(x);

+}

+

+static double wasm_nearbyint(double x) {

+ if (UNLIKELY(isnan(x))) {

+ return quiet_nan(x);

+ }

+ return nearbyint(x);

+}

+

+static float wasm_fabsf(float x) {

+ if (UNLIKELY(isnan(x))) {

+ uint32_t tmp;

+ wasm_rt_memcpy(&tmp, &x, 4);

+ tmp = tmp & ~(1UL << 31);

+ wasm_rt_memcpy(&x, &tmp, 4);

+ return x;

+ }

+ return fabsf(x);

+}

+

+static double wasm_fabs(double x) {

+ if (UNLIKELY(isnan(x))) {

+ uint64_t tmp;

+ wasm_rt_memcpy(&tmp, &x, 8);

+ tmp = tmp & ~(1ULL << 63);

+ wasm_rt_memcpy(&x, &tmp, 8);

+ return x;

+ }

+ return fabs(x);

+}

+

+static double wasm_sqrt(double x) {

+ if (UNLIKELY(isnan(x))) {

+ return quiet_nan(x);

+ }

+ return sqrt(x);

+}

+

+static float wasm_sqrtf(float x) {

+ if (UNLIKELY(isnan(x))) {

+ return quiet_nanf(x);

+ }

+ return sqrtf(x);

+}

+

+static inline void memory_fill(wasm_rt_memory_t* mem, u32 d, u32 val, u32 n) {

+ RANGE_CHECK(mem, d, n);

+ memset(mem->data + d, val, n);

+}

+

+static inline void memory_copy(wasm_rt_memory_t* dest,

+ const wasm_rt_memory_t* src,

+ u32 dest_addr,

+ u32 src_addr,

+ u32 n) {

+ RANGE_CHECK(dest, dest_addr, n);

+ RANGE_CHECK(src, src_addr, n);

+ memmove(dest->data + dest_addr, src->data + src_addr, n);

+}

+

+static inline void memory_init(wasm_rt_memory_t* dest,

+ const u8* src,

+ u32 src_size,

+ u32 dest_addr,

+ u32 src_addr,

+ u32 n) {

+ if (UNLIKELY(src_addr + (uint64_t)n > src_size))

+ TRAP(OOB);

+ LOAD_DATA((*dest), dest_addr, src + src_addr, n);

+}

+

+typedef struct {

+ enum { RefFunc, RefNull, GlobalGet } expr_type;

+ wasm_rt_func_type_t type;

+ wasm_rt_function_ptr_t func;

+ wasm_rt_tailcallee_t func_tailcallee;

+ size_t module_offset;

+} wasm_elem_segment_expr_t;

+

+static inline void funcref_table_init(wasm_rt_funcref_table_t* dest,

+ const wasm_elem_segment_expr_t* src,

+ u32 src_size,

+ u32 dest_addr,

+ u32 src_addr,

+ u32 n,

+ void* module_instance) {

+ if (UNLIKELY(src_addr + (uint64_t)n > src_size))

+ TRAP(OOB);

+ if (UNLIKELY(dest_addr + (uint64_t)n > dest->size))

+ TRAP(OOB);

+ for (u32 i = 0; i < n; i++) {

+ const wasm_elem_segment_expr_t* const src_expr = &src[src_addr + i];

+ wasm_rt_funcref_t* const dest_val = &(dest->data[dest_addr + i]);

+ switch (src_expr->expr_type) {

+ case RefFunc:

+ *dest_val = (wasm_rt_funcref_t){

+ src_expr->type, src_expr->func, src_expr->func_tailcallee,

+ (char*)module_instance + src_expr->module_offset};

+ break;

+ case RefNull:

+ *dest_val = wasm_rt_funcref_null_value;

+ break;

+ case GlobalGet:

+ *dest_val = **(wasm_rt_funcref_t**)((char*)module_instance +

+ src_expr->module_offset);

+ break;

+ }

+ }

+}

+

+// Currently wasm2c only supports initializing externref tables with ref.null.

+static inline void externref_table_init(wasm_rt_externref_table_t* dest,

+ u32 src_size,

+ u32 dest_addr,

+ u32 src_addr,

+ u32 n) {

+ if (UNLIKELY(src_addr + (uint64_t)n > src_size))

+ TRAP(OOB);

+ if (UNLIKELY(dest_addr + (uint64_t)n > dest->size))

+ TRAP(OOB);

+ for (u32 i = 0; i < n; i++) {

+ dest->data[dest_addr + i] = wasm_rt_externref_null_value;

+ }

+}

+

+#define DEFINE_TABLE_COPY(type) \

+ static inline void type##_table_copy(wasm_rt_##type##_table_t* dest, \

+ const wasm_rt_##type##_table_t* src, \

+ u32 dest_addr, u32 src_addr, u32 n) { \

+ if (UNLIKELY(dest_addr + (uint64_t)n > dest->size)) \

+ TRAP(OOB); \

+ if (UNLIKELY(src_addr + (uint64_t)n > src->size)) \

+ TRAP(OOB); \

+ \

+ memmove(dest->data + dest_addr, src->data + src_addr, \

+ n * sizeof(wasm_rt_##type##_t)); \

+ }

+

+DEFINE_TABLE_COPY(funcref)

+DEFINE_TABLE_COPY(externref)

+

+#define DEFINE_TABLE_GET(type) \

+ static inline wasm_rt_##type##_t type##_table_get( \

+ const wasm_rt_##type##_table_t* table, u32 i) { \

+ if (UNLIKELY(i >= table->size)) \

+ TRAP(OOB); \

+ return table->data[i]; \

+ }

+

+DEFINE_TABLE_GET(funcref)

+DEFINE_TABLE_GET(externref)

+

+#define DEFINE_TABLE_SET(type) \

+ static inline void type##_table_set(const wasm_rt_##type##_table_t* table, \

+ u32 i, const wasm_rt_##type##_t val) { \

+ if (UNLIKELY(i >= table->size)) \

+ TRAP(OOB); \

+ table->data[i] = val; \

+ }

+

+DEFINE_TABLE_SET(funcref)

+DEFINE_TABLE_SET(externref)

+

+#define DEFINE_TABLE_FILL(type) \

+ static inline void type##_table_fill(const wasm_rt_##type##_table_t* table, \

+ u32 d, const wasm_rt_##type##_t val, \

+ u32 n) { \

+ if (UNLIKELY((uint64_t)d + n > table->size)) \

+ TRAP(OOB); \

+ for (uint32_t i = d; i < d + n; i++) { \

+ table->data[i] = val; \

+ } \

+ }

+

+DEFINE_TABLE_FILL(funcref)

+DEFINE_TABLE_FILL(externref)

+

+#if defined(__GNUC__) || defined(__clang__)

+#define FUNC_TYPE_DECL_EXTERN_T(x) extern const char* const x

+#define FUNC_TYPE_EXTERN_T(x) const char* const x

+#define FUNC_TYPE_T(x) static const char* const x

+#else

+#define FUNC_TYPE_DECL_EXTERN_T(x) extern const char x[]

+#define FUNC_TYPE_EXTERN_T(x) const char x[]

+#define FUNC_TYPE_T(x) static const char x[]

+#endif

+

+#if (__STDC_VERSION__ < 201112L) && !defined(static_assert)

+#define static_assert(X) \

+ extern int(*assertion(void))[!!sizeof(struct { int x : (X) ? 2 : -1; })];

+#endif

+

+#ifdef _MSC_VER

+#define WEAK_FUNC_DECL(func, fallback) \

+ __pragma(comment(linker, "/alternatename:" #func "=" #fallback)) \

+ \

+ void \

+ fallback(void** instance_ptr, void* tail_call_stack, \

+ wasm_rt_tailcallee_t* next)

+#else

+#define WEAK_FUNC_DECL(func, fallback) \

+ __attribute__((weak)) void func(void** instance_ptr, void* tail_call_stack, \

+ wasm_rt_tailcallee_t* next)

+#endif

+

+static void w2c_test_tailcaller_0(w2c_test*);

+static void wasm_tailcall_w2c_test_tailcaller_0(void **instance_ptr, void *tail_call_stack, wasm_rt_tailcallee_t *next);

+static struct wasm_multi_id w2c_test_infiniteloop(w2c_test*, u32, f64);

+static void wasm_tailcall_w2c_test_infiniteloop(void **instance_ptr, void *tail_call_stack, wasm_rt_tailcallee_t *next);

+

+#ifndef wasm_multi_if

+#define wasm_multi_if wasm_multi_if

+struct wasm_multi_if {

+ u32 i0;

+ f32 f1;

+};

+#endif /* wasm_multi_if */

+

+FUNC_TYPE_T(w2c_test_i32_f32) = "\x98\x89\x5c\xbd\x28\xfd\x0e\x4d\xc5\xdc\x68\x2c\x7c\xee\x61\x09\x14\x19\x30\x62\xc2\x2f\x49\xc5\xb5\x81\x57\x55\x6b\xe7\xa5\xb9";

+FUNC_TYPE_T(w2c_test_t1) = "\x36\xa9\xe7\xf1\xc9\x5b\x82\xff\xb9\x97\x43\xe0\xc5\xc4\xce\x95\xd8\x3c\x9a\x43\x0a\xac\x59\xf8\x4e\xf3\xcb\xfa\xb6\x14\x50\x68";

+FUNC_TYPE_T(w2c_test_t2) = "\xe5\x11\x86\xc7\x24\xdb\x44\x80\xbe\xd1\xe0\x89\xbc\xc0\x20\xea\xfb\x1c\x9a\x27\xa5\xc3\xdb\xca\x5d\xb0\x05\x0f\x7c\x03\x74\x0a";

+

+static const wasm_elem_segment_expr_t elem_segment_exprs_w2c_test_e0[] = {

+ {RefFunc, w2c_test_i32_f32, (wasm_rt_function_ptr_t)w2c_spectest_print_i32_f32, {wasm_tailcall_w2c_spectest_print_i32_f32}, offsetof(w2c_test, w2c_spectest_instance)},

+};

+

+static void init_tables(w2c_test* instance) {

+ wasm_rt_allocate_funcref_table(&instance->w2c_tab, 1, 1);

+ funcref_table_init(&instance->w2c_tab, elem_segment_exprs_w2c_test_e0, 1, 0u, 0, 1, instance);

+}

+

+static void init_elem_instances(w2c_test *instance) {

+}

+

+/* export: 'tailcaller' */

+void w2c_test_tailcaller(w2c_test* instance) {

+ w2c_test_tailcaller_0(instance);

+}

+

+/* export for tail-call of 'tailcaller' */

+void wasm_tailcall_w2c_test_tailcaller(void **instance_ptr, void *tail_call_stack, wasm_rt_tailcallee_t *next) {

+ wasm_tailcall_w2c_test_tailcaller_0(instance_ptr, tail_call_stack, next);

+}

+

+/* handler for missing tail-call on import: 'spectest' 'print_i32_f32' */

+WEAK_FUNC_DECL(wasm_tailcall_w2c_spectest_print_i32_f32, wasm_fallback_test_w2c_spectest_print_i32_f32)

+{

+ next->fn = NULL;

+ struct wasm_multi_if params;

+ wasm_rt_memcpy(params, tail_call_stack, sizeof(params);

+ w2c_spectest_print_i32_f32(*instance_ptr, params.i0, params.f1);

+}

+

+static void init_instance_import(w2c_test* instance, struct w2c_spectest* w2c_spectest_instance) {

+ instance->w2c_spectest_instance = w2c_spectest_instance;

+}

+

+void wasm2c_test_instantiate(w2c_test* instance, struct w2c_spectest* w2c_spectest_instance) {

+ assert(wasm_rt_is_initialized());

+ init_instance_import(instance, w2c_spectest_instance);

+ init_tables(instance);

+ init_elem_instances(instance);

+}

+

+void wasm2c_test_free(w2c_test* instance) {

+ wasm_rt_free_funcref_table(&instance->w2c_tab);

+}

+

+wasm_rt_func_type_t wasm2c_test_get_func_type(uint32_t param_count, uint32_t result_count, ...) {

+ va_list args;

+

+ if (param_count == 2 && result_count == 0) {

+ va_start(args, result_count);

+ if (true && va_arg(args, wasm_rt_type_t) == WASM_RT_I32 && va_arg(args, wasm_rt_type_t) == WASM_RT_F32) {

+ va_end(args);

+ return w2c_test_i32_f32;

+ }

+ va_end(args);

+ }

+

+ if (param_count == 0 && result_count == 0) {

+ va_start(args, result_count);

+ if (true) {

+ va_end(args);

+ return w2c_test_t1;

+ }

+ va_end(args);

+ }

+

+ if (param_count == 2 && result_count == 2) {

+ va_start(args, result_count);

+ if (true && va_arg(args, wasm_rt_type_t) == WASM_RT_I32 && va_arg(args, wasm_rt_type_t) == WASM_RT_F64 && va_arg(args, wasm_rt_type_t) == WASM_RT_I32 && va_arg(args, wasm_rt_type_t) == WASM_RT_F64) {

+ va_end(args);

+ return w2c_test_t2;

+ }

+ va_end(args);

+ }

+

+ return NULL;

+}

+

+void w2c_test_tailcaller_0(w2c_test* instance) {

+ FUNC_PROLOGUE;

+ u32 var_i0, var_i2;

+ f32 var_f1;

+ var_i0 = 1u;

+ var_f1 = 2;

+ var_i2 = 0u;

+ static_assert(sizeof(struct wasm_multi_if) <= 1024);

+ CHECK_CALL_INDIRECT(instance->w2c_tab, w2c_test_i32_f32, var_i2);

+ if (!instance->w2c_tab.data[var_i2].func_tailcallee.fn) {

+ CALL_INDIRECT(instance->w2c_tab, void (*)(void*, u32, f32), w2c_test_i32_f32, var_i2, instance->w2c_tab.data[var_i2].module_instance, var_i0, var_f1);

+ } else {

+ void *instance_ptr_storage;

+ void **instance_ptr = &instance_ptr_storage;

+ char tail_call_stack[1024];

+ wasm_rt_tailcallee_t next_storage;

+ wasm_rt_tailcallee_t *next = &next_storage;

+ {

+ struct wasm_multi_if tmp;

+ tmp.i0 = var_i0;

+ tmp.f1 = var_f1;

+ wasm_rt_memcpy(tail_call_stack, &tmp, sizeof(tmp));

+ }

+ next->fn = instance->w2c_tab.data[var_i2].func_tailcallee.fn;

+ *instance_ptr = instance->w2c_tab.data[var_i2].module_instance;

+ while (next->fn) { next->fn(instance_ptr, tail_call_stack, next); }

+ }

+ goto var_Bfunc;

+ var_Bfunc:;

+ FUNC_EPILOGUE;

+}

+

+void wasm_tailcall_w2c_test_tailcaller_0(void **instance_ptr, void *tail_call_stack, wasm_rt_tailcallee_t *next) {

+ w2c_test* instance = *instance_ptr;

+ u32 var_i0, var_i2;

+ f32 var_f1;

+ var_i0 = 1u;

+ var_f1 = 2;

+ var_i2 = 0u;

+ static_assert(sizeof(struct wasm_multi_if) <= 1024);

+ CHECK_CALL_INDIRECT(instance->w2c_tab, w2c_test_i32_f32, var_i2);

+ if (!instance->w2c_tab.data[var_i2].func_tailcallee.fn) {

+ CALL_INDIRECT(instance->w2c_tab, void (*)(void*, u32, f32), w2c_test_i32_f32, var_i2, instance->w2c_tab.data[var_i2].module_instance, var_i0, var_f1);

+ next->fn = NULL;

+ } else {

+ {

+ struct wasm_multi_if tmp;

+ tmp.i0 = var_i0;

+ tmp.f1 = var_f1;

+ wasm_rt_memcpy(tail_call_stack, &tmp, sizeof(tmp));

+ }

+ next->fn = instance->w2c_tab.data[var_i2].func_tailcallee.fn;

+ *instance_ptr = instance->w2c_tab.data[var_i2].module_instance;

+ }

+ return;

+ var_Bfunc:;

+ next->fn = NULL;

+}

+

+struct wasm_multi_id w2c_test_infiniteloop(w2c_test* instance, u32 var_p0, f64 var_p1) {

+ FUNC_PROLOGUE;

+ u32 var_i0;

+ f64 var_d1;

+ var_i0 = var_p0;

+ var_d1 = var_p1;

+ static_assert(sizeof(struct wasm_multi_id) <= 1024);

+ {

+ void *instance_ptr_storage;

+ void **instance_ptr = &instance_ptr_storage;

+ char tail_call_stack[1024];

+ wasm_rt_tailcallee_t next_storage;

+ wasm_rt_tailcallee_t *next = &next_storage;

+ {

+ struct wasm_multi_id tmp;

+ tmp.i0 = var_i0;

+ tmp.d1 = var_d1;

+ wasm_rt_memcpy(tail_call_stack, &tmp, sizeof(tmp));

+ }

+ next->fn = wasm_tailcall_w2c_test_infiniteloop;

+ while (next->fn) { next->fn(instance_ptr, tail_call_stack, next); }

+ {

+ struct wasm_multi_id tmp;

+ wasm_rt_memcpy(&tmp, tail_call_stack, sizeof(tmp));

+ var_i0 = tmp.i0;

+ var_d1 = tmp.d1;

+ }

+ }

+ goto var_Bfunc;

+ var_Bfunc:;

+ FUNC_EPILOGUE;

+ {

+ struct wasm_multi_id tmp;

+ tmp.i0 = var_i0;

+ tmp.d1 = var_d1;

+ return tmp;

+ }

+}

+

+void wasm_tailcall_w2c_test_infiniteloop(void **instance_ptr, void *tail_call_stack, wasm_rt_tailcallee_t *next) {

+ static_assert(sizeof(struct wasm_multi_id) <= 1024);

+ w2c_test* instance = *instance_ptr;

+ u32 var_p0;

+ f64 var_p1;

+ {

+ struct wasm_multi_id tmp;

+ wasm_rt_memcpy(&tmp, tail_call_stack, sizeof(tmp));

+ var_p0 = tmp.i0;

+ var_p1 = tmp.d1;

+ }

+ u32 var_i0;

+ f64 var_d1;

+ var_i0 = var_p0;

+ var_d1 = var_p1;

+ static_assert(sizeof(struct wasm_multi_id) <= 1024);

+ {

+ {

+ struct wasm_multi_id tmp;

+ tmp.i0 = var_i0;

+ tmp.d1 = var_d1;

+ wasm_rt_memcpy(tail_call_stack, &tmp, sizeof(tmp));

+ }

+ next->fn = wasm_tailcall_w2c_test_infiniteloop;

+ }

+ return;

+ var_Bfunc:;

+ {

+ struct wasm_multi_id tmp;

+ tmp.i0 = var_i0;

+ tmp.d1 = var_d1;

+ wasm_rt_memcpy(tail_call_stack, &tmp, sizeof(tmp));

+ }

+ next->fn = NULL;

+}

+;;; STDOUT ;;)