|
#include <math.h> |
|
#include <string.h> |
|
|
|
#include "chall.h" |
|
#define UNLIKELY(x) __builtin_expect(!!(x), 0) |
|
#define LIKELY(x) __builtin_expect(!!(x), 1) |
|
|
|
#define TRAP(x) (wasm_rt_trap(WASM_RT_TRAP_##x), 0) |
|
|
|
#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 |
|
|
|
#define UNREACHABLE TRAP(UNREACHABLE) |
|
|
|
#define CALL_INDIRECT(table, t, ft, x, ...) \ |
|
(LIKELY((x) < table.size && table.data[x].func && \ |
|
table.data[x].func_type == func_types[ft]) \ |
|
? ((t)table.data[x].func)(__VA_ARGS__) \ |
|
: TRAP(CALL_INDIRECT)) |
|
|
|
#define MEMCHECK(mem, a, t) \ |
|
if (UNLIKELY((a) + sizeof(t) > mem->size)) TRAP(OOB) |
|
|
|
#define DEFINE_LOAD(name, t1, t2, t3) \ |
|
static inline t3 name(wasm_rt_memory_t* mem, u64 addr) { \ |
|
MEMCHECK(mem, addr, t1); \ |
|
t1 result; \ |
|
memcpy(&result, &mem->data[addr], sizeof(t1)); \ |
|
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; \ |
|
memcpy(&mem->data[addr], &wrapped, sizeof(t1)); \ |
|
} |
|
|
|
DEFINE_LOAD(i32_load, u32, u32, u32); |
|
DEFINE_LOAD(i64_load, u64, u64, u64); |
|
DEFINE_LOAD(f32_load, f32, f32, f32); |
|
DEFINE_LOAD(f64_load, f64, f64, f64); |
|
DEFINE_LOAD(i32_load8_s, s8, s32, u32); |
|
DEFINE_LOAD(i64_load8_s, s8, s64, u64); |
|
DEFINE_LOAD(i32_load8_u, u8, u32, u32); |
|
DEFINE_LOAD(i64_load8_u, u8, u64, u64); |
|
DEFINE_LOAD(i32_load16_s, s16, s32, u32); |
|
DEFINE_LOAD(i64_load16_s, s16, s64, u64); |
|
DEFINE_LOAD(i32_load16_u, u16, u32, u32); |
|
DEFINE_LOAD(i64_load16_u, u16, u64, u64); |
|
DEFINE_LOAD(i64_load32_s, s32, s64, u64); |
|
DEFINE_LOAD(i64_load32_u, u32, u64, u64); |
|
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); |
|
|
|
#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)) |
|
|
|
#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, max, maxop, x) \ |
|
((UNLIKELY((x) != (x))) ? TRAP(INVALID_CONVERSION) \ |
|
: (UNLIKELY((x) < (ft)(min) || (x) maxop (ft)(max))) ? TRAP(INT_OVERFLOW) \ |
|
: (ut)(st)(x)) |
|
|
|
#define I32_TRUNC_S_F32(x) TRUNC_S(u32, s32, f32, INT32_MIN, INT32_MAX, >=, x) |
|
#define I64_TRUNC_S_F32(x) TRUNC_S(u64, s64, f32, INT64_MIN, INT64_MAX, >=, x) |
|
#define I32_TRUNC_S_F64(x) TRUNC_S(u32, s32, f64, INT32_MIN, INT32_MAX, >, x) |
|
#define I64_TRUNC_S_F64(x) TRUNC_S(u64, s64, f64, INT64_MIN, INT64_MAX, >=, x) |
|
|
|
#define TRUNC_U(ut, ft, max, maxop, x) \ |
|
((UNLIKELY((x) != (x))) ? TRAP(INVALID_CONVERSION) \ |
|
: (UNLIKELY((x) <= (ft)-1 || (x) maxop (ft)(max))) ? TRAP(INT_OVERFLOW) \ |
|
: (ut)(x)) |
|
|
|
#define I32_TRUNC_U_F32(x) TRUNC_U(u32, f32, UINT32_MAX, >=, x) |
|
#define I64_TRUNC_U_F32(x) TRUNC_U(u64, f32, UINT64_MAX, >=, x) |
|
#define I32_TRUNC_U_F64(x) TRUNC_U(u32, f64, UINT32_MAX, >, x) |
|
#define I64_TRUNC_U_F64(x) TRUNC_U(u64, f64, UINT64_MAX, >=, x) |
|
|
|
#define DEFINE_REINTERPRET(name, t1, t2) \ |
|
static inline t2 name(t1 x) { \ |
|
t2 result; \ |
|
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 u32 func_types[4]; |
|
|
|
static void init_func_types(void) { |
|
func_types[0] = wasm_rt_register_func_type(1, 1, WASM_RT_I32, WASM_RT_I32); |
|
func_types[1] = wasm_rt_register_func_type(0, 0); |
|
func_types[2] = wasm_rt_register_func_type(1, 0, WASM_RT_I32); |
|
func_types[3] = wasm_rt_register_func_type(0, 1, WASM_RT_I32); |
|
} |
|
|
|
static void _start(void); |
|
static void stackRestore(u32); |
|
static u32 stackAlloc(u32); |
|
static u32 stackSave(void); |
|
static u32 review(u32); |
|
static u32 f5(u32); |
|
|
|
static u32 g0; |
|
|
|
static void init_globals(void) { |
|
g0 = 5244176u; |
|
} |
|
|
|
static wasm_rt_memory_t memory; |
|
|
|
static void _start(void) { |
|
FUNC_PROLOGUE; |
|
FUNC_EPILOGUE; |
|
} |
|
|
|
static void stackRestore(u32 p0) { |
|
FUNC_PROLOGUE; |
|
u32 i0; |
|
i0 = p0; |
|
g0 = i0; |
|
FUNC_EPILOGUE; |
|
} |
|
|
|
static u32 stackAlloc(u32 p0) { |
|
FUNC_PROLOGUE; |
|
u32 i0, i1; |
|
i0 = g0; |
|
i1 = p0; |
|
i0 -= i1; |
|
i1 = 4294967280u; |
|
i0 &= i1; |
|
p0 = i0; |
|
g0 = i0; |
|
i0 = p0; |
|
FUNC_EPILOGUE; |
|
return i0; |
|
} |
|
|
|
static u32 stackSave(void) { |
|
FUNC_PROLOGUE; |
|
u32 i0; |
|
i0 = g0; |
|
FUNC_EPILOGUE; |
|
return i0; |
|
} |
|
|
|
static u32 review(u32 p0) { |
|
u32 l1 = 0; |
|
FUNC_PROLOGUE; |
|
u32 i0, i1, i2, i3; |
|
i0 = 1124u; |
|
i0 = i32_load((&memory), (u64)(i0)); |
|
l1 = i0; |
|
i0 = p0; |
|
i0 = i32_load8_s((&memory), (u64)(i0)); |
|
i0 = f5(i0); |
|
p0 = i0; |
|
i0 = l1; |
|
i1 = 3u; |
|
i0 = (u32)((s32)i0 <= (s32)i1); |
|
if (i0) { |
|
i0 = 1091u; |
|
i1 = l1; |
|
i2 = 1073u; |
|
i1 += i2; |
|
i1 = i32_load8_u((&memory), (u64)(i1)); |
|
i2 = p0; |
|
i3 = 255u; |
|
i2 &= i3; |
|
i1 = i1 == i2; |
|
if (i1) {goto B1;} |
|
goto B0; |
|
} |
|
i0 = p0; |
|
i1 = 4294967264u; |
|
i0 += i1; |
|
i1 = 255u; |
|
i0 &= i1; |
|
i1 = 94u; |
|
i0 = i0 > i1; |
|
if (i0) {goto B0;} |
|
i0 = 1091u; |
|
i1 = l1; |
|
i2 = 47u; |
|
i1 = i1 != i2; |
|
if (i1) {goto B1;} |
|
i0 = 1104u; |
|
i1 = 1078u; |
|
i2 = p0; |
|
i3 = 125u; |
|
i2 = i2 == i3; |
|
i0 = i2 ? i0 : i1; |
|
B1:; |
|
goto Bfunc; |
|
B0:; |
|
i0 = 1121u; |
|
i1 = 42u; |
|
i32_store8((&memory), (u64)(i0), i1); |
|
i0 = 1124u; |
|
i1 = 0u; |
|
i32_store((&memory), (u64)(i0), i1); |
|
i0 = 1078u; |
|
Bfunc:; |
|
FUNC_EPILOGUE; |
|
return i0; |
|
} |
|
|
|
static u32 f5(u32 p0) { |
|
u32 l1 = 0; |
|
FUNC_PROLOGUE; |
|
u32 i0, i1, i2, i3; |
|
i0 = 1124u; |
|
i1 = 1124u; |
|
i1 = i32_load((&memory), (u64)(i1)); |
|
i2 = 1u; |
|
i1 += i2; |
|
i2 = 49u; |
|
i1 = REM_U(i1, i2); |
|
l1 = i1; |
|
i32_store((&memory), (u64)(i0), i1); |
|
i0 = 1121u; |
|
i1 = 1121u; |
|
i1 = i32_load8_u((&memory), (u64)(i1)); |
|
i2 = l1; |
|
i3 = 1024u; |
|
i2 += i3; |
|
i2 = i32_load8_u((&memory), (u64)(i2)); |
|
i3 = p0; |
|
i2 ^= i3; |
|
i1 ^= i2; |
|
p0 = i1; |
|
i32_store8((&memory), (u64)(i0), i1); |
|
i0 = p0; |
|
i1 = 24u; |
|
i0 <<= (i1 & 31); |
|
i1 = 24u; |
|
i0 = (u32)((s32)i0 >> (i1 & 31)); |
|
FUNC_EPILOGUE; |
|
return i0; |
|
} |
|
|
|
static const u8 data_segment_data_0[] = { |
|
0x2a, 0x39, 0x67, 0x7e, 0x71, 0x2d, 0x21, 0x21, 0x72, 0x43, 0x41, 0x3a, |
|
0x09, 0x0c, 0x04, 0x05, 0x52, 0x42, 0x40, 0x19, 0x0a, 0x77, 0x51, 0x42, |
|
0x05, 0x23, 0x36, 0x5b, 0x0c, 0x67, 0x66, 0x22, 0x00, 0x4b, 0x27, 0x38, |
|
0x47, 0x72, 0x6e, 0x5b, 0x75, 0x2b, 0x2c, 0x32, 0x5e, 0x53, 0x47, 0x5a, |
|
0x22, 0x70, 0x74, 0x6d, 0x7b, 0x00, 0x77, 0x68, 0x61, 0x74, 0x27, 0x73, |
|
0x20, 0x74, 0x68, 0x69, 0x73, 0x3f, 0x00, 0x7a, 0x7a, 0x7a, 0x2e, 0x2e, |
|
0x2e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0x68, 0x78, 0x20, |
|
0x2e, 0x2e, 0x2e, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x2e, 0x2e, 0x2e, |
|
0x00, 0x2a, |
|
}; |
|
|
|
static const u8 data_segment_data_1[] = { |
|
0x10, 0x05, 0x50, |
|
}; |
|
|
|
static void init_memory(void) { |
|
wasm_rt_allocate_memory((&memory), 256, 256); |
|
memcpy(&(memory.data[1024u]), data_segment_data_0, 98); |
|
memcpy(&(memory.data[1136u]), data_segment_data_1, 3); |
|
} |
|
|
|
static void init_table(void) { |
|
uint32_t offset; |
|
} |
|
|
|
/* export: 'memory' */ |
|
wasm_rt_memory_t (*WASM_RT_ADD_PREFIX(Z_memory)); |
|
/* export: 'review' */ |
|
u32 (*WASM_RT_ADD_PREFIX(Z_reviewZ_ii))(u32); |
|
/* export: '_start' */ |
|
void (*WASM_RT_ADD_PREFIX(Z__startZ_vv))(void); |
|
/* export: 'stackSave' */ |
|
u32 (*WASM_RT_ADD_PREFIX(Z_stackSaveZ_iv))(void); |
|
/* export: 'stackAlloc' */ |
|
u32 (*WASM_RT_ADD_PREFIX(Z_stackAllocZ_ii))(u32); |
|
/* export: 'stackRestore' */ |
|
void (*WASM_RT_ADD_PREFIX(Z_stackRestoreZ_vi))(u32); |
|
|
|
static void init_exports(void) { |
|
/* export: 'memory' */ |
|
WASM_RT_ADD_PREFIX(Z_memory) = (&memory); |
|
/* export: 'review' */ |
|
WASM_RT_ADD_PREFIX(Z_reviewZ_ii) = (&review); |
|
/* export: '_start' */ |
|
WASM_RT_ADD_PREFIX(Z__startZ_vv) = (&_start); |
|
/* export: 'stackSave' */ |
|
WASM_RT_ADD_PREFIX(Z_stackSaveZ_iv) = (&stackSave); |
|
/* export: 'stackAlloc' */ |
|
WASM_RT_ADD_PREFIX(Z_stackAllocZ_ii) = (&stackAlloc); |
|
/* export: 'stackRestore' */ |
|
WASM_RT_ADD_PREFIX(Z_stackRestoreZ_vi) = (&stackRestore); |
|
} |
|
|
|
void WASM_RT_ADD_PREFIX(init)(void) { |
|
init_func_types(); |
|
init_globals(); |
|
init_memory(); |
|
init_table(); |
|
init_exports(); |
|
} |