From bf08dc3e2bbc27f44269b1cf9e1aa2b2e66e565a Mon Sep 17 00:00:00 2001 From: Maxime Vorwerk Date: Tue, 18 Jun 2024 20:07:38 +0200 Subject: [PATCH] Some Assembly Required 2 --- some_assembly_required_2/Y8splx37qY.c | 1145 ++++++++++++++++++++++ some_assembly_required_2/Y8splx37qY.dcmp | 102 ++ some_assembly_required_2/Y8splx37qY.h | 84 ++ some_assembly_required_2/Y8splx37qY.js | 44 + some_assembly_required_2/Y8splx37qY.wasm | Bin 0 -> 843 bytes some_assembly_required_2/Y8splx37qY.wat | 281 ++++++ 6 files changed, 1656 insertions(+) create mode 100644 some_assembly_required_2/Y8splx37qY.c create mode 100644 some_assembly_required_2/Y8splx37qY.dcmp create mode 100644 some_assembly_required_2/Y8splx37qY.h create mode 100644 some_assembly_required_2/Y8splx37qY.js create mode 100644 some_assembly_required_2/Y8splx37qY.wasm create mode 100644 some_assembly_required_2/Y8splx37qY.wat diff --git a/some_assembly_required_2/Y8splx37qY.c b/some_assembly_required_2/Y8splx37qY.c new file mode 100644 index 0000000..8d7bfb8 --- /dev/null +++ b/some_assembly_required_2/Y8splx37qY.c @@ -0,0 +1,1145 @@ +/* Automatically generated by wasm2c */ +#ifndef WASM_H_GENERATED_ +#define WASM_H_GENERATED_ + +#include "wasm-rt.h" + +#include + +#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 + +typedef struct w2c_ { + u32 w2c_g0; + u32 w2c_input; + u32 w2c_0x5F_dso_handle; + u32 w2c_0x5F_data_end; + u32 w2c_0x5F_global_base; + u32 w2c_0x5F_heap_base; + u32 w2c_0x5F_memory_base; + u32 w2c_0x5F_table_base; + wasm_rt_memory_t w2c_memory; + wasm_rt_funcref_table_t w2c_T0; +} w2c_; + +void wasm2c__instantiate(w2c_*); +void wasm2c__free(w2c_*); +wasm_rt_func_type_t wasm2c__get_func_type(uint32_t param_count, uint32_t result_count, ...); + +/* export: 'memory' */ +wasm_rt_memory_t* w2c__memory(w2c_* instance); + +/* export: '__wasm_call_ctors' */ +void w2c__0x5F_wasm_call_ctors(w2c_*); + +/* export: 'strcmp' */ +u32 w2c__strcmp(w2c_*, u32, u32); + +/* export: 'check_flag' */ +u32 w2c__check_flag(w2c_*); + +/* export: 'input' */ +u32* w2c__input(w2c_* instance); + +/* export: 'copy_char' */ +void w2c__copy_char(w2c_*, u32, u32); + +/* export: '__dso_handle' */ +u32* w2c__0x5F_dso_handle(w2c_* instance); + +/* export: '__data_end' */ +u32* w2c__0x5F_data_end(w2c_* instance); + +/* export: '__global_base' */ +u32* w2c__0x5F_global_base(w2c_* instance); + +/* export: '__heap_base' */ +u32* w2c__0x5F_heap_base(w2c_* instance); + +/* export: '__memory_base' */ +u32* w2c__0x5F_memory_base(w2c_* instance); + +/* export: '__table_base' */ +u32* w2c__0x5F_table_base(w2c_* instance); + +#ifdef __cplusplus +} +#endif + +#endif /* WASM_H_GENERATED_ */ +/* Automatically generated by wasm2c */ +#include +#include +#include +#include +#include +#if defined(__MINGW32__) +#include +#elif defined(_MSC_VER) +#include +#include +#define alloca _alloca +#elif defined(__FreeBSD__) || defined(__OpenBSD__) +#include +#else +#include +#endif + +#include "wasm.h" + +// Computes a pointer to an object of the given size in a little-endian memory. +// +// On a little-endian host, this is just &mem->data[addr] - the object's size is +// unused. On a big-endian host, it's &mem->data[mem->size - addr - n], where n +// is the object's size. +// +// Note that mem may be evaluated multiple times. +// +// Parameters: +// mem - The memory. +// addr - The address. +// n - The size of the object. +// +// Result: +// A pointer for an object of size n. +#if WABT_BIG_ENDIAN +#define MEM_ADDR(mem, addr, n) &(mem)->data[(mem)->size - (addr) - (n)] +#else +#define MEM_ADDR(mem, addr, n) &(mem)->data[addr] +#endif + +#define TRAP(x) (wasm_rt_trap(WASM_RT_TRAP_##x), 0) + +#if WASM_RT_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 + +static inline void load_data(void* dest, const void* src, size_t n) { + if (!n) { + return; + } + wasm_rt_memcpy(dest, src, n); +#if WABT_BIG_ENDIAN + u8* dest_chars = dest; + for (size_t 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; + } +#endif +} + +#define LOAD_DATA(m, o, i, s) \ + do { \ + RANGE_CHECK((&m), o, s); \ + load_data(MEM_ADDR(&m, 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_ADDR(mem, 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_ADDR(mem, addr, sizeof(t1)), &wrapped, sizeof(t1)); \ + } + +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_ADDR(mem, d, n), 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(MEM_ADDR(dest, dest_addr, n), MEM_ADDR(src, src_addr, n), 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__0x5F_wasm_call_ctors_0(w2c_*); +static u32 w2c__strcmp_0(w2c_*, u32, u32); +static u32 w2c__check_flag_0(w2c_*); +static void w2c__copy_char_0(w2c_*, u32, u32); + +FUNC_TYPE_T(w2c__t0) = "\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__t1) = "\x92\xfb\x6a\xdf\x49\x07\x0a\x83\xbe\x08\x02\x68\xcd\xf6\x95\x27\x4a\xc2\xf3\xe5\xe4\x7d\x29\x49\xe8\xed\x42\x92\x6a\x9d\xda\xf0"; +FUNC_TYPE_T(w2c__t2) = "\x72\xab\x00\xdf\x20\x3d\xce\xa1\xf2\x29\xc7\x9d\x13\x40\x7e\x98\xac\x7d\x41\x4a\x53\x2e\x42\x42\x61\x55\x2e\xaa\xeb\xbe\xc6\x35"; +FUNC_TYPE_T(w2c__t3) = "\x26\x10\x81\xe2\x21\x43\xd6\x01\x3e\x2d\x2f\x16\x17\x78\x6f\xba\xb3\x2f\x4d\x54\x9b\x8a\xa9\xdd\xbf\x53\x92\x3c\xd3\x71\xc6\xb2"; + +static void init_globals(w2c_* instance) { + instance->w2c_g0 = 66864u; + instance->w2c_input = 1072u; + instance->w2c_0x5F_dso_handle = 1024u; + instance->w2c_0x5F_data_end = 1328u; + instance->w2c_0x5F_global_base = 1024u; + instance->w2c_0x5F_heap_base = 66864u; + instance->w2c_0x5F_memory_base = 0u; + instance->w2c_0x5F_table_base = 1u; +} + +static const u8 data_segment_data_w2c__d0[] = { + 0x78, 0x61, 0x6b, 0x67, 0x4b, 0x5c, 0x4e, 0x73, 0x39, 0x3d, 0x38, 0x3a, + 0x39, 0x6c, 0x31, 0x3f, 0x69, 0x6d, 0x38, 0x69, 0x3c, 0x38, 0x39, 0x3f, + 0x30, 0x30, 0x3e, 0x38, 0x38, 0x6b, 0x30, 0x39, 0x3d, 0x6e, 0x6a, 0x39, + 0x6b, 0x69, 0x6d, 0x6e, 0x75, 0x00, 0x00, +}; + +static void init_memories(w2c_* instance) { + wasm_rt_allocate_memory(&instance->w2c_memory, 2, 65536, 0); + LOAD_DATA(instance->w2c_memory, 1024u, data_segment_data_w2c__d0, 43); +} + +static void init_data_instances(w2c_ *instance) { +} + +static void init_tables(w2c_* instance) { + wasm_rt_allocate_funcref_table(&instance->w2c_T0, 1, 1); +} + +/* export: 'memory' */ +wasm_rt_memory_t* w2c__memory(w2c_* instance) { + return &instance->w2c_memory; +} + +/* export: '__wasm_call_ctors' */ +void w2c__0x5F_wasm_call_ctors(w2c_* instance) { + w2c__0x5F_wasm_call_ctors_0(instance); +} + +/* export: 'strcmp' */ +u32 w2c__strcmp(w2c_* instance, u32 var_p0, u32 var_p1) { + return w2c__strcmp_0(instance, var_p0, var_p1); +} + +/* export: 'check_flag' */ +u32 w2c__check_flag(w2c_* instance) { + return w2c__check_flag_0(instance); +} + +/* export: 'input' */ +u32* w2c__input(w2c_* instance) { + return &instance->w2c_input; +} + +/* export: 'copy_char' */ +void w2c__copy_char(w2c_* instance, u32 var_p0, u32 var_p1) { + w2c__copy_char_0(instance, var_p0, var_p1); +} + +/* export: '__dso_handle' */ +u32* w2c__0x5F_dso_handle(w2c_* instance) { + return &instance->w2c_0x5F_dso_handle; +} + +/* export: '__data_end' */ +u32* w2c__0x5F_data_end(w2c_* instance) { + return &instance->w2c_0x5F_data_end; +} + +/* export: '__global_base' */ +u32* w2c__0x5F_global_base(w2c_* instance) { + return &instance->w2c_0x5F_global_base; +} + +/* export: '__heap_base' */ +u32* w2c__0x5F_heap_base(w2c_* instance) { + return &instance->w2c_0x5F_heap_base; +} + +/* export: '__memory_base' */ +u32* w2c__0x5F_memory_base(w2c_* instance) { + return &instance->w2c_0x5F_memory_base; +} + +/* export: '__table_base' */ +u32* w2c__0x5F_table_base(w2c_* instance) { + return &instance->w2c_0x5F_table_base; +} + +void wasm2c__instantiate(w2c_* instance) { + assert(wasm_rt_is_initialized()); + init_globals(instance); + init_tables(instance); + init_memories(instance); + init_data_instances(instance); +} + +void wasm2c__free(w2c_* instance) { + wasm_rt_free_funcref_table(&instance->w2c_T0); + wasm_rt_free_memory(&instance->w2c_memory); +} + +wasm_rt_func_type_t wasm2c__get_func_type(uint32_t param_count, uint32_t result_count, ...) { + va_list args; + + if (param_count == 0 && result_count == 0) { + va_start(args, result_count); + if (true) { + va_end(args); + return w2c__t0; + } + va_end(args); + } + + if (param_count == 2 && result_count == 1) { + 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_I32 && va_arg(args, wasm_rt_type_t) == WASM_RT_I32) { + va_end(args); + return w2c__t1; + } + va_end(args); + } + + if (param_count == 0 && result_count == 1) { + va_start(args, result_count); + if (true && va_arg(args, wasm_rt_type_t) == WASM_RT_I32) { + va_end(args); + return w2c__t2; + } + va_end(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_I32) { + va_end(args); + return w2c__t3; + } + va_end(args); + } + + return NULL; +} + +void w2c__0x5F_wasm_call_ctors_0(w2c_* instance) { + FUNC_PROLOGUE; + FUNC_EPILOGUE; +} + +u32 w2c__strcmp_0(w2c_* instance, u32 var_p0, u32 var_p1) { + u32 var_l2 = 0, var_l3 = 0, var_l4 = 0, var_l5 = 0, var_l6 = 0, var_l7 = 0, var_l8 = 0, var_l9 = 0, + var_l10 = 0, var_l11 = 0, var_l12 = 0, var_l13 = 0, var_l14 = 0, var_l15 = 0, var_l16 = 0, var_l17 = 0, + var_l18 = 0, var_l19 = 0, var_l20 = 0, var_l21 = 0, var_l22 = 0, var_l23 = 0, var_l24 = 0, var_l25 = 0, + var_l26 = 0, var_l27 = 0, var_l28 = 0, var_l29 = 0, var_l30 = 0, var_l31 = 0, var_l32 = 0, var_l33 = 0, + var_l34 = 0, var_l35 = 0, var_l36 = 0, var_l37 = 0, var_l38 = 0, var_l39 = 0, var_l40 = 0, var_l41 = 0, + var_l42 = 0, var_l43 = 0; + FUNC_PROLOGUE; + u32 var_i0, var_i1; + var_i0 = instance->w2c_g0; + var_l2 = var_i0; + var_i0 = 32u; + var_l3 = var_i0; + var_i0 = var_l2; + var_i1 = var_l3; + var_i0 -= var_i1; + var_l4 = var_i0; + var_i0 = var_l4; + var_i1 = var_p0; + i32_store(&instance->w2c_memory, (u64)(var_i0) + 24, var_i1); + var_i0 = var_l4; + var_i1 = var_p1; + i32_store(&instance->w2c_memory, (u64)(var_i0) + 20, var_i1); + var_i0 = var_l4; + var_i0 = i32_load(&instance->w2c_memory, (u64)(var_i0) + 24u); + var_l5 = var_i0; + var_i0 = var_l4; + var_i1 = var_l5; + i32_store(&instance->w2c_memory, (u64)(var_i0) + 16, var_i1); + var_i0 = var_l4; + var_i0 = i32_load(&instance->w2c_memory, (u64)(var_i0) + 20u); + var_l6 = var_i0; + var_i0 = var_l4; + var_i1 = var_l6; + i32_store(&instance->w2c_memory, (u64)(var_i0) + 12, var_i1); + var_L1: + var_i0 = var_l4; + var_i0 = i32_load(&instance->w2c_memory, (u64)(var_i0) + 16u); + var_l7 = var_i0; + var_i0 = 1u; + var_l8 = var_i0; + var_i0 = var_l7; + var_i1 = var_l8; + var_i0 += var_i1; + var_l9 = var_i0; + var_i0 = var_l4; + var_i1 = var_l9; + i32_store(&instance->w2c_memory, (u64)(var_i0) + 16, var_i1); + var_i0 = var_l7; + var_i0 = i32_load8_u(&instance->w2c_memory, (u64)(var_i0)); + var_l10 = var_i0; + var_i0 = var_l4; + var_i1 = var_l10; + i32_store8(&instance->w2c_memory, (u64)(var_i0) + 11, var_i1); + var_i0 = var_l4; + var_i0 = i32_load(&instance->w2c_memory, (u64)(var_i0) + 12u); + var_l11 = var_i0; + var_i0 = 1u; + var_l12 = var_i0; + var_i0 = var_l11; + var_i1 = var_l12; + var_i0 += var_i1; + var_l13 = var_i0; + var_i0 = var_l4; + var_i1 = var_l13; + i32_store(&instance->w2c_memory, (u64)(var_i0) + 12, var_i1); + var_i0 = var_l11; + var_i0 = i32_load8_u(&instance->w2c_memory, (u64)(var_i0)); + var_l14 = var_i0; + var_i0 = var_l4; + var_i1 = var_l14; + i32_store8(&instance->w2c_memory, (u64)(var_i0) + 10, var_i1); + var_i0 = var_l4; + var_i0 = i32_load8_u(&instance->w2c_memory, (u64)(var_i0) + 11u); + var_l15 = var_i0; + var_i0 = 255u; + var_l16 = var_i0; + var_i0 = var_l15; + var_i1 = var_l16; + var_i0 &= var_i1; + var_l17 = var_i0; + var_i0 = var_l17; + if (var_i0) {goto var_B2;} + var_i0 = var_l4; + var_i0 = i32_load8_u(&instance->w2c_memory, (u64)(var_i0) + 11u); + var_l18 = var_i0; + var_i0 = 255u; + var_l19 = var_i0; + var_i0 = var_l18; + var_i1 = var_l19; + var_i0 &= var_i1; + var_l20 = var_i0; + var_i0 = var_l4; + var_i0 = i32_load8_u(&instance->w2c_memory, (u64)(var_i0) + 10u); + var_l21 = var_i0; + var_i0 = 255u; + var_l22 = var_i0; + var_i0 = var_l21; + var_i1 = var_l22; + var_i0 &= var_i1; + var_l23 = var_i0; + var_i0 = var_l20; + var_i1 = var_l23; + var_i0 -= var_i1; + var_l24 = var_i0; + var_i0 = var_l4; + var_i1 = var_l24; + i32_store(&instance->w2c_memory, (u64)(var_i0) + 28, var_i1); + goto var_B0; + var_B2:; + var_i0 = var_l4; + var_i0 = i32_load8_u(&instance->w2c_memory, (u64)(var_i0) + 11u); + var_l25 = var_i0; + var_i0 = 255u; + var_l26 = var_i0; + var_i0 = var_l25; + var_i1 = var_l26; + var_i0 &= var_i1; + var_l27 = var_i0; + var_i0 = var_l4; + var_i0 = i32_load8_u(&instance->w2c_memory, (u64)(var_i0) + 10u); + var_l28 = var_i0; + var_i0 = 255u; + var_l29 = var_i0; + var_i0 = var_l28; + var_i1 = var_l29; + var_i0 &= var_i1; + var_l30 = var_i0; + var_i0 = var_l27; + var_l31 = var_i0; + var_i0 = var_l30; + var_l32 = var_i0; + var_i0 = var_l31; + var_i1 = var_l32; + var_i0 = var_i0 == var_i1; + var_l33 = var_i0; + var_i0 = 1u; + var_l34 = var_i0; + var_i0 = var_l33; + var_i1 = var_l34; + var_i0 &= var_i1; + var_l35 = var_i0; + var_i0 = var_l35; + if (var_i0) {goto var_L1;} + var_i0 = var_l4; + var_i0 = i32_load8_u(&instance->w2c_memory, (u64)(var_i0) + 11u); + var_l36 = var_i0; + var_i0 = 255u; + var_l37 = var_i0; + var_i0 = var_l36; + var_i1 = var_l37; + var_i0 &= var_i1; + var_l38 = var_i0; + var_i0 = var_l4; + var_i0 = i32_load8_u(&instance->w2c_memory, (u64)(var_i0) + 10u); + var_l39 = var_i0; + var_i0 = 255u; + var_l40 = var_i0; + var_i0 = var_l39; + var_i1 = var_l40; + var_i0 &= var_i1; + var_l41 = var_i0; + var_i0 = var_l38; + var_i1 = var_l41; + var_i0 -= var_i1; + var_l42 = var_i0; + var_i0 = var_l4; + var_i1 = var_l42; + i32_store(&instance->w2c_memory, (u64)(var_i0) + 28, var_i1); + var_B0:; + var_i0 = var_l4; + var_i0 = i32_load(&instance->w2c_memory, (u64)(var_i0) + 28u); + var_l43 = var_i0; + var_i0 = var_l43; + goto var_Bfunc; + var_Bfunc:; + FUNC_EPILOGUE; + return var_i0; +} + +u32 w2c__check_flag_0(w2c_* instance) { + u32 var_l0 = 0, var_l1 = 0, var_l2 = 0, var_l3 = 0, var_l4 = 0, var_l5 = 0, var_l6 = 0, var_l7 = 0, + var_l8 = 0, var_l9 = 0, var_l10 = 0; + FUNC_PROLOGUE; + u32 var_i0, var_i1; + var_l1 = 1072u; + var_l2 = 1024u; + var_l4 = w2c__strcmp_0(instance, var_l2, var_l1); + var_l6 = var_l4 != 0u; + var_l7 = 4294967295u; + var_i0 = var_l6; + var_l8 ^= var_i7; + var_i0 = var_l8; + var_l10 &= 1u; + FUNC_EPILOGUE; + return var_l10; +} + +void w2c__copy_char_0(w2c_* instance, u32 var_p0, u32 var_p1) { + u32 var_l2 = 0, var_l3 = 0, var_l4 = 0, var_l5 = 0, var_l6 = 0, var_l7 = 0, var_l8 = 0, var_l9 = 0, + var_l10 = 0; + FUNC_PROLOGUE; + u32 var_i0, var_i1; + var_i0 = instance->w2c_g0; + var_l2 = var_i0; + var_i0 = 16u; + var_l3 = var_i0; + var_i0 = var_l2; + var_i1 = var_l3; + var_i0 -= var_i1; + var_l4 = var_i0; + var_i0 = var_l4; + var_i1 = var_p0; + i32_store(&instance->w2c_memory, (u64)(var_i0) + 12, var_i1); + var_i0 = var_l4; + var_i1 = var_p1; + i32_store(&instance->w2c_memory, (u64)(var_i0) + 8, var_i1); + var_i0 = var_l4; + var_i0 = i32_load(&instance->w2c_memory, (u64)(var_i0) + 12u); + var_l5 = var_i0; + var_i0 = var_l5; + var_i0 = !(var_i0); + if (var_i0) {goto var_B0;} + var_i0 = var_l4; + var_i0 = i32_load(&instance->w2c_memory, (u64)(var_i0) + 12u); + var_l6 = var_i0; + var_i0 = 8u; + var_l7 = var_i0; + var_i0 = var_l6; + var_i1 = var_l7; + var_i0 ^= var_i1; + var_l8 = var_i0; + var_i0 = var_l4; + var_i1 = var_l8; + i32_store(&instance->w2c_memory, (u64)(var_i0) + 12, var_i1); + var_B0:; + var_i0 = var_l4; + var_i0 = i32_load(&instance->w2c_memory, (u64)(var_i0) + 12u); + var_l9 = var_i0; + var_i0 = var_l4; + var_i0 = i32_load(&instance->w2c_memory, (u64)(var_i0) + 8u); + var_l10 = var_i0; + var_i0 = var_l10; + var_i1 = var_l9; + i32_store8(&instance->w2c_memory, (u64)(var_i0) + 1072, var_i1); + goto var_Bfunc; + var_Bfunc:; + FUNC_EPILOGUE; +} diff --git a/some_assembly_required_2/Y8splx37qY.dcmp b/some_assembly_required_2/Y8splx37qY.dcmp new file mode 100644 index 0000000..b30c767 --- /dev/null +++ b/some_assembly_required_2/Y8splx37qY.dcmp @@ -0,0 +1,102 @@ +export memory memory(initial: 2, max: 0); + +global g_a:int = 66864; +export global input:int = 1072; +export global dso_handle:int = 1024; +export global data_end:int = 1328; +export global global_base:int = 1024; +export global heap_base:int = 66864; +export global memory_base:int = 0; +export global table_base:int = 1; + +table T_a:funcref(min: 1, max: 1); + +data d_xakgKNs989l1im8i890088k09nj9(offset: 1024) = +"xakgK\Ns9=8:9l1?im8i<89?00>88k09=nj9kimnu\00\00"; + +export function wasm_call_ctors() { +} + +export function strcmp(a:int, b:int):int { + var c:int = g_a; + var d:int = 32; + var e:int = c - d; + e[6]:int = a; + e[5]:int = b; + var f:int = e[6]:int; + e[4]:int = f; + var g:int = e[5]:int; + e[3]:int = g; + loop L_b { + var h:ubyte_ptr = e[4]:int; + var i:int = 1; + var j:int = h + i; + e[4]:int = j; + var k:int = h[0]; + e[11]:byte = k; + var l:ubyte_ptr = e[3]:int; + var m:int = 1; + var n:int = l + m; + e[3]:int = n; + var o:int = l[0]; + e[10]:byte = o; + var p:int = e[11]:ubyte; + var q:int = 255; + var r:int = p & q; + if (r) goto B_c; + var s:int = e[11]:ubyte; + var t:int = 255; + var u:int = s & t; + var v:int = e[10]:ubyte; + var w:int = 255; + var x:int = v & w; + var y:int = u - x; + e[7]:int = y; + goto B_a; + label B_c: + var z:int = e[11]:ubyte; + var aa:int = 255; + var ba:int = z & aa; + var ca:int = e[10]:ubyte; + var da:int = 255; + var ea:int = ca & da; + var fa:int = ba; + var ga:int = ea; + var ha:int = fa == ga; + var ia:int = 1; + var ja:int = ha & ia; + if (ja) continue L_b; + } + var ka:int = e[11]:ubyte; + var la:int = 255; + var ma:int = ka & la; + var na:int = e[10]:ubyte; + var oa:int = 255; + var pa:int = na & oa; + var qa:int = ma - pa; + e[7]:int = qa; + label B_a: + var ra:int = e[7]:int; + return ra; +} + +export function check_flag():int { + var b:int = 1072; + var c:int = 1024; + var d:int = strcmp(c, b); + var g:int = d != 0; + var i:int = g ^ -1; + var k:int = i & 1; + return k; +} + +function copy(a:int, b:int) { + var c:int = g_a; + var e:int_ptr = c - 16; + if (eqz(a)) + goto B_a; + a = a ^ 8; +label B_a: + b[1072] = a; +} + diff --git a/some_assembly_required_2/Y8splx37qY.h b/some_assembly_required_2/Y8splx37qY.h new file mode 100644 index 0000000..a00e9ac --- /dev/null +++ b/some_assembly_required_2/Y8splx37qY.h @@ -0,0 +1,84 @@ +/* Automatically generated by wasm2c */ +#ifndef Y8SPLX37QY_H_GENERATED_ +#define Y8SPLX37QY_H_GENERATED_ + +#include "wasm-rt.h" + +#include + +#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 + +typedef struct w2c_Y8splx37qY { + u32 w2c_g0; + u32 w2c_input; + u32 w2c_0x5F_dso_handle; + u32 w2c_0x5F_data_end; + u32 w2c_0x5F_global_base; + u32 w2c_0x5F_heap_base; + u32 w2c_0x5F_memory_base; + u32 w2c_0x5F_table_base; + wasm_rt_memory_t w2c_memory; + wasm_rt_funcref_table_t w2c_T0; +} w2c_Y8splx37qY; + +void wasm2c_Y8splx37qY_instantiate(w2c_Y8splx37qY*); +void wasm2c_Y8splx37qY_free(w2c_Y8splx37qY*); +wasm_rt_func_type_t wasm2c_Y8splx37qY_get_func_type(uint32_t param_count, uint32_t result_count, ...); + +/* export: 'memory' */ +wasm_rt_memory_t* w2c_Y8splx37qY_memory(w2c_Y8splx37qY* instance); + +/* export: '__wasm_call_ctors' */ +void w2c_Y8splx37qY_0x5F_wasm_call_ctors(w2c_Y8splx37qY*); + +/* export: 'strcmp' */ +u32 w2c_Y8splx37qY_strcmp(w2c_Y8splx37qY*, u32, u32); + +/* export: 'check_flag' */ +u32 w2c_Y8splx37qY_check_flag(w2c_Y8splx37qY*); + +/* export: 'input' */ +u32* w2c_Y8splx37qY_input(w2c_Y8splx37qY* instance); + +/* export: 'copy_char' */ +void w2c_Y8splx37qY_copy_char(w2c_Y8splx37qY*, u32, u32); + +/* export: '__dso_handle' */ +u32* w2c_Y8splx37qY_0x5F_dso_handle(w2c_Y8splx37qY* instance); + +/* export: '__data_end' */ +u32* w2c_Y8splx37qY_0x5F_data_end(w2c_Y8splx37qY* instance); + +/* export: '__global_base' */ +u32* w2c_Y8splx37qY_0x5F_global_base(w2c_Y8splx37qY* instance); + +/* export: '__heap_base' */ +u32* w2c_Y8splx37qY_0x5F_heap_base(w2c_Y8splx37qY* instance); + +/* export: '__memory_base' */ +u32* w2c_Y8splx37qY_0x5F_memory_base(w2c_Y8splx37qY* instance); + +/* export: '__table_base' */ +u32* w2c_Y8splx37qY_0x5F_table_base(w2c_Y8splx37qY* instance); + +#ifdef __cplusplus +} +#endif + +#endif /* Y8SPLX37QY_H_GENERATED_ */ diff --git a/some_assembly_required_2/Y8splx37qY.js b/some_assembly_required_2/Y8splx37qY.js new file mode 100644 index 0000000..ccfef9f --- /dev/null +++ b/some_assembly_required_2/Y8splx37qY.js @@ -0,0 +1,44 @@ +const name_list = ['copy_char', 'value', '207aLjBod', '1301420SaUSqf', '233ZRpipt', '2224QffgXU', 'check_flag', '408533hsoVYx', 'instance', '278338GVFUrH', 'Correct!', '549933ZVjkwI', 'innerHTML', 'charCodeAt', './aD8SvhyVkb', 'result', '977AzKzwq', 'Incorrect!', 'exports', 'length', 'getElementById', '1jIrMBu', 'input', '615361geljRK']; + +const name_selector = function(arg1, arg2) { + arg1 = arg1 - 195; + let selected_name = name_list[arg1]; + return selected_name; +}; + +(function(arg1, arg2) { + const _name_selector = name_selector; + while (!![]) { + try { + const some_int = -parseInt(_name_selector(0xc8)) * -parseInt(_name_selector(0xc9)) + -parseInt(_name_selector(0xcd)) + parseInt(_name_selector(0xcf)) + parseInt(_name_selector(195)) + -parseInt(_name_selector(0xc6)) * parseInt(_name_selector(0xd4)) + parseInt(_name_selector(0xcb)) + -parseInt(_name_selector(0xd9)) * parseInt(_name_selector(0xc7)); + if (some_int === arg2) + break; + else + arg1['push'](arg1['shift']()); + } catch (_0x4f8a) { + arg1['push'](arg1['shift']()); + } + } +}(name_list, 310022)); + +let exports; + +(async () => { + const _name_selector = name_selector; + let some_name = await fetch(_name_selector(210)), + wasm = await WebAssembly['instantiate'](await some_name['arrayBuffer']()), + wasm_symbol = wasm[_name_selector(204)]; + exports = wasm_symbol[_name_selector(214)]; +})(); + +function onButtonPress() { + const _name_selector = name_selector; + let some_doc_comp = document[_name_selector(0xd8)](_name_selector(0xda))[_name_selector(0xc5)]; + for (let i = 0; i < some_doc_comp['length']; i++) { + exports[_name_selector(196)](some_doc_comp[_name_selector(209)](i), i); + } + exports['copy_char'](0, some_doc_comp[_name_selector(0xd7)]), + exports[_name_selector(0xca)]() == 0x1 ? + document['getElementById'](_name_selector(0xd3))[_name_selector(0xd0)] = _name_selector(0xce): + document[_name_selector(0xd8)](_name_selector(0xd3))['innerHTML'] = _name_selector(0xd5); +} diff --git a/some_assembly_required_2/Y8splx37qY.wasm b/some_assembly_required_2/Y8splx37qY.wasm new file mode 100644 index 0000000000000000000000000000000000000000..f71de8acfaa81ccd65bc65635249d55fb97c0f65 GIT binary patch literal 843 zcmZ8f+iuf95S?9L;@D1;-fw9;(`(wQQp-b>M3mM@zyngh0BPfec_U-6DEo3Oo!tMfIXRx zJN*#|x6_R}vHF~Zk07nyVDvmSM6oj*y{Jw%9E0I2^)MN#Za8>IB15_i!)d6Z!GmFx zlzL2t_hF*$!%1YAo>JW?9OcO3Y~DhSZC09w_eqq)g8RcXC3wH2ILi)zWPoI#L?b2> zO@zAK;Gd|=6*OydgDgf?T~;(&A)Aq1m%h9;Zgr$Wg+P#l1$3UM$jPFn7A^qDW#qQN z(=?wvrupch|3oEDlvo2jOPKi6a z0GC#EXbo3!Ev0o_!S$GQ>l<}h^(B|pdYhWFg`2pQ(sq8VszWo?p01=XhTB z-U=@Zfb{br!LNrTJ1r`L9XHr+$ld)wc92m4Z7fX4;U0?UU@>I}-Llsf#e7Va|HkBV zJsy*j`)jdT);sN%cH0h|zj{n_*zI{+zMfG{I$9cwEtolF&wC~25BvOU7(agebT?^U iH(Jf)>ZaFk^j4v6qK_7 literal 0 HcmV?d00001 diff --git a/some_assembly_required_2/Y8splx37qY.wat b/some_assembly_required_2/Y8splx37qY.wat new file mode 100644 index 0000000..94088db --- /dev/null +++ b/some_assembly_required_2/Y8splx37qY.wat @@ -0,0 +1,281 @@ +(module + (table $table0 1 1 funcref) + (memory $memory0 2) + (global $global0 (mut i32) (i32.const 66864)) + (global $global1 i32 (i32.const 1072)) + (global $global2 i32 (i32.const 1024)) + (global $global3 i32 (i32.const 1328)) + (global $global4 i32 (i32.const 1024)) + (global $global5 i32 (i32.const 66864)) + (global $global6 i32 (i32.const 0)) + (global $global7 i32 (i32.const 1)) + (export "memory" (memory $memory0)) + (export "__wasm_call_ctors" (func $func0)) + (export "strcmp" (func $func1)) + (export "check_flag" (func $func2)) + (export "input" (global $global1)) + (export "copy_char" (func $func3)) + (export "__dso_handle" (global $global2)) + (export "__data_end" (global $global3)) + (export "__global_base" (global $global4)) + (export "__heap_base" (global $global5)) + (export "__memory_base" (global $global6)) + (export "__table_base" (global $global7)) + (func $func0 + ) + (func $func1 (param $var0 i32) (param $var1 i32) (result i32) + (local $var2 i32) (local $var3 i32) (local $var4 i32) (local $var5 i32) (local $var6 i32) (local $var7 i32) (local $var8 i32) (local $var9 i32) (local $var10 i32) (local $var11 i32) (local $var12 i32) (local $var13 i32) (local $var14 i32) (local $var15 i32) (local $var16 i32) (local $var17 i32) (local $var18 i32) (local $var19 i32) (local $var20 i32) (local $var21 i32) (local $var22 i32) (local $var23 i32) (local $var24 i32) (local $var25 i32) (local $var26 i32) (local $var27 i32) (local $var28 i32) (local $var29 i32) (local $var30 i32) (local $var31 i32) (local $var32 i32) (local $var33 i32) (local $var34 i32) (local $var35 i32) (local $var36 i32) (local $var37 i32) (local $var38 i32) (local $var39 i32) (local $var40 i32) (local $var41 i32) (local $var42 i32) (local $var43 i32) + global.get $global0 + local.set $var2 + i32.const 32 + local.set $var3 + local.get $var2 + local.get $var3 + i32.sub + local.set $var4 + local.get $var4 + local.get $var0 + i32.store offset=24 + local.get $var4 + local.get $var1 + i32.store offset=20 + local.get $var4 + i32.load offset=24 + local.set $var5 + local.get $var4 + local.get $var5 + i32.store offset=16 + local.get $var4 + i32.load offset=20 + local.set $var6 + local.get $var4 + local.get $var6 + i32.store offset=12 + block $label1 + loop $label2 + local.get $var4 + i32.load offset=16 + local.set $var7 + i32.const 1 + local.set $var8 + local.get $var7 + local.get $var8 + i32.add + local.set $var9 + local.get $var4 + local.get $var9 + i32.store offset=16 + local.get $var7 + i32.load8_u + local.set $var10 + local.get $var4 + local.get $var10 + i32.store8 offset=11 + local.get $var4 + i32.load offset=12 + local.set $var11 + i32.const 1 + local.set $var12 + local.get $var11 + local.get $var12 + i32.add + local.set $var13 + local.get $var4 + local.get $var13 + i32.store offset=12 + local.get $var11 + i32.load8_u + local.set $var14 + local.get $var4 + local.get $var14 + i32.store8 offset=10 + local.get $var4 + i32.load8_u offset=11 + local.set $var15 + i32.const 255 + local.set $var16 + local.get $var15 + local.get $var16 + i32.and + local.set $var17 + block $label0 + local.get $var17 + br_if $label0 + local.get $var4 + i32.load8_u offset=11 + local.set $var18 + i32.const 255 + local.set $var19 + local.get $var18 + local.get $var19 + i32.and + local.set $var20 + local.get $var4 + i32.load8_u offset=10 + local.set $var21 + i32.const 255 + local.set $var22 + local.get $var21 + local.get $var22 + i32.and + local.set $var23 + local.get $var20 + local.get $var23 + i32.sub + local.set $var24 + local.get $var4 + local.get $var24 + i32.store offset=28 + br $label1 + end $label0 + local.get $var4 + i32.load8_u offset=11 + local.set $var25 + i32.const 255 + local.set $var26 + local.get $var25 + local.get $var26 + i32.and + local.set $var27 + local.get $var4 + i32.load8_u offset=10 + local.set $var28 + i32.const 255 + local.set $var29 + local.get $var28 + local.get $var29 + i32.and + local.set $var30 + local.get $var27 + local.set $var31 + local.get $var30 + local.set $var32 + local.get $var31 + local.get $var32 + i32.eq + local.set $var33 + i32.const 1 + local.set $var34 + local.get $var33 + local.get $var34 + i32.and + local.set $var35 + local.get $var35 + br_if $label2 + end $label2 + local.get $var4 + i32.load8_u offset=11 + local.set $var36 + i32.const 255 + local.set $var37 + local.get $var36 + local.get $var37 + i32.and + local.set $var38 + local.get $var4 + i32.load8_u offset=10 + local.set $var39 + i32.const 255 + local.set $var40 + local.get $var39 + local.get $var40 + i32.and + local.set $var41 + local.get $var38 + local.get $var41 + i32.sub + local.set $var42 + local.get $var4 + local.get $var42 + i32.store offset=28 + end $label1 + local.get $var4 + i32.load offset=28 + local.set $var43 + local.get $var43 + return + ) + (func $func2 (result i32) + (local $var0 i32) (local $var1 i32) (local $var2 i32) (local $var3 i32) (local $var4 i32) (local $var5 i32) (local $var6 i32) (local $var7 i32) (local $var8 i32) (local $var9 i32) (local $var10 i32) + i32.const 0 + local.set $var0 + i32.const 1072 + local.set $var1 + i32.const 1024 + local.set $var2 + local.get $var2 + local.get $var1 + call $func1 + local.set $var3 + local.get $var3 + local.set $var4 + local.get $var0 + local.set $var5 + local.get $var4 + local.get $var5 + i32.ne + local.set $var6 + i32.const -1 + local.set $var7 + local.get $var6 + local.get $var7 + i32.xor + local.set $var8 + i32.const 1 + local.set $var9 + local.get $var8 + local.get $var9 + i32.and + local.set $var10 + local.get $var10 + return + ) + (func $func3 (param $var0 i32) (param $var1 i32) + (local $var2 i32) (local $var3 i32) (local $var4 i32) (local $var5 i32) (local $var6 i32) (local $var7 i32) (local $var8 i32) (local $var9 i32) (local $var10 i32) + global.get $global0 + local.set $var2 + i32.const 16 + local.set $var3 + local.get $var2 + local.get $var3 + i32.sub + local.set $var4 + local.get $var4 + local.get $var0 + i32.store offset=12 + local.get $var4 + local.get $var1 + i32.store offset=8 + local.get $var4 + i32.load offset=12 + local.set $var5 + block $label0 + local.get $var5 + i32.eqz + br_if $label0 + local.get $var4 + i32.load offset=12 + local.set $var6 + i32.const 8 + local.set $var7 + local.get $var6 + local.get $var7 + i32.xor + local.set $var8 + local.get $var4 + local.get $var8 + i32.store offset=12 + end $label0 + local.get $var4 + i32.load offset=12 + local.set $var9 + local.get $var4 + i32.load offset=8 + local.set $var10 + local.get $var10 + local.get $var9 + i32.store8 offset=1072 + return + ) + (data (i32.const 1024) "xakgK\5cNs9=8:9l1?im8i<89?00>88k09=nj9kimnu\00\00") +)