From 52b6c73d9c2dee4973271a5cb1e2b9242a7a975b Mon Sep 17 00:00:00 2001 From: Wenyong Huang Date: Fri, 8 Oct 2021 17:47:11 +0800 Subject: [PATCH] Apply clang-format for more src files and update spec test script (#775) Apply clang-format for core/iwasm/include, core/iwasm/common and core/iwasm/aot files. Update spec cases test script: - Checkout latest commit of https://github.com/WebAssembly/spec - Checkout main branch but not master of https://github.com/WebAssembly/threads - Update wabt to latest version And update source debugging document. Signed-off-by: Wenyong Huang --- core/iwasm/aot/aot_intrinsic.c | 81 +- core/iwasm/aot/aot_intrinsic.h | 6 +- core/iwasm/aot/aot_loader.c | 753 +++++------ core/iwasm/aot/aot_reloc.h | 25 +- core/iwasm/aot/aot_runtime.c | 792 ++++++------ core/iwasm/aot/aot_runtime.h | 131 +- core/iwasm/aot/arch/aot_reloc_aarch64.c | 151 ++- core/iwasm/aot/arch/aot_reloc_arc.c | 86 +- core/iwasm/aot/arch/aot_reloc_arm.c | 84 +- core/iwasm/aot/arch/aot_reloc_mips.c | 16 +- core/iwasm/aot/arch/aot_reloc_riscv.c | 77 +- core/iwasm/aot/arch/aot_reloc_thumb.c | 63 +- core/iwasm/aot/arch/aot_reloc_x86_32.c | 48 +- core/iwasm/aot/arch/aot_reloc_x86_64.c | 119 +- core/iwasm/aot/arch/aot_reloc_xtensa.c | 56 +- core/iwasm/aot/debug/elf_parser.c | 14 +- core/iwasm/aot/debug/jit_debug.c | 14 +- core/iwasm/common/arch/invokeNative_general.c | 66 +- core/iwasm/common/wasm_application.c | 171 +-- core/iwasm/common/wasm_c_api.c | 1009 +++++++-------- core/iwasm/common/wasm_c_api_internal.h | 18 +- core/iwasm/common/wasm_exec_env.c | 23 +- core/iwasm/common/wasm_exec_env.h | 11 +- core/iwasm/common/wasm_memory.c | 20 +- core/iwasm/common/wasm_memory.h | 1 - core/iwasm/common/wasm_native.c | 93 +- core/iwasm/common/wasm_native.h | 3 +- core/iwasm/common/wasm_runtime_common.c | 1118 +++++++++-------- core/iwasm/common/wasm_runtime_common.h | 407 +++--- core/iwasm/common/wasm_shared_memory.c | 45 +- core/iwasm/common/wasm_shared_memory.h | 10 +- core/iwasm/include/aot_export.h | 22 +- core/iwasm/include/lib_export.h | 19 +- core/iwasm/include/wasm_c_api.h | 22 +- core/iwasm/include/wasm_export.h | 113 +- doc/source_debugging.md | 4 +- tests/wamr-test-suites/test_wamr.sh | 19 +- 37 files changed, 2835 insertions(+), 2875 deletions(-) diff --git a/core/iwasm/aot/aot_intrinsic.c b/core/iwasm/aot/aot_intrinsic.c index ce28d9d5..ba02dca0 100644 --- a/core/iwasm/aot/aot_intrinsic.c +++ b/core/iwasm/aot/aot_intrinsic.c @@ -11,43 +11,30 @@ typedef struct { uint64 flag; } aot_intrinsic; +/* clang-format off */ static const aot_intrinsic g_intrinsic_mapping[] = { - { "llvm.experimental.constrained.fadd.f32", "aot_intrinsic_fadd_f32", - AOT_INTRINSIC_FLAG_F32_FADD }, - { "llvm.experimental.constrained.fadd.f64", "aot_intrinsic_fadd_f64", - AOT_INTRINSIC_FLAG_F64_FADD }, - { "llvm.experimental.constrained.fsub.f32", "aot_intrinsic_fsub_f32", - AOT_INTRINSIC_FLAG_F32_FSUB }, - { "llvm.experimental.constrained.fsub.f64", "aot_intrinsic_fsub_f64", - AOT_INTRINSIC_FLAG_F64_FSUB }, - { "llvm.experimental.constrained.fmul.f32", "aot_intrinsic_fmul_f32", - AOT_INTRINSIC_FLAG_F32_FMUL }, - { "llvm.experimental.constrained.fmul.f64", "aot_intrinsic_fmul_f64", - AOT_INTRINSIC_FLAG_F64_FMUL }, - { "llvm.experimental.constrained.fdiv.f32", "aot_intrinsic_fdiv_f32", - AOT_INTRINSIC_FLAG_F32_FDIV }, - { "llvm.experimental.constrained.fdiv.f64", "aot_intrinsic_fdiv_f64", - AOT_INTRINSIC_FLAG_F64_FDIV }, + { "llvm.experimental.constrained.fadd.f32", "aot_intrinsic_fadd_f32", AOT_INTRINSIC_FLAG_F32_FADD }, + { "llvm.experimental.constrained.fadd.f64", "aot_intrinsic_fadd_f64", AOT_INTRINSIC_FLAG_F64_FADD }, + { "llvm.experimental.constrained.fsub.f32", "aot_intrinsic_fsub_f32", AOT_INTRINSIC_FLAG_F32_FSUB }, + { "llvm.experimental.constrained.fsub.f64", "aot_intrinsic_fsub_f64", AOT_INTRINSIC_FLAG_F64_FSUB }, + { "llvm.experimental.constrained.fmul.f32", "aot_intrinsic_fmul_f32", AOT_INTRINSIC_FLAG_F32_FMUL }, + { "llvm.experimental.constrained.fmul.f64", "aot_intrinsic_fmul_f64", AOT_INTRINSIC_FLAG_F64_FMUL }, + { "llvm.experimental.constrained.fdiv.f32", "aot_intrinsic_fdiv_f32", AOT_INTRINSIC_FLAG_F32_FDIV }, + { "llvm.experimental.constrained.fdiv.f64", "aot_intrinsic_fdiv_f64", AOT_INTRINSIC_FLAG_F64_FDIV }, { "llvm.fabs.f32", "aot_intrinsic_fabs_f32", AOT_INTRINSIC_FLAG_F32_FABS }, { "llvm.fabs.f64", "aot_intrinsic_fabs_f64", AOT_INTRINSIC_FLAG_F64_FABS }, { "llvm.ceil.f32", "aot_intrinsic_ceil_f32", AOT_INTRINSIC_FLAG_F32_CEIL }, { "llvm.ceil.f64", "aot_intrinsic_ceil_f64", AOT_INTRINSIC_FLAG_F64_CEIL }, - { "llvm.floor.f32", "aot_intrinsic_floor_f32", - AOT_INTRINSIC_FLAG_F32_FLOOR }, - { "llvm.floor.f64", "aot_intrinsic_floor_f64", - AOT_INTRINSIC_FLAG_F64_FLOOR }, - { "llvm.trunc.f32", "aot_intrinsic_trunc_f32", - AOT_INTRINSIC_FLAG_F32_TRUNC }, - { "llvm.trunc.f64", "aot_intrinsic_trunc_f64", - AOT_INTRINSIC_FLAG_F64_TRUNC }, + { "llvm.floor.f32", "aot_intrinsic_floor_f32", AOT_INTRINSIC_FLAG_F32_FLOOR }, + { "llvm.floor.f64", "aot_intrinsic_floor_f64", AOT_INTRINSIC_FLAG_F64_FLOOR }, + { "llvm.trunc.f32", "aot_intrinsic_trunc_f32", AOT_INTRINSIC_FLAG_F32_TRUNC }, + { "llvm.trunc.f64", "aot_intrinsic_trunc_f64", AOT_INTRINSIC_FLAG_F64_TRUNC }, { "llvm.rint.f32", "aot_intrinsic_rint_f32", AOT_INTRINSIC_FLAG_F32_RINT }, { "llvm.rint.f64", "aot_intrinsic_rint_f64", AOT_INTRINSIC_FLAG_F64_RINT }, { "llvm.sqrt.f32", "aot_intrinsic_sqrt_f32", AOT_INTRINSIC_FLAG_F32_SQRT }, { "llvm.sqrt.f64", "aot_intrinsic_sqrt_f64", AOT_INTRINSIC_FLAG_F64_SQRT }, - { "llvm.copysign.f32", "aot_intrinsic_copysign_f32", - AOT_INTRINSIC_FLAG_F32_COPYSIGN }, - { "llvm.copysign.f64", "aot_intrinsic_copysign_f64", - AOT_INTRINSIC_FLAG_F64_COPYSIGN }, + { "llvm.copysign.f32", "aot_intrinsic_copysign_f32", AOT_INTRINSIC_FLAG_F32_COPYSIGN }, + { "llvm.copysign.f64", "aot_intrinsic_copysign_f64", AOT_INTRINSIC_FLAG_F64_COPYSIGN }, { "llvm.minnum.f32", "aot_intrinsic_fmin_f32", AOT_INTRINSIC_FLAG_F32_MIN }, { "llvm.minnum.f64", "aot_intrinsic_fmin_f64", AOT_INTRINSIC_FLAG_F64_MIN }, { "llvm.maxnum.f32", "aot_intrinsic_fmax_f32", AOT_INTRINSIC_FLAG_F32_MAX }, @@ -58,23 +45,24 @@ static const aot_intrinsic g_intrinsic_mapping[] = { { "llvm.cttz.i64", "aot_intrinsic_ctz_i64", AOT_INTRINSIC_FLAG_I64_CTZ }, { "llvm.ctpop.i32", "aot_intrinsic_popcnt_i32", AOT_INTRINSIC_FLAG_I32_POPCNT }, { "llvm.ctpop.i64", "aot_intrinsic_popcnt_i64", AOT_INTRINSIC_FLAG_I64_POPCNT }, - { "f64_convert_i32_s", "aot_intrinsic_i32_to_f64", AOT_INTRINSIC_FLAG_I32_TO_F64}, - { "f64_convert_i32_u", "aot_intrinsic_u32_to_f64", AOT_INTRINSIC_FLAG_U32_TO_F64}, - { "f32_convert_i32_s", "aot_intrinsic_i32_to_f32", AOT_INTRINSIC_FLAG_I32_TO_F32}, - { "f32_convert_i32_u", "aot_intrinsic_u32_to_f32", AOT_INTRINSIC_FLAG_U32_TO_F32}, - { "f64_convert_i64_s", "aot_intrinsic_i64_to_f64", AOT_INTRINSIC_FLAG_I32_TO_F64}, - { "f64_convert_i64_u", "aot_intrinsic_u64_to_f64", AOT_INTRINSIC_FLAG_U64_TO_F64}, - { "f32_convert_i64_s", "aot_intrinsic_i64_to_f32", AOT_INTRINSIC_FLAG_I64_TO_F32}, - { "f32_convert_i64_u", "aot_intrinsic_u64_to_f32", AOT_INTRINSIC_FLAG_U64_TO_F32}, - { "i32_trunc_f64_u", "aot_intrinsic_f64_to_u32", AOT_INTRINSIC_FLAG_I32_TO_F64}, - { "f32_demote_f64", "aot_intrinsic_f64_to_f32", AOT_INTRINSIC_FLAG_F64_TO_F32}, - { "f64_promote_f32", "aot_intrinsic_f32_to_f64", AOT_INTRINSIC_FLAG_F32_TO_F64}, - { "f32_cmp", "aot_intrinsic_f32_cmp", AOT_INTRINSIC_FLAG_F32_CMP}, - { "f64_cmp", "aot_intrinsic_f64_cmp", AOT_INTRINSIC_FLAG_F64_CMP}, + { "f64_convert_i32_s", "aot_intrinsic_i32_to_f64", AOT_INTRINSIC_FLAG_I32_TO_F64 }, + { "f64_convert_i32_u", "aot_intrinsic_u32_to_f64", AOT_INTRINSIC_FLAG_U32_TO_F64 }, + { "f32_convert_i32_s", "aot_intrinsic_i32_to_f32", AOT_INTRINSIC_FLAG_I32_TO_F32 }, + { "f32_convert_i32_u", "aot_intrinsic_u32_to_f32", AOT_INTRINSIC_FLAG_U32_TO_F32 }, + { "f64_convert_i64_s", "aot_intrinsic_i64_to_f64", AOT_INTRINSIC_FLAG_I32_TO_F64 }, + { "f64_convert_i64_u", "aot_intrinsic_u64_to_f64", AOT_INTRINSIC_FLAG_U64_TO_F64 }, + { "f32_convert_i64_s", "aot_intrinsic_i64_to_f32", AOT_INTRINSIC_FLAG_I64_TO_F32 }, + { "f32_convert_i64_u", "aot_intrinsic_u64_to_f32", AOT_INTRINSIC_FLAG_U64_TO_F32 }, + { "i32_trunc_f64_u", "aot_intrinsic_f64_to_u32", AOT_INTRINSIC_FLAG_I32_TO_F64 }, + { "f32_demote_f64", "aot_intrinsic_f64_to_f32", AOT_INTRINSIC_FLAG_F64_TO_F32 }, + { "f64_promote_f32", "aot_intrinsic_f32_to_f64", AOT_INTRINSIC_FLAG_F32_TO_F64 }, + { "f32_cmp", "aot_intrinsic_f32_cmp", AOT_INTRINSIC_FLAG_F32_CMP }, + { "f64_cmp", "aot_intrinsic_f64_cmp", AOT_INTRINSIC_FLAG_F64_CMP }, }; +/* clang-format on */ static const uint32 g_intrinsic_count = - sizeof(g_intrinsic_mapping) / sizeof(aot_intrinsic); + sizeof(g_intrinsic_mapping) / sizeof(aot_intrinsic); float32 aot_intrinsic_fadd_f32(float32 a, float32 b) @@ -223,7 +211,7 @@ float64 aot_intrinsic_fmin_f64(float64 a, float64 b) { float64 c = fmin(a, b); - if (c==0 && a==b) + if (c == 0 && a == b) return signbit(a) ? a : b; return c; } @@ -243,7 +231,7 @@ float64 aot_intrinsic_fmax_f64(float64 a, float64 b) { float64 c = fmax(a, b); - if (c==0 && a==b) + if (c == 0 && a == b) return signbit(a) ? b : a; return c; } @@ -600,7 +588,8 @@ aot_intrinsic_fill_capability_flags(AOTCompContext *comp_ctx) return; if (!strncmp(comp_ctx->target_arch, "thumb", 5)) { - if (!strcmp(comp_ctx->target_cpu, "cortex-m7")) {} + if (!strcmp(comp_ctx->target_cpu, "cortex-m7")) { + } else if (!strcmp(comp_ctx->target_cpu, "cortex-m4")) { add_f64_common_intrinsics(comp_ctx); } @@ -611,7 +600,7 @@ aot_intrinsic_fill_capability_flags(AOTCompContext *comp_ctx) } } else if (!strncmp(comp_ctx->target_arch, "riscv", 5)) { - /* + /* * Note: Use builtin intrinsics since hardware float operation * will cause rodata relocation */ diff --git a/core/iwasm/aot/aot_intrinsic.h b/core/iwasm/aot/aot_intrinsic.h index 84a8be83..3446ad55 100644 --- a/core/iwasm/aot/aot_intrinsic.h +++ b/core/iwasm/aot/aot_intrinsic.h @@ -22,14 +22,15 @@ extern "C" { * - The lower 48 bits are the intrinsic capability mask */ -#define AOT_INTRINSIC_FLAG(group, number) \ +#define AOT_INTRINSIC_FLAG(group, number) \ ((((uint64)(group & 0xffffLL)) << 48) | ((uint64)1 << number)) #define AOT_INTRINSIC_FLAG_MASK (0x0000ffffffffffffLL) -#define AOT_INTRINSIC_GET_GROUP_FROM_FLAG(flag) \ +#define AOT_INTRINSIC_GET_GROUP_FROM_FLAG(flag) \ ((((uint64)flag) >> 48) & 0xffffLL) +/* clang-format off */ #define AOT_INTRINSIC_FLAG_F32_FADD AOT_INTRINSIC_FLAG(0, 0) #define AOT_INTRINSIC_FLAG_F32_FSUB AOT_INTRINSIC_FLAG(0, 1) #define AOT_INTRINSIC_FLAG_F32_FMUL AOT_INTRINSIC_FLAG(0, 2) @@ -83,6 +84,7 @@ extern "C" { #define AOT_INTRINSIC_FLAG_F64_TO_U64 AOT_INTRINSIC_FLAG(1, 23) #define AOT_INTRINSIC_FLAG_F64_TO_F32 AOT_INTRINSIC_FLAG(1, 24) #define AOT_INTRINSIC_FLAG_F64_CMP AOT_INTRINSIC_FLAG(1, 25) +/* clang-format on */ float32 aot_intrinsic_fadd_f32(float32 a, float32 b); diff --git a/core/iwasm/aot/aot_loader.c b/core/iwasm/aot/aot_loader.c index 8c296f0e..1923a6a2 100644 --- a/core/iwasm/aot/aot_loader.c +++ b/core/iwasm/aot/aot_loader.c @@ -26,14 +26,13 @@ static void set_error_buf(char *error_buf, uint32 error_buf_size, const char *string) { if (error_buf != NULL) { - snprintf(error_buf, error_buf_size, - "AOT module load failed: %s", string); + snprintf(error_buf, error_buf_size, "AOT module load failed: %s", + string); } } static void -set_error_buf_v(char *error_buf, uint32 error_buf_size, - const char *format, ...) +set_error_buf_v(char *error_buf, uint32 error_buf_size, const char *format, ...) { va_list args; char buf[128]; @@ -42,8 +41,7 @@ set_error_buf_v(char *error_buf, uint32 error_buf_size, va_start(args, format); vsnprintf(buf, sizeof(buf), format, args); va_end(args); - snprintf(error_buf, error_buf_size, - "AOT module load failed: %s", buf); + snprintf(error_buf, error_buf_size, "AOT module load failed: %s", buf); } } @@ -99,110 +97,113 @@ check_buf(const uint8 *buf, const uint8 *buf_end, uint32 length, return true; } -#define CHECK_BUF(buf, buf_end, length) do { \ - if (!check_buf(buf, buf_end, length, \ - error_buf, error_buf_size)) { \ - goto fail; \ - } \ -} while (0) +#define CHECK_BUF(buf, buf_end, length) \ + do { \ + if (!check_buf(buf, buf_end, length, error_buf, error_buf_size)) { \ + goto fail; \ + } \ + } while (0) -static uint8* +static uint8 * align_ptr(const uint8 *p, uint32 b) { uintptr_t v = (uintptr_t)p; uintptr_t m = b - 1; - return (uint8*)((v + m) & ~m); + return (uint8 *)((v + m) & ~m); } static inline uint64 GET_U64_FROM_ADDR(uint32 *addr) { - union { uint64 val; uint32 parts[2]; } u; + union { + uint64 val; + uint32 parts[2]; + } u; u.parts[0] = addr[0]; u.parts[1] = addr[1]; return u.val; } -#define TEMPLATE_READ(p, p_end, res, type) do { \ - if (sizeof(type) != sizeof(uint64)) \ - p = (uint8*)align_ptr(p, sizeof(type)); \ - else \ - /* align 4 bytes if type is uint64 */ \ - p = (uint8*)align_ptr(p, sizeof(uint32)); \ - CHECK_BUF(p, p_end, sizeof(type)); \ - if (sizeof(type) != sizeof(uint64)) \ - res = *(type*)p; \ - else \ - res = (type)GET_U64_FROM_ADDR((uint32*)p); \ - if (!is_little_endian()) \ - exchange_##type((uint8*)&res); \ - p += sizeof(type); \ - } while (0) +#define TEMPLATE_READ(p, p_end, res, type) \ + do { \ + if (sizeof(type) != sizeof(uint64)) \ + p = (uint8 *)align_ptr(p, sizeof(type)); \ + else \ + /* align 4 bytes if type is uint64 */ \ + p = (uint8 *)align_ptr(p, sizeof(uint32)); \ + CHECK_BUF(p, p_end, sizeof(type)); \ + if (sizeof(type) != sizeof(uint64)) \ + res = *(type *)p; \ + else \ + res = (type)GET_U64_FROM_ADDR((uint32 *)p); \ + if (!is_little_endian()) \ + exchange_##type((uint8 *)&res); \ + p += sizeof(type); \ + } while (0) #define read_uint8(p, p_end, res) TEMPLATE_READ(p, p_end, res, uint8) #define read_uint16(p, p_end, res) TEMPLATE_READ(p, p_end, res, uint16) #define read_uint32(p, p_end, res) TEMPLATE_READ(p, p_end, res, uint32) #define read_uint64(p, p_end, res) TEMPLATE_READ(p, p_end, res, uint64) -#define read_byte_array(p, p_end, addr, len) do { \ - CHECK_BUF(p, p_end, len); \ - memcpy(addr, p, len); \ - p += len; \ - } while (0) +#define read_byte_array(p, p_end, addr, len) \ + do { \ + CHECK_BUF(p, p_end, len); \ + memcpy(addr, p, len); \ + p += len; \ + } while (0) -#define read_string(p, p_end, str) do { \ - uint16 str_len; \ - read_uint16(p, p_end, str_len); \ - CHECK_BUF(p, p_end, str_len); \ - if (!(str = const_str_set_insert \ - (p, str_len, module, \ - error_buf, error_buf_size))) { \ - goto fail; \ - } \ - p += str_len; \ - } while (0) +#define read_string(p, p_end, str) \ + do { \ + uint16 str_len; \ + read_uint16(p, p_end, str_len); \ + CHECK_BUF(p, p_end, str_len); \ + if (!(str = const_str_set_insert(p, str_len, module, error_buf, \ + error_buf_size))) { \ + goto fail; \ + } \ + p += str_len; \ + } while (0) /* Legal values for bin_type */ -#define BIN_TYPE_ELF32L 0 /* 32-bit little endian */ -#define BIN_TYPE_ELF32B 1 /* 32-bit big endian */ -#define BIN_TYPE_ELF64L 2 /* 64-bit little endian */ -#define BIN_TYPE_ELF64B 3 /* 64-bit big endian */ -#define BIN_TYPE_COFF64 6 /* 64-bit little endian */ +#define BIN_TYPE_ELF32L 0 /* 32-bit little endian */ +#define BIN_TYPE_ELF32B 1 /* 32-bit big endian */ +#define BIN_TYPE_ELF64L 2 /* 64-bit little endian */ +#define BIN_TYPE_ELF64B 3 /* 64-bit big endian */ +#define BIN_TYPE_COFF64 6 /* 64-bit little endian */ /* Legal values for e_type (object file type). */ -#define E_TYPE_NONE 0 /* No file type */ -#define E_TYPE_REL 1 /* Relocatable file */ -#define E_TYPE_EXEC 2 /* Executable file */ -#define E_TYPE_DYN 3 /* Shared object file */ +#define E_TYPE_NONE 0 /* No file type */ +#define E_TYPE_REL 1 /* Relocatable file */ +#define E_TYPE_EXEC 2 /* Executable file */ +#define E_TYPE_DYN 3 /* Shared object file */ /* Legal values for e_machine (architecture). */ -#define E_MACHINE_386 3 /* Intel 80386 */ -#define E_MACHINE_MIPS 8 /* MIPS R3000 big-endian */ -#define E_MACHINE_MIPS_RS3_LE 10 /* MIPS R3000 little-endian */ -#define E_MACHINE_ARM 40 /* ARM/Thumb */ -#define E_MACHINE_AARCH64 183 /* AArch64 */ -#define E_MACHINE_ARC 45 /* Argonaut RISC Core */ -#define E_MACHINE_IA_64 50 /* Intel Merced */ -#define E_MACHINE_MIPS_X 51 /* Stanford MIPS-X */ -#define E_MACHINE_X86_64 62 /* AMD x86-64 architecture */ -#define E_MACHINE_ARC_COMPACT 93 /* ARC International ARCompact */ +#define E_MACHINE_386 3 /* Intel 80386 */ +#define E_MACHINE_MIPS 8 /* MIPS R3000 big-endian */ +#define E_MACHINE_MIPS_RS3_LE 10 /* MIPS R3000 little-endian */ +#define E_MACHINE_ARM 40 /* ARM/Thumb */ +#define E_MACHINE_AARCH64 183 /* AArch64 */ +#define E_MACHINE_ARC 45 /* Argonaut RISC Core */ +#define E_MACHINE_IA_64 50 /* Intel Merced */ +#define E_MACHINE_MIPS_X 51 /* Stanford MIPS-X */ +#define E_MACHINE_X86_64 62 /* AMD x86-64 architecture */ +#define E_MACHINE_ARC_COMPACT 93 /* ARC International ARCompact */ #define E_MACHINE_ARC_COMPACT2 195 /* Synopsys ARCompact V2 */ -#define E_MACHINE_XTENSA 94 /* Tensilica Xtensa Architecture */ -#define E_MACHINE_RISCV 243 /* RISC-V 32/64 */ +#define E_MACHINE_XTENSA 94 /* Tensilica Xtensa Architecture */ +#define E_MACHINE_RISCV 243 /* RISC-V 32/64 */ #define E_MACHINE_WIN_X86_64 0x8664 /* Windowx x86-64 architecture */ /* Legal values for e_version */ -#define E_VERSION_CURRENT 1 /* Current version */ +#define E_VERSION_CURRENT 1 /* Current version */ static void * loader_malloc(uint64 size, char *error_buf, uint32 error_buf_size) { void *mem; - if (size >= UINT32_MAX - || !(mem = wasm_runtime_malloc((uint32)size))) { - set_error_buf(error_buf, error_buf_size, - "allocate memory failed"); + if (size >= UINT32_MAX || !(mem = wasm_runtime_malloc((uint32)size))) { + set_error_buf(error_buf, error_buf_size, "allocate memory failed"); return NULL; } @@ -210,15 +211,14 @@ loader_malloc(uint64 size, char *error_buf, uint32 error_buf_size) return mem; } -static char* +static char * const_str_set_insert(const uint8 *str, int32 len, AOTModule *module, - char* error_buf, uint32 error_buf_size) + char *error_buf, uint32 error_buf_size) { HashMap *set = module->const_str_set; char *c_str, *value; - if (!(c_str = loader_malloc((uint32)len + 1, - error_buf, error_buf_size))) { + if (!(c_str = loader_malloc((uint32)len + 1, error_buf, error_buf_size))) { return NULL; } @@ -241,9 +241,9 @@ const_str_set_insert(const uint8 *str, int32 len, AOTModule *module, } static bool -get_aot_file_target(AOTTargetInfo *target_info, - char *target_buf, uint32 target_buf_size, - char *error_buf, uint32 error_buf_size) +get_aot_file_target(AOTTargetInfo *target_info, char *target_buf, + uint32 target_buf_size, char *error_buf, + uint32 error_buf_size) { char *machine_type = NULL; switch (target_info->e_machine) { @@ -273,14 +273,14 @@ get_aot_file_target(AOTTargetInfo *target_info, break; default: set_error_buf_v(error_buf, error_buf_size, - "unknown machine type %d", - target_info->e_machine); + "unknown machine type %d", target_info->e_machine); return false; } if (strncmp(target_info->arch, machine_type, strlen(machine_type))) { - set_error_buf_v(error_buf, error_buf_size, - "machine type (%s) isn't consistent with target type (%s)", - machine_type, target_info->arch); + set_error_buf_v( + error_buf, error_buf_size, + "machine type (%s) isn't consistent with target type (%s)", + machine_type, target_info->arch); return false; } snprintf(target_buf, target_buf_size, "%s", target_info->arch); @@ -288,8 +288,8 @@ get_aot_file_target(AOTTargetInfo *target_info, } static bool -check_machine_info(AOTTargetInfo *target_info, - char *error_buf, uint32 error_buf_size) +check_machine_info(AOTTargetInfo *target_info, char *error_buf, + uint32 error_buf_size) { char target_expected[32], target_got[32]; @@ -311,8 +311,8 @@ check_machine_info(AOTTargetInfo *target_info, static bool load_target_info_section(const uint8 *buf, const uint8 *buf_end, - AOTModule *module, - char *error_buf, uint32 error_buf_size) + AOTModule *module, char *error_buf, + uint32 error_buf_size) { AOTTargetInfo target_info; const uint8 *p = buf, *p_end = buf_end; @@ -325,12 +325,10 @@ load_target_info_section(const uint8 *buf, const uint8 *buf_end, read_uint32(p, p_end, target_info.e_version); read_uint32(p, p_end, target_info.e_flags); read_uint32(p, p_end, target_info.reserved); - read_byte_array(p, p_end, - target_info.arch, sizeof(target_info.arch)); + read_byte_array(p, p_end, target_info.arch, sizeof(target_info.arch)); if (p != buf_end) { - set_error_buf(error_buf, error_buf_size, - "invalid section size"); + set_error_buf(error_buf, error_buf_size, "invalid section size"); return false; } @@ -340,16 +338,17 @@ load_target_info_section(const uint8 *buf, const uint8 *buf_end, set_error_buf_v(error_buf, error_buf_size, "invalid target endian type, expected %s but got %s", is_little_endian() ? "little endian" : "big endian", - is_target_little_endian ? "little endian" : "big endian"); + is_target_little_endian ? "little endian" + : "big endian"); return false; } /* Check target bit width */ is_target_64_bit = target_info.bin_type & 2 ? true : false; - if ((sizeof(void*) == 8 ? true : false) != is_target_64_bit) { + if ((sizeof(void *) == 8 ? true : false) != is_target_64_bit) { set_error_buf_v(error_buf, error_buf_size, "invalid target bit width, expected %s but got %s", - sizeof(void*) == 8 ? "64-bit" : "32-bit", + sizeof(void *) == 8 ? "64-bit" : "32-bit", is_target_64_bit ? "64-bit" : "32-bit"); return false; } @@ -368,8 +367,7 @@ load_target_info_section(const uint8 *buf, const uint8 *buf_end, } if (target_info.e_version != E_VERSION_CURRENT) { - set_error_buf(error_buf, error_buf_size, - "invalid elf file version"); + set_error_buf(error_buf, error_buf_size, "invalid elf file version"); return false; } @@ -400,8 +398,8 @@ get_native_symbol_by_name(const char *name) static bool load_native_symbol_section(const uint8 *buf, const uint8 *buf_end, - AOTModule *module, - char *error_buf, uint32 error_buf_size) + AOTModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; uint32 cnt; @@ -437,8 +435,7 @@ fail: } static bool -load_custom_section(const uint8 *buf, const uint8 *buf_end, - AOTModule *module, +load_custom_section(const uint8 *buf, const uint8 *buf_end, AOTModule *module, char *error_buf, uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; @@ -449,8 +446,8 @@ load_custom_section(const uint8 *buf, const uint8 *buf_end, switch (sub_section_type) { case AOT_CUSTOM_SECTION_NATIVE_SYMBOL: - if (!load_native_symbol_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_native_symbol_section(buf, buf_end, module, error_buf, + error_buf_size)) goto fail; break; default: @@ -463,8 +460,7 @@ fail: } static void -destroy_import_memories(AOTImportMemory *import_memories, - bool is_jit_mode) +destroy_import_memories(AOTImportMemory *import_memories, bool is_jit_mode) { if (!is_jit_mode) wasm_runtime_free(import_memories); @@ -485,8 +481,8 @@ destroy_mem_init_data_list(AOTMemInitData **data_list, uint32 count, static bool load_mem_init_data_list(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, - char *error_buf, uint32 error_buf_size) + AOTModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *buf = *p_buf; AOTMemInitData **data_list; @@ -496,7 +492,7 @@ load_mem_init_data_list(const uint8 **p_buf, const uint8 *buf_end, /* Allocate memory */ size = sizeof(AOTMemInitData *) * (uint64)module->mem_init_data_count; if (!(module->mem_init_data_list = data_list = - loader_malloc(size, error_buf, error_buf_size))) { + loader_malloc(size, error_buf, error_buf_size))) { return false; } @@ -513,8 +509,7 @@ load_mem_init_data_list(const uint8 **p_buf, const uint8 *buf_end, read_uint64(buf, buf_end, init_expr_value); read_uint32(buf, buf_end, byte_count); size = offsetof(AOTMemInitData, bytes) + (uint64)byte_count; - if (!(data_list[i] = loader_malloc - (size, error_buf, error_buf_size))) { + if (!(data_list[i] = loader_malloc(size, error_buf, error_buf_size))) { return false; } @@ -526,8 +521,8 @@ load_mem_init_data_list(const uint8 **p_buf, const uint8 *buf_end, data_list[i]->offset.init_expr_type = (uint8)init_expr_type; data_list[i]->offset.u.i64 = (int64)init_expr_value; data_list[i]->byte_count = byte_count; - read_byte_array(buf, buf_end, - data_list[i]->bytes, data_list[i]->byte_count); + read_byte_array(buf, buf_end, data_list[i]->bytes, + data_list[i]->byte_count); } *p_buf = buf; @@ -537,8 +532,7 @@ fail: } static bool -load_memory_info(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, +load_memory_info(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module, char *error_buf, uint32 error_buf_size) { uint32 i; @@ -552,7 +546,7 @@ load_memory_info(const uint8 **p_buf, const uint8 *buf_end, read_uint32(buf, buf_end, module->memory_count); total_size = sizeof(AOTMemory) * (uint64)module->memory_count; if (!(module->memories = - loader_malloc(total_size, error_buf, error_buf_size))) { + loader_malloc(total_size, error_buf, error_buf_size))) { return false; } @@ -567,8 +561,8 @@ load_memory_info(const uint8 **p_buf, const uint8 *buf_end, /* load memory init data list */ if (module->mem_init_data_count > 0 - && !load_mem_init_data_list(&buf, buf_end, module, - error_buf, error_buf_size)) + && !load_mem_init_data_list(&buf, buf_end, module, error_buf, + error_buf_size)) return false; *p_buf = buf; @@ -605,10 +599,8 @@ destroy_table_init_data_list(AOTTableInitData **data_list, uint32 count, } static bool -load_import_table_list(const uint8 **p_buf, - const uint8 *buf_end, - AOTModule *module, - char *error_buf, +load_import_table_list(const uint8 **p_buf, const uint8 *buf_end, + AOTModule *module, char *error_buf, uint32 error_buf_size) { const uint8 *buf = *p_buf; @@ -619,7 +611,7 @@ load_import_table_list(const uint8 **p_buf, /* Allocate memory */ size = sizeof(AOTImportTable) * (uint64)module->import_table_count; if (!(module->import_tables = import_table = - loader_malloc(size, error_buf, error_buf_size))) { + loader_malloc(size, error_buf, error_buf_size))) { return false; } @@ -638,8 +630,8 @@ fail: } static bool -load_table_list(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, char *error_buf, uint32 error_buf_size) +load_table_list(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module, + char *error_buf, uint32 error_buf_size) { const uint8 *buf = *p_buf; AOTTable *table; @@ -649,7 +641,7 @@ load_table_list(const uint8 **p_buf, const uint8 *buf_end, /* Allocate memory */ size = sizeof(AOTTable) * (uint64)module->table_count; if (!(module->tables = table = - loader_malloc(size, error_buf, error_buf_size))) { + loader_malloc(size, error_buf, error_buf_size))) { return false; } @@ -671,8 +663,8 @@ fail: static bool load_table_init_data_list(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, - char *error_buf, uint32 error_buf_size) + AOTModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *buf = *p_buf; AOTTableInitData **data_list; @@ -682,7 +674,7 @@ load_table_init_data_list(const uint8 **p_buf, const uint8 *buf_end, /* Allocate memory */ size = sizeof(AOTTableInitData *) * (uint64)module->table_init_data_count; if (!(module->table_init_data_list = data_list = - loader_malloc(size, error_buf, error_buf_size))) { + loader_malloc(size, error_buf, error_buf_size))) { return false; } @@ -701,8 +693,7 @@ load_table_init_data_list(const uint8 **p_buf, const uint8 *buf_end, size1 = sizeof(uint32) * (uint64)func_index_count; size = offsetof(AOTTableInitData, func_indexes) + size1; - if (!(data_list[i] = loader_malloc - (size, error_buf, error_buf_size))) { + if (!(data_list[i] = loader_malloc(size, error_buf, error_buf_size))) { return false; } @@ -713,7 +704,8 @@ load_table_init_data_list(const uint8 **p_buf, const uint8 *buf_end, data_list[i]->offset.init_expr_type = (uint8)init_expr_type; data_list[i]->offset.u.i64 = (int64)init_expr_value; data_list[i]->func_index_count = func_index_count; - read_byte_array(buf, buf_end, data_list[i]->func_indexes, (uint32)size1); + read_byte_array(buf, buf_end, data_list[i]->func_indexes, + (uint32)size1); } *p_buf = buf; @@ -723,8 +715,7 @@ fail: } static bool -load_table_info(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, +load_table_info(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module, char *error_buf, uint32 error_buf_size) { const uint8 *buf = *p_buf; @@ -744,8 +735,8 @@ load_table_info(const uint8 **p_buf, const uint8 *buf_end, /* load table init data list */ if (module->table_init_data_count > 0 - && !load_table_init_data_list(&buf, buf_end, module, - error_buf, error_buf_size)) + && !load_table_init_data_list(&buf, buf_end, module, error_buf, + error_buf_size)) return false; *p_buf = buf; @@ -767,8 +758,7 @@ destroy_func_types(AOTFuncType **func_types, uint32 count, bool is_jit_mode) } static bool -load_func_types(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, +load_func_types(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module, char *error_buf, uint32 error_buf_size) { const uint8 *buf = *p_buf; @@ -778,8 +768,8 @@ load_func_types(const uint8 **p_buf, const uint8 *buf_end, /* Allocate memory */ size = sizeof(AOTFuncType *) * (uint64)module->func_type_count; - if (!(module->func_types = func_types = loader_malloc - (size, error_buf, error_buf_size))) { + if (!(module->func_types = func_types = + loader_malloc(size, error_buf, error_buf_size))) { return false; } @@ -800,8 +790,7 @@ load_func_types(const uint8 **p_buf, const uint8 *buf_end, size1 = (uint64)param_count + (uint64)result_count; size = offsetof(AOTFuncType, types) + size1; - if (!(func_types[i] = loader_malloc - (size, error_buf, error_buf_size))) { + if (!(func_types[i] = loader_malloc(size, error_buf, error_buf_size))) { return false; } @@ -810,8 +799,8 @@ load_func_types(const uint8 **p_buf, const uint8 *buf_end, read_byte_array(buf, buf_end, func_types[i]->types, (uint32)size1); param_cell_num = wasm_get_cell_num(func_types[i]->types, param_count); - ret_cell_num = wasm_get_cell_num(func_types[i]->types + param_count, - result_count); + ret_cell_num = + wasm_get_cell_num(func_types[i]->types + param_count, result_count); if (param_cell_num > UINT16_MAX || ret_cell_num > UINT16_MAX) { set_error_buf(error_buf, error_buf_size, "param count or result count too large"); @@ -830,8 +819,7 @@ fail: static bool load_func_type_info(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, - char *error_buf, uint32 error_buf_size) + AOTModule *module, char *error_buf, uint32 error_buf_size) { const uint8 *buf = *p_buf; @@ -857,8 +845,7 @@ destroy_import_globals(AOTImportGlobal *import_globals, bool is_jit_mode) static bool load_import_globals(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, - char *error_buf, uint32 error_buf_size) + AOTModule *module, char *error_buf, uint32 error_buf_size) { const uint8 *buf = *p_buf; AOTImportGlobal *import_globals; @@ -871,13 +858,13 @@ load_import_globals(const uint8 **p_buf, const uint8 *buf_end, /* Allocate memory */ size = sizeof(AOTImportGlobal) * (uint64)module->import_global_count; if (!(module->import_globals = import_globals = - loader_malloc(size, error_buf, error_buf_size))) { + loader_malloc(size, error_buf, error_buf_size))) { return false; } /* Create each import global */ for (i = 0; i < module->import_global_count; i++) { - buf = (uint8*)align_ptr(buf, 2); + buf = (uint8 *)align_ptr(buf, 2); read_uint8(buf, buf_end, import_globals[i].type); read_uint8(buf, buf_end, import_globals[i].is_mutable); read_string(buf, buf_end, import_globals[i].module_name); @@ -885,9 +872,8 @@ load_import_globals(const uint8 **p_buf, const uint8 *buf_end, #if WASM_ENABLE_LIBC_BUILTIN != 0 if (wasm_native_lookup_libc_builtin_global( - import_globals[i].module_name, - import_globals[i].global_name, - &tmp_global)) { + import_globals[i].module_name, import_globals[i].global_name, + &tmp_global)) { if (tmp_global.type != import_globals[i].type || tmp_global.is_mutable != import_globals[i].is_mutable) { set_error_buf(error_buf, error_buf_size, @@ -895,7 +881,7 @@ load_import_globals(const uint8 **p_buf, const uint8 *buf_end, return false; } import_globals[i].global_data_linked = - tmp_global.global_data_linked; + tmp_global.global_data_linked; } #endif @@ -913,8 +899,8 @@ fail: static bool load_import_global_info(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, - char *error_buf, uint32 error_buf_size) + AOTModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *buf = *p_buf; @@ -922,8 +908,8 @@ load_import_global_info(const uint8 **p_buf, const uint8 *buf_end, /* load import globals */ if (module->import_global_count > 0 - && !load_import_globals(&buf, buf_end, module, - error_buf, error_buf_size)) + && !load_import_globals(&buf, buf_end, module, error_buf, + error_buf_size)) return false; *p_buf = buf; @@ -940,8 +926,7 @@ destroy_globals(AOTGlobal *globals, bool is_jit_mode) } static bool -load_globals(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, +load_globals(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module, char *error_buf, uint32 error_buf_size) { const uint8 *buf = *p_buf; @@ -952,16 +937,16 @@ load_globals(const uint8 **p_buf, const uint8 *buf_end, /* Allocate memory */ size = sizeof(AOTGlobal) * (uint64)module->global_count; - if (!(module->globals = globals = loader_malloc - (size, error_buf, error_buf_size))) { + if (!(module->globals = globals = + loader_malloc(size, error_buf, error_buf_size))) { return false; } if (module->import_global_count > 0) { last_import_global = &module->import_globals[module->import_global_count - 1]; - data_offset = last_import_global->data_offset - + last_import_global->size; + data_offset = + last_import_global->data_offset + last_import_global->size; } /* Create each global */ @@ -997,8 +982,7 @@ fail: } static bool -load_global_info(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, +load_global_info(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module, char *error_buf, uint32 error_buf_size) { const uint8 *buf = *p_buf; @@ -1017,16 +1001,14 @@ fail: } static void -destroy_import_funcs(AOTImportFunc *import_funcs, - bool is_jit_mode) +destroy_import_funcs(AOTImportFunc *import_funcs, bool is_jit_mode) { if (!is_jit_mode) wasm_runtime_free(import_funcs); } static bool -load_import_funcs(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, +load_import_funcs(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module, char *error_buf, uint32 error_buf_size) { const char *module_name, *field_name; @@ -1038,7 +1020,7 @@ load_import_funcs(const uint8 **p_buf, const uint8 *buf_end, /* Allocate memory */ size = sizeof(AOTImportFunc) * (uint64)module->import_func_count; if (!(module->import_funcs = import_funcs = - loader_malloc(size, error_buf, error_buf_size))) { + loader_malloc(size, error_buf, error_buf_size))) { return false; } @@ -1049,18 +1031,17 @@ load_import_funcs(const uint8 **p_buf, const uint8 *buf_end, set_error_buf(error_buf, error_buf_size, "unknown type"); return false; } - import_funcs[i].func_type = module->func_types[import_funcs[i].func_type_index]; + import_funcs[i].func_type = + module->func_types[import_funcs[i].func_type_index]; read_string(buf, buf_end, import_funcs[i].module_name); read_string(buf, buf_end, import_funcs[i].func_name); module_name = import_funcs[i].module_name; field_name = import_funcs[i].func_name; - import_funcs[i].func_ptr_linked = - wasm_native_resolve_symbol(module_name, field_name, - import_funcs[i].func_type, - &import_funcs[i].signature, - &import_funcs[i].attachment, - &import_funcs[i].call_conv_raw); + import_funcs[i].func_ptr_linked = wasm_native_resolve_symbol( + module_name, field_name, import_funcs[i].func_type, + &import_funcs[i].signature, &import_funcs[i].attachment, + &import_funcs[i].call_conv_raw); #if WASM_ENABLE_LIBC_WASI != 0 if (!strcmp(import_funcs[i].module_name, "wasi_unstable") @@ -1077,8 +1058,7 @@ fail: static bool load_import_func_info(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, - char *error_buf, uint32 error_buf_size) + AOTModule *module, char *error_buf, uint32 error_buf_size) { const uint8 *buf = *p_buf; @@ -1086,8 +1066,7 @@ load_import_func_info(const uint8 **p_buf, const uint8 *buf_end, /* load import funcs */ if (module->import_func_count > 0 - && !load_import_funcs(&buf, buf_end, module, - error_buf, error_buf_size)) + && !load_import_funcs(&buf, buf_end, module, error_buf, error_buf_size)) return false; *p_buf = buf; @@ -1110,8 +1089,8 @@ destroy_object_data_sections(AOTObjectDataSection *data_sections, static bool load_object_data_sections(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, - char *error_buf, uint32 error_buf_size) + AOTModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *buf = *p_buf; AOTObjectDataSection *data_sections; @@ -1121,7 +1100,7 @@ load_object_data_sections(const uint8 **p_buf, const uint8 *buf_end, /* Allocate memory */ size = sizeof(AOTObjectDataSection) * (uint64)module->data_section_count; if (!(module->data_sections = data_sections = - loader_malloc(size, error_buf, error_buf_size))) { + loader_malloc(size, error_buf, error_buf_size))) { return false; } @@ -1129,7 +1108,8 @@ load_object_data_sections(const uint8 **p_buf, const uint8 *buf_end, for (i = 0; i < module->data_section_count; i++) { int map_prot = MMAP_PROT_READ | MMAP_PROT_WRITE; #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \ - || defined(BUILD_TARGET_RISCV64_LP64D) || defined(BUILD_TARGET_RISCV64_LP64) + || defined(BUILD_TARGET_RISCV64_LP64D) \ + || defined(BUILD_TARGET_RISCV64_LP64) /* aot code and data in x86_64 must be in range 0 to 2G due to relocation for R_X86_64_32/32S/PC32 */ int map_flags = MMAP_MAP_32BIT; @@ -1142,10 +1122,9 @@ load_object_data_sections(const uint8 **p_buf, const uint8 *buf_end, /* Allocate memory for data */ if (data_sections[i].size > 0 - && !(data_sections[i].data = - os_mmap(NULL, data_sections[i].size, map_prot, map_flags))) { - set_error_buf(error_buf, error_buf_size, - "allocate memory failed"); + && !(data_sections[i].data = os_mmap(NULL, data_sections[i].size, + map_prot, map_flags))) { + set_error_buf(error_buf, error_buf_size, "allocate memory failed"); return false; } #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) @@ -1157,8 +1136,8 @@ load_object_data_sections(const uint8 **p_buf, const uint8 *buf_end, #endif #endif - read_byte_array(buf, buf_end, - data_sections[i].data, data_sections[i].size); + read_byte_array(buf, buf_end, data_sections[i].data, + data_sections[i].size); } *p_buf = buf; @@ -1169,8 +1148,8 @@ fail: static bool load_object_data_sections_info(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, - char *error_buf, uint32 error_buf_size) + AOTModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *buf = *p_buf; @@ -1178,8 +1157,8 @@ load_object_data_sections_info(const uint8 **p_buf, const uint8 *buf_end, /* load object data sections */ if (module->data_section_count > 0 - && !load_object_data_sections(&buf, buf_end, module, - error_buf, error_buf_size)) + && !load_object_data_sections(&buf, buf_end, module, error_buf, + error_buf_size)) return false; *p_buf = buf; @@ -1190,15 +1169,16 @@ fail: static bool load_init_data_section(const uint8 *buf, const uint8 *buf_end, - AOTModule *module, - char *error_buf, uint32 error_buf_size) + AOTModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; if (!load_memory_info(&p, p_end, module, error_buf, error_buf_size) || !load_table_info(&p, p_end, module, error_buf, error_buf_size) || !load_func_type_info(&p, p_end, module, error_buf, error_buf_size) - || !load_import_global_info(&p, p_end, module, error_buf, error_buf_size) + || !load_import_global_info(&p, p_end, module, error_buf, + error_buf_size) || !load_global_info(&p, p_end, module, error_buf, error_buf_size) || !load_import_func_info(&p, p_end, module, error_buf, error_buf_size)) return false; @@ -1209,8 +1189,8 @@ load_init_data_section(const uint8 *buf, const uint8 *buf_end, /* check start function index */ if (module->start_func_index != (uint32)-1 - && (module->start_func_index >= module->import_func_count - + module->func_count)) { + && (module->start_func_index + >= module->import_func_count + module->func_count)) { set_error_buf(error_buf, error_buf_size, "invalid start function index"); return false; @@ -1224,8 +1204,8 @@ load_init_data_section(const uint8 *buf, const uint8 *buf_end, read_uint32(p, p_end, module->aux_stack_bottom); read_uint32(p, p_end, module->aux_stack_size); - if (!load_object_data_sections_info(&p, p_end, module, - error_buf, error_buf_size)) + if (!load_object_data_sections_info(&p, p_end, module, error_buf, + error_buf_size)) return false; if (p != p_end) { @@ -1240,15 +1220,13 @@ fail: } static bool -load_text_section(const uint8 *buf, const uint8 *buf_end, - AOTModule *module, +load_text_section(const uint8 *buf, const uint8 *buf_end, AOTModule *module, char *error_buf, uint32 error_buf_size) { uint8 *plt_base; if (module->func_count > 0 && buf_end == buf) { - set_error_buf(error_buf, error_buf_size, - "invalid code size"); + set_error_buf(error_buf, error_buf_size, "invalid code size"); return false; } @@ -1256,9 +1234,9 @@ load_text_section(const uint8 *buf, const uint8 *buf_end, read_uint32(buf, buf_end, module->literal_size); /* literal data is at begining of the text section */ - module->literal = (uint8*)buf; - module->code = (void*)(buf + module->literal_size); - module->code_size = (uint32)(buf_end - (uint8*)module->code); + module->literal = (uint8 *)buf; + module->code = (void *)(buf + module->literal_size); + module->code_size = (uint32)(buf_end - (uint8 *)module->code); #if WASM_ENABLE_DEBUG_AOT != 0 module->elf_size = module->code_size; @@ -1289,8 +1267,7 @@ fail: } static bool -load_function_section(const uint8 *buf, const uint8 *buf_end, - AOTModule *module, +load_function_section(const uint8 *buf, const uint8 *buf_end, AOTModule *module, char *error_buf, uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; @@ -1304,29 +1281,29 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, #endif #if defined(OS_ENABLE_HW_BOUND_CHECK) && defined(BH_PLATFORM_WINDOWS) - unwind_info= (AOTUnwindInfo *)((uint8*)module->code + module->code_size - - sizeof(AOTUnwindInfo)); + unwind_info = (AOTUnwindInfo *)((uint8 *)module->code + module->code_size + - sizeof(AOTUnwindInfo)); unwind_info->Version = 1; unwind_info->Flags = UNW_FLAG_NHANDLER; - *(uint32*)&unwind_info->UnwindCode[0] = unwind_code_offset; + *(uint32 *)&unwind_info->UnwindCode[0] = unwind_code_offset; size = sizeof(RUNTIME_FUNCTION) * (uint64)module->func_count; if (size > 0 && !(rtl_func_table = module->rtl_func_table = - loader_malloc(size, error_buf, error_buf_size))) { + loader_malloc(size, error_buf, error_buf_size))) { return false; } #endif - size = sizeof(void*) * (uint64)module->func_count; + size = sizeof(void *) * (uint64)module->func_count; if (size > 0 - && !(module->func_ptrs = loader_malloc - (size, error_buf, error_buf_size))) { + && !(module->func_ptrs = + loader_malloc(size, error_buf, error_buf_size))) { return false; } for (i = 0; i < module->func_count; i++) { - if (sizeof(void*) == 8) { + if (sizeof(void *) == 8) { read_uint64(p, p_end, text_offset); } else { @@ -1339,10 +1316,10 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, "invalid function code offset"); return false; } - module->func_ptrs[i] = (uint8*)module->code + text_offset; + module->func_ptrs[i] = (uint8 *)module->code + text_offset; #if defined(BUILD_TARGET_THUMB) || defined(BUILD_TARGET_THUMB_VFP) /* bits[0] of thumb function address must be 1 */ - module->func_ptrs[i] = (void*)((uintptr_t)module->func_ptrs[i] | 1); + module->func_ptrs[i] = (void *)((uintptr_t)module->func_ptrs[i] | 1); #endif #if defined(OS_ENABLE_HW_BOUND_CHECK) && defined(BH_PLATFORM_WINDOWS) rtl_func_table[i].BeginAddress = (DWORD)text_offset; @@ -1356,7 +1333,7 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, #if defined(OS_ENABLE_HW_BOUND_CHECK) && defined(BH_PLATFORM_WINDOWS) if (module->func_count > 0) { rtl_func_table[module->func_count - 1].EndAddress = - (DWORD)(module->code_size - get_plt_table_size()); + (DWORD)(module->code_size - get_plt_table_size()); if (!RtlAddFunctionTable(rtl_func_table, module->func_count, (DWORD64)(uintptr_t)module->code)) { @@ -1373,7 +1350,7 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, if (module->start_func_index >= module->import_func_count) module->start_function = module->func_ptrs[module->start_func_index - - module->import_func_count]; + - module->import_func_count]; else /* TODO: fix start function can be import function issue */ module->start_function = NULL; @@ -1384,8 +1361,8 @@ load_function_section(const uint8 *buf, const uint8 *buf_end, size = sizeof(uint32) * (uint64)module->func_count; if (size > 0 - && !(module->func_type_indexes = loader_malloc - (size, error_buf, error_buf_size))) { + && !(module->func_type_indexes = + loader_malloc(size, error_buf, error_buf_size))) { return false; } @@ -1416,8 +1393,8 @@ destroy_exports(AOTExport *exports, bool is_jit_mode) } static bool -load_exports(const uint8 **p_buf, const uint8 *buf_end, - AOTModule *module, char *error_buf, uint32 error_buf_size) +load_exports(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module, + char *error_buf, uint32 error_buf_size) { const uint8 *buf = *p_buf; AOTExport *exports; @@ -1427,7 +1404,7 @@ load_exports(const uint8 **p_buf, const uint8 *buf_end, /* Allocate memory */ size = sizeof(AOTExport) * (uint64)module->export_count; if (!(module->exports = exports = - loader_malloc(size, error_buf, error_buf_size))) { + loader_malloc(size, error_buf, error_buf_size))) { return false; } @@ -1453,8 +1430,7 @@ fail: } static bool -load_export_section(const uint8 *buf, const uint8 *buf_end, - AOTModule *module, +load_export_section(const uint8 *buf, const uint8 *buf_end, AOTModule *module, char *error_buf, uint32 error_buf_size) { const uint8 *p = buf, *p_end = buf_end; @@ -1466,8 +1442,7 @@ load_export_section(const uint8 *buf, const uint8 *buf_end, return false; if (p != p_end) { - set_error_buf(error_buf, error_buf_size, - "invalid export section size"); + set_error_buf(error_buf, error_buf_size, "invalid export section size"); return false; } @@ -1476,7 +1451,6 @@ fail: return false; } - static void * get_data_section_addr(AOTModule *module, const char *section_name, uint32 *p_data_size) @@ -1501,8 +1475,8 @@ resolve_target_sym(const char *symbol, int32 *p_index) uint32 i, num = 0; SymbolMap *target_sym_map; - if (!(target_sym_map = get_target_symbol_map(&num))) - return NULL; + if (!(target_sym_map = get_target_symbol_map(&num))) + return NULL; for (i = 0; i < num; i++) if (!strcmp(target_sym_map[i].symbol_name, symbol)) { @@ -1567,18 +1541,18 @@ str2uint64(const char *buf, uint64 *p_res) #endif static bool -do_text_relocation(AOTModule *module, - AOTRelocationGroup *group, +do_text_relocation(AOTModule *module, AOTRelocationGroup *group, char *error_buf, uint32 error_buf_size) { bool is_literal = is_literal_relocation(group->section_name); uint8 *aot_text = is_literal ? module->literal : module->code; - uint32 aot_text_size = is_literal ? module->literal_size : module->code_size; + uint32 aot_text_size = + is_literal ? module->literal_size : module->code_size; uint32 i, func_index, symbol_len; #if defined(BH_PLATFORM_WINDOWS) uint32 xmm_plt_index = 0, real_plt_index = 0, float_plt_index = 0; #endif - char symbol_buf[128] = { 0 }, *symbol, *p; + char symbol_buf[128] = { 0 }, *symbol, *p; void *symbol_addr; AOTRelocation *relocation = group->relocations; @@ -1594,8 +1568,8 @@ do_text_relocation(AOTModule *module, if (symbol_len + 1 <= sizeof(symbol_buf)) symbol = symbol_buf; else { - if (!(symbol = loader_malloc(symbol_len + 1, - error_buf, error_buf_size))) { + if (!(symbol = loader_malloc(symbol_len + 1, error_buf, + error_buf_size))) { return false; } } @@ -1615,8 +1589,7 @@ do_text_relocation(AOTModule *module, else if (!strcmp(symbol, ".text")) { symbol_addr = module->code; } - else if (!strcmp(symbol, ".data") - || !strcmp(symbol, ".sdata") + else if (!strcmp(symbol, ".data") || !strcmp(symbol, ".sdata") || !strcmp(symbol, ".rdata") || !strcmp(symbol, ".rodata") /* ".rodata.cst4/8/16/.." */ @@ -1645,7 +1618,7 @@ do_text_relocation(AOTModule *module, symbol_addr = module->extra_plt_data + xmm_plt_index * 16; bh_memcpy_s(xmm_buf, sizeof(xmm_buf), symbol + strlen(XMM_PLT_PREFIX) + 16, 16); - if (!str2uint64(xmm_buf, (uint64*)symbol_addr)) { + if (!str2uint64(xmm_buf, (uint64 *)symbol_addr)) { set_error_buf_v(error_buf, error_buf_size, "resolve symbol %s failed", symbol); goto check_symbol_fail; @@ -1653,7 +1626,7 @@ do_text_relocation(AOTModule *module, bh_memcpy_s(xmm_buf, sizeof(xmm_buf), symbol + strlen(XMM_PLT_PREFIX), 16); - if (!str2uint64(xmm_buf, (uint64*)((uint8*)symbol_addr + 8))) { + if (!str2uint64(xmm_buf, (uint64 *)((uint8 *)symbol_addr + 8))) { set_error_buf_v(error_buf, error_buf_size, "resolve symbol %s failed", symbol); goto check_symbol_fail; @@ -1669,7 +1642,7 @@ do_text_relocation(AOTModule *module, + real_plt_index * 8; bh_memcpy_s(real_buf, sizeof(real_buf), symbol + strlen(REAL_PLT_PREFIX), 16); - if (!str2uint64(real_buf, (uint64*)symbol_addr)) { + if (!str2uint64(real_buf, (uint64 *)symbol_addr)) { set_error_buf_v(error_buf, error_buf_size, "resolve symbol %s failed", symbol); goto check_symbol_fail; @@ -1685,7 +1658,7 @@ do_text_relocation(AOTModule *module, + module->real_plt_count * 8 + float_plt_index * 4; bh_memcpy_s(float_buf, sizeof(float_buf), symbol + strlen(REAL_PLT_PREFIX), 8); - if (!str2uint32(float_buf, (uint32*)symbol_addr)) { + if (!str2uint32(float_buf, (uint32 *)symbol_addr)) { set_error_buf_v(error_buf, error_buf_size, "resolve symbol %s failed", symbol); goto check_symbol_fail; @@ -1702,13 +1675,10 @@ do_text_relocation(AOTModule *module, if (symbol != symbol_buf) wasm_runtime_free(symbol); - if (!apply_relocation(module, - aot_text, aot_text_size, - relocation->relocation_offset, - relocation->relocation_addend, - relocation->relocation_type, - symbol_addr, symbol_index, - error_buf, error_buf_size)) + if (!apply_relocation( + module, aot_text, aot_text_size, relocation->relocation_offset, + relocation->relocation_addend, relocation->relocation_type, + symbol_addr, symbol_index, error_buf, error_buf_size)) return false; } @@ -1721,8 +1691,7 @@ check_symbol_fail: } static bool -do_data_relocation(AOTModule *module, - AOTRelocationGroup *group, +do_data_relocation(AOTModule *module, AOTRelocationGroup *group, char *error_buf, uint32 error_buf_size) { @@ -1747,8 +1716,7 @@ do_data_relocation(AOTModule *module, return false; } - data_addr = get_data_section_addr(module, data_section_name, - &data_size); + data_addr = get_data_section_addr(module, data_section_name, &data_size); if (group->relocation_count > 0 && !data_addr) { set_error_buf(error_buf, error_buf_size, @@ -1767,13 +1735,10 @@ do_data_relocation(AOTModule *module, return false; } - if (!apply_relocation(module, - data_addr, data_size, - relocation->relocation_offset, - relocation->relocation_addend, - relocation->relocation_type, - symbol_addr, -1, - error_buf, error_buf_size)) + if (!apply_relocation( + module, data_addr, data_size, relocation->relocation_offset, + relocation->relocation_addend, relocation->relocation_type, + symbol_addr, -1, error_buf, error_buf_size)) return false; } @@ -1781,8 +1746,7 @@ do_data_relocation(AOTModule *module, } static bool -validate_symbol_table(uint8 *buf, uint8 *buf_end, - uint32 *offsets, uint32 count, +validate_symbol_table(uint8 *buf, uint8 *buf_end, uint32 *offsets, uint32 count, char *error_buf, uint32 error_buf_size) { uint32 i, str_len_addr = 0; @@ -1796,7 +1760,7 @@ validate_symbol_table(uint8 *buf, uint8 *buf_end, str_len_addr += (uint32)sizeof(uint16) + str_len; str_len_addr = align_uint(str_len_addr, 2); buf += str_len; - buf = (uint8*)align_ptr(buf, 2); + buf = (uint8 *)align_ptr(buf, 2); } if (buf == buf_end) @@ -1807,8 +1771,8 @@ fail: static bool load_relocation_section(const uint8 *buf, const uint8 *buf_end, - AOTModule *module, - char *error_buf, uint32 error_buf_size) + AOTModule *module, char *error_buf, + uint32 error_buf_size) { AOTRelocationGroup *groups = NULL, *group; uint32 symbol_count = 0; @@ -1831,9 +1795,8 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end, symbol_buf = (uint8 *)buf; symbol_buf_end = symbol_buf + total_string_len; - if (!validate_symbol_table(symbol_buf, symbol_buf_end, - symbol_offsets, symbol_count, - error_buf, error_buf_size)) { + if (!validate_symbol_table(symbol_buf, symbol_buf_end, symbol_offsets, + symbol_count, error_buf, error_buf_size)) { set_error_buf(error_buf, error_buf_size, "validate symbol table failed"); goto fail; @@ -1849,7 +1812,7 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end, uint8 *group_name; /* section name address is 4 bytes aligned. */ - buf = (uint8*)align_ptr(buf, sizeof(uint32)); + buf = (uint8 *)align_ptr(buf, sizeof(uint32)); read_uint32(buf, buf_end, name_index); if (name_index >= symbol_count) { @@ -1930,8 +1893,8 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end, map_flags = MMAP_MAP_32BIT; if (size > UINT32_MAX - || !(module->extra_plt_data = os_mmap(NULL, (uint32)size, - map_prot, map_flags))) { + || !(module->extra_plt_data = + os_mmap(NULL, (uint32)size, map_prot, map_flags))) { set_error_buf(error_buf, error_buf_size, "mmap memory failed"); goto fail; } @@ -1957,7 +1920,7 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end, uint8 *name_addr; /* section name address is 4 bytes aligned. */ - buf = (uint8*)align_ptr(buf, sizeof(uint32)); + buf = (uint8 *)align_ptr(buf, sizeof(uint32)); read_uint32(buf, buf_end, name_index); if (name_index >= symbol_count) { @@ -1969,10 +1932,9 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end, name_addr = symbol_buf + symbol_offsets[name_index]; str_len = *(uint16 *)name_addr; - if (!(group->section_name = - const_str_set_insert(name_addr + sizeof(uint16), - (int32)str_len, module, - error_buf, error_buf_size))) { + if (!(group->section_name = const_str_set_insert( + name_addr + sizeof(uint16), (int32)str_len, module, error_buf, + error_buf_size))) { goto fail; } @@ -1981,7 +1943,7 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end, /* Allocate memory for relocations */ size = sizeof(AOTRelocation) * (uint64)group->relocation_count; if (!(group->relocations = relocation = - loader_malloc(size, error_buf, error_buf_size))) { + loader_malloc(size, error_buf, error_buf_size))) { ret = false; goto fail; } @@ -2015,10 +1977,9 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end, symbol_addr = symbol_buf + symbol_offsets[symbol_index]; str_len = *(uint16 *)symbol_addr; - if (!(relocation->symbol_name = - const_str_set_insert(symbol_addr + sizeof(uint16), - (int32)str_len, module, - error_buf, error_buf_size))) { + if (!(relocation->symbol_name = const_str_set_insert( + symbol_addr + sizeof(uint16), (int32)str_len, module, + error_buf, error_buf_size))) { goto fail; } } @@ -2029,7 +1990,7 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end, #ifdef BH_PLATFORM_WINDOWS || !strcmp(group->section_name, ".text") #endif - ) { + ) { if (module->native_symbol_count > 0) { set_error_buf(error_buf, error_buf_size, "cannot apply relocation to text section " @@ -2052,8 +2013,8 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end, if (module->code) { /* The layout is: literal size + literal + code (with plt table) */ uint8 *mmap_addr = module->literal - sizeof(uint32); - uint32 total_size = sizeof(uint32) - + module->literal_size + module->code_size; + uint32 total_size = + sizeof(uint32) + module->literal_size + module->code_size; os_mprotect(mmap_addr, total_size, map_prot); } @@ -2092,8 +2053,8 @@ fail: } static bool -load_from_sections(AOTModule *module, AOTSection *sections, - char *error_buf, uint32 error_buf_size) +load_from_sections(AOTModule *module, AOTSection *sections, char *error_buf, + uint32 error_buf_size) { AOTSection *section = sections; const uint8 *buf, *buf_end; @@ -2112,45 +2073,44 @@ load_from_sections(AOTModule *module, AOTSection *sections, || (last_section_type != (uint32)-1 && (section_type != last_section_type + 1 && section_type != AOT_SECTION_TYPE_CUSTOM))) { - set_error_buf(error_buf, error_buf_size, - "invalid section order"); + set_error_buf(error_buf, error_buf_size, "invalid section order"); return false; } last_section_type = section_type; switch (section_type) { case AOT_SECTION_TYPE_TARGET_INFO: - if (!load_target_info_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_target_info_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case AOT_SECTION_TYPE_INIT_DATA: - if (!load_init_data_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_init_data_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case AOT_SECTION_TYPE_TEXT: - if (!load_text_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_text_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case AOT_SECTION_TYPE_FUNCTION: - if (!load_function_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_function_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case AOT_SECTION_TYPE_EXPORT: - if (!load_export_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_export_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case AOT_SECTION_TYPE_RELOCATION: - if (!load_relocation_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_relocation_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; case AOT_SECTION_TYPE_CUSTOM: - if (!load_custom_section(buf, buf_end, module, - error_buf, error_buf_size)) + if (!load_custom_section(buf, buf_end, module, error_buf, + error_buf_size)) return false; break; default: @@ -2164,8 +2124,7 @@ load_from_sections(AOTModule *module, AOTSection *sections, if (last_section_type != AOT_SECTION_TYPE_RELOCATION && last_section_type != AOT_SECTION_TYPE_CUSTOM) { - set_error_buf(error_buf, error_buf_size, - "section missing"); + set_error_buf(error_buf, error_buf_size, "section missing"); return false; } @@ -2182,8 +2141,7 @@ load_from_sections(AOTModule *module, AOTSection *sections, func_index = exports[i].index - module->import_func_count; func_type_index = module->func_type_indexes[func_index]; func_type = module->func_types[func_type_index]; - if (func_type->param_count == 1 - && func_type->result_count == 1 + if (func_type->param_count == 1 && func_type->result_count == 1 && func_type->types[0] == VALUE_TYPE_I32 && func_type->types[1] == VALUE_TYPE_I32) { bh_assert(module->malloc_func_index == (uint32)-1); @@ -2196,8 +2154,7 @@ load_from_sections(AOTModule *module, AOTSection *sections, func_index = exports[i].index - module->import_func_count; func_type_index = module->func_type_indexes[func_index]; func_type = module->func_types[func_type_index]; - if (func_type->param_count == 2 - && func_type->result_count == 1 + if (func_type->param_count == 2 && func_type->result_count == 1 && func_type->types[0] == VALUE_TYPE_I32 && func_type->types[1] == VALUE_TYPE_I32 && func_type->types[2] == VALUE_TYPE_I32) { @@ -2216,21 +2173,22 @@ load_from_sections(AOTModule *module, AOTSection *sections, if ((export_tmp->kind == EXPORT_KIND_FUNC) && (!strcmp(export_tmp->name, "__retain") || !strcmp(export_tmp->name, "__pin"))) { - func_index = export_tmp->index - - module->import_func_count; + func_index = + export_tmp->index - module->import_func_count; func_type_index = - module->func_type_indexes[func_index]; + module->func_type_indexes[func_index]; func_type = module->func_types[func_type_index]; if (func_type->param_count == 1 && func_type->result_count == 1 && func_type->types[0] == VALUE_TYPE_I32 && func_type->types[1] == VALUE_TYPE_I32) { - bh_assert( - module->retain_func_index == (uint32)-1); + bh_assert(module->retain_func_index + == (uint32)-1); module->retain_func_index = export_tmp->index; - LOG_VERBOSE( - "Found retain function, name: %s, index: %u", - export_tmp->name, export_tmp->index); + LOG_VERBOSE("Found retain function, name: %s, " + "index: %u", + export_tmp->name, + export_tmp->index); break; } } @@ -2248,8 +2206,7 @@ load_from_sections(AOTModule *module, AOTSection *sections, func_index = exports[i].index - module->import_func_count; func_type_index = module->func_type_indexes[func_index]; func_type = module->func_types[func_type_index]; - if (func_type->param_count == 1 - && func_type->result_count == 0 + if (func_type->param_count == 1 && func_type->result_count == 0 && func_type->types[0] == VALUE_TYPE_I32) { bh_assert(module->free_func_index == (uint32)-1); module->free_func_index = func_index; @@ -2265,19 +2222,20 @@ load_from_sections(AOTModule *module, AOTSection *sections, os_dcache_flush(); #if WASM_ENABLE_MEMORY_TRACING != 0 - wasm_runtime_dump_module_mem_consumption((WASMModuleCommon*)module); + wasm_runtime_dump_module_mem_consumption((WASMModuleCommon *)module); #endif #if WASM_ENABLE_DEBUG_AOT != 0 if (!jit_code_entry_create(module->elf_hdr, module->elf_size)) { - set_error_buf(error_buf, error_buf_size, "create jit code entry failed"); + set_error_buf(error_buf, error_buf_size, + "create jit code entry failed"); return false; } #endif return true; } -static AOTModule* +static AOTModule * create_module(char *error_buf, uint32 error_buf_size) { AOTModule *module = @@ -2289,12 +2247,9 @@ create_module(char *error_buf, uint32 error_buf_size) module->module_type = Wasm_Module_AoT; - if (!(module->const_str_set = - bh_hash_map_create(32, false, - (HashFunc)wasm_string_hash, - (KeyEqualFunc)wasm_string_equal, - NULL, - wasm_runtime_free))) { + if (!(module->const_str_set = bh_hash_map_create( + 32, false, (HashFunc)wasm_string_hash, + (KeyEqualFunc)wasm_string_equal, NULL, wasm_runtime_free))) { set_error_buf(error_buf, error_buf_size, "create const string set failed"); wasm_runtime_free(module); @@ -2304,17 +2259,16 @@ create_module(char *error_buf, uint32 error_buf_size) return module; } -AOTModule* -aot_load_from_sections(AOTSection *section_list, - char *error_buf, uint32 error_buf_size) +AOTModule * +aot_load_from_sections(AOTSection *section_list, char *error_buf, + uint32 error_buf_size) { AOTModule *module = create_module(error_buf, error_buf_size); if (!module) return NULL; - if (!load_from_sections(module, section_list, - error_buf, error_buf_size)) { + if (!load_from_sections(module, section_list, error_buf, error_buf_size)) { aot_unload(module); return NULL; } @@ -2329,10 +2283,10 @@ destroy_sections(AOTSection *section_list, bool destroy_aot_text) AOTSection *section = section_list, *next; while (section) { next = section->next; - if (destroy_aot_text - && section->section_type == AOT_SECTION_TYPE_TEXT + if (destroy_aot_text && section->section_type == AOT_SECTION_TYPE_TEXT && section->section_body) - os_munmap((uint8*)section->section_body, section->section_body_size); + os_munmap((uint8 *)section->section_body, + section->section_body_size); wasm_runtime_free(section); section = next; } @@ -2376,10 +2330,9 @@ fail: } static bool -create_sections(AOTModule *module, - const uint8 *buf, uint32 size, - AOTSection **p_section_list, - char *error_buf, uint32 error_buf_size) +create_sections(AOTModule *module, const uint8 *buf, uint32 size, + AOTSection **p_section_list, char *error_buf, + uint32 error_buf_size) { AOTSection *section_list = NULL, *section_list_end = NULL, *section; const uint8 *p = buf, *p_end = buf + size; @@ -2390,8 +2343,8 @@ create_sections(AOTModule *module, uint64 total_size; uint8 *aot_text; - if (!resolve_native_symbols(buf, size, &native_symbol_count, - error_buf, error_buf_size)) { + if (!resolve_native_symbols(buf, size, &native_symbol_count, error_buf, + error_buf_size)) { goto fail; } @@ -2405,30 +2358,31 @@ create_sections(AOTModule *module, read_uint32(p, p_end, section_size); CHECK_BUF(p, p_end, section_size); - if (!(section = - loader_malloc(sizeof(AOTSection), - error_buf, error_buf_size))) { + if (!(section = loader_malloc(sizeof(AOTSection), error_buf, + error_buf_size))) { goto fail; } memset(section, 0, sizeof(AOTSection)); section->section_type = (int32)section_type; - section->section_body = (uint8*)p; + section->section_body = (uint8 *)p; section->section_body_size = section_size; if (section_type == AOT_SECTION_TYPE_TEXT) { if ((section_size > 0) && (native_symbol_count == 0)) { - int map_prot = MMAP_PROT_READ | MMAP_PROT_WRITE - | MMAP_PROT_EXEC; + int map_prot = + MMAP_PROT_READ | MMAP_PROT_WRITE | MMAP_PROT_EXEC; #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \ - || defined(BUILD_TARGET_RISCV64_LP64D) || defined(BUILD_TARGET_RISCV64_LP64) - /* aot code and data in x86_64 must be in range 0 to 2G due to - relocation for R_X86_64_32/32S/PC32 */ + || defined(BUILD_TARGET_RISCV64_LP64D) \ + || defined(BUILD_TARGET_RISCV64_LP64) + /* aot code and data in x86_64 must be in range 0 to 2G due + to relocation for R_X86_64_32/32S/PC32 */ int map_flags = MMAP_MAP_32BIT; #else int map_flags = MMAP_MAP_NONE; #endif - total_size = (uint64)section_size + aot_get_plt_table_size(); + total_size = + (uint64)section_size + aot_get_plt_table_size(); total_size = (total_size + 3) & ~((uint64)3); if (total_size >= UINT32_MAX || !(aot_text = os_mmap(NULL, (uint32)total_size, @@ -2452,8 +2406,8 @@ create_sections(AOTModule *module, destory_aot_text = true; if ((uint32)total_size > section->section_body_size) { - memset(aot_text + (uint32)section_size, - 0, (uint32)total_size - section_size); + memset(aot_text + (uint32)section_size, 0, + (uint32)total_size - section_size); section->section_body_size = (uint32)total_size; } } @@ -2469,15 +2423,13 @@ create_sections(AOTModule *module, p += section_size; } else { - set_error_buf(error_buf, error_buf_size, - "invalid section id"); + set_error_buf(error_buf, error_buf_size, "invalid section id"); goto fail; } } if (!section_list) { - set_error_buf(error_buf, error_buf_size, - "create section list failed"); + set_error_buf(error_buf, error_buf_size, "create section list failed"); return false; } @@ -2490,8 +2442,8 @@ fail: } static bool -load(const uint8 *buf, uint32 size, AOTModule *module, - char *error_buf, uint32 error_buf_size) +load(const uint8 *buf, uint32 size, AOTModule *module, char *error_buf, + uint32 error_buf_size) { const uint8 *buf_end = buf + size; const uint8 *p = buf, *p_end = buf_end; @@ -2511,8 +2463,8 @@ load(const uint8 *buf, uint32 size, AOTModule *module, return false; } - if (!create_sections(module, buf, size, §ion_list, - error_buf, error_buf_size)) + if (!create_sections(module, buf, size, §ion_list, error_buf, + error_buf_size)) return false; ret = load_from_sections(module, section_list, error_buf, error_buf_size); @@ -2534,9 +2486,9 @@ fail: return false; } -AOTModule* -aot_load_from_aot_file(const uint8 *buf, uint32 size, - char *error_buf, uint32 error_buf_size) +AOTModule * +aot_load_from_aot_file(const uint8 *buf, uint32 size, char *error_buf, + uint32 error_buf_size) { AOTModule *module = create_module(error_buf, error_buf_size); @@ -2553,7 +2505,7 @@ aot_load_from_aot_file(const uint8 *buf, uint32 size, } #if WASM_ENABLE_JIT != 0 -static AOTModule* +static AOTModule * aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx, char *error_buf, uint32 error_buf_size) { @@ -2571,7 +2523,7 @@ aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx, /* Allocate memory for module */ if (!(module = - loader_malloc(sizeof(AOTModule), error_buf, error_buf_size))) { + loader_malloc(sizeof(AOTModule), error_buf, error_buf_size))) { return NULL; } @@ -2584,12 +2536,12 @@ aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx, if (module->memory_count) { size = sizeof(AOTMemory) * (uint64)module->memory_count; if (!(module->memories = - loader_malloc(size, error_buf, error_buf_size))) { + loader_malloc(size, error_buf, error_buf_size))) { goto fail1; } - bh_memcpy_s(module->memories, (uint32)size, - comp_data->memories, (uint32)size); + bh_memcpy_s(module->memories, (uint32)size, comp_data->memories, + (uint32)size); } module->mem_init_data_list = comp_data->mem_init_data_list; @@ -2627,7 +2579,7 @@ aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx, size = (uint64)module->func_count * sizeof(void *); if (size > 0 && !(module->func_ptrs = - loader_malloc(size, error_buf, error_buf_size))) { + loader_malloc(size, error_buf, error_buf_size))) { goto fail2; } @@ -2662,8 +2614,8 @@ aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx, for (i = 0; i < comp_data->func_count; i++) { snprintf(func_name, sizeof(func_name), "%s%d", AOT_FUNC_PREFIX, i); - if ((error = LLVMOrcLLLazyJITLookup(comp_ctx->lazy_orcjit, - &func_addr, func_name))) { + if ((error = LLVMOrcLLLazyJITLookup(comp_ctx->lazy_orcjit, &func_addr, + func_name))) { aot_handle_llvm_errmsg(error_buf, error_buf_size, "cannot lookup: ", error); goto fail3; @@ -2676,9 +2628,8 @@ aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx, bh_assert(comp_ctx->exec_engine); for (i = 0; i < comp_data->func_count; i++) { snprintf(func_name, sizeof(func_name), "%s%d", AOT_FUNC_PREFIX, i); - if (!(module->func_ptrs[i] = - (void *)LLVMGetFunctionAddress(comp_ctx->exec_engine, - func_name))) { + if (!(module->func_ptrs[i] = (void *)LLVMGetFunctionAddress( + comp_ctx->exec_engine, func_name))) { set_error_buf(error_buf, error_buf_size, "get function address failed"); goto fail3; @@ -2690,7 +2641,7 @@ aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx, size = (uint64)module->func_count * sizeof(uint32); if (size > 0 && !(module->func_type_indexes = - loader_malloc(size, error_buf, error_buf_size))) { + loader_malloc(size, error_buf, error_buf_size))) { goto fail3; } for (i = 0; i < comp_data->func_count; i++) @@ -2701,8 +2652,8 @@ aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx, module->start_func_index = comp_data->start_func_index; if (comp_data->start_func_index != (uint32)-1) { - bh_assert(comp_data->start_func_index < module->import_func_count - + module->func_count); + bh_assert(comp_data->start_func_index + < module->import_func_count + module->func_count); /* TODO: fix issue that start func cannot be import func */ if (comp_data->start_func_index >= module->import_func_count) { module->start_function = @@ -2754,9 +2705,9 @@ fail1: return NULL; } -AOTModule* -aot_convert_wasm_module(WASMModule *wasm_module, - char *error_buf, uint32 error_buf_size) +AOTModule * +aot_convert_wasm_module(WASMModule *wasm_module, char *error_buf, + uint32 error_buf_size) { AOTCompData *comp_data; AOTCompContext *comp_ctx; @@ -2808,8 +2759,8 @@ aot_convert_wasm_module(WASMModule *wasm_module, goto fail2; } - aot_module = aot_load_from_comp_data(comp_data, comp_ctx, - error_buf, error_buf_size); + aot_module = + aot_load_from_comp_data(comp_data, comp_ctx, error_buf, error_buf_size); if (!aot_module) { goto fail2; } @@ -2839,8 +2790,7 @@ aot_unload(AOTModule *module) #endif if (module->import_memories) - destroy_import_memories(module->import_memories, - module->is_jit_mode); + destroy_import_memories(module->import_memories, module->is_jit_mode); if (module->memories) wasm_runtime_free(module->memories); @@ -2854,8 +2804,7 @@ aot_unload(AOTModule *module) wasm_runtime_free(module->native_symbol_list); if (module->import_tables) - destroy_import_tables(module->import_tables, - module->is_jit_mode); + destroy_import_tables(module->import_tables, module->is_jit_mode); if (module->tables) destroy_tables(module->tables, module->is_jit_mode); @@ -2866,25 +2815,20 @@ aot_unload(AOTModule *module) module->is_jit_mode); if (module->func_types) - destroy_func_types(module->func_types, - module->func_type_count, + destroy_func_types(module->func_types, module->func_type_count, module->is_jit_mode); if (module->import_globals) - destroy_import_globals(module->import_globals, - module->is_jit_mode); + destroy_import_globals(module->import_globals, module->is_jit_mode); if (module->globals) - destroy_globals(module->globals, - module->is_jit_mode); + destroy_globals(module->globals, module->is_jit_mode); if (module->import_funcs) - destroy_import_funcs(module->import_funcs, - module->is_jit_mode); + destroy_import_funcs(module->import_funcs, module->is_jit_mode); if (module->exports) - destroy_exports(module->exports, - module->is_jit_mode); + destroy_exports(module->exports, module->is_jit_mode); if (module->func_type_indexes) wasm_runtime_free(module->func_type_indexes); @@ -2898,8 +2842,8 @@ aot_unload(AOTModule *module) if (module->code && (module->native_symbol_count == 0)) { /* The layout is: literal size + literal + code (with plt table) */ uint8 *mmap_addr = module->literal - sizeof(uint32); - uint32 total_size = sizeof(uint32) - + module->literal_size + module->code_size; + uint32 total_size = + sizeof(uint32) + module->literal_size + module->code_size; os_munmap(mmap_addr, total_size); } @@ -2932,4 +2876,3 @@ aot_get_plt_table_size() { return get_plt_table_size(); } - diff --git a/core/iwasm/aot/aot_reloc.h b/core/iwasm/aot/aot_reloc.h index 73c498e7..f2296ba5 100644 --- a/core/iwasm/aot/aot_reloc.h +++ b/core/iwasm/aot/aot_reloc.h @@ -3,15 +3,23 @@ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception */ +#ifndef _AOT_RELOC_H_ +#define _AOT_RELOC_H_ + #include "aot_runtime.h" #include "aot_intrinsic.h" +#ifdef __cplusplus +extern "C" { +#endif + typedef struct { const char *symbol_name; void *symbol_addr; } SymbolMap; -#define REG_SYM(symbol) { #symbol, (void*)symbol } +/* clang-format off */ +#define REG_SYM(symbol) { #symbol, (void *)symbol } #if WASM_ENABLE_BULK_MEMORY != 0 #define REG_BULK_MEMORY_SYM() \ @@ -122,10 +130,11 @@ typedef struct { REG_AOT_TRACE_SYM() \ REG_INTRINSIC_SYM() \ -#define CHECK_RELOC_OFFSET(data_size) do { \ - if (!check_reloc_offset(target_section_size, reloc_offset, data_size, \ - error_buf, error_buf_size)) \ - return false; \ +#define CHECK_RELOC_OFFSET(data_size) do { \ + if (!check_reloc_offset(target_section_size, \ + reloc_offset, data_size, \ + error_buf, error_buf_size)) \ + return false; \ } while (0) SymbolMap * @@ -146,4 +155,10 @@ apply_relocation(AOTModule *module, uint64 reloc_offset, uint64 reloc_addend, uint32 reloc_type, void *symbol_addr, int32 symbol_index, char *error_buf, uint32 error_buf_size); +/* clang-format off */ +#ifdef __cplusplus +} +#endif + +#endif /* end of _AOT_RELOC_H_ */ diff --git a/core/iwasm/aot/aot_runtime.c b/core/iwasm/aot/aot_runtime.c index 2acf04ed..28db2878 100644 --- a/core/iwasm/aot/aot_runtime.c +++ b/core/iwasm/aot/aot_runtime.c @@ -18,14 +18,13 @@ static void set_error_buf(char *error_buf, uint32 error_buf_size, const char *string) { if (error_buf != NULL) { - snprintf(error_buf, error_buf_size, - "AOT module instantiate failed: %s", string); + snprintf(error_buf, error_buf_size, "AOT module instantiate failed: %s", + string); } } static void -set_error_buf_v(char *error_buf, uint32 error_buf_size, - const char *format, ...) +set_error_buf_v(char *error_buf, uint32 error_buf_size, const char *format, ...) { va_list args; char buf[128]; @@ -34,8 +33,8 @@ set_error_buf_v(char *error_buf, uint32 error_buf_size, va_start(args, format); vsnprintf(buf, sizeof(buf), format, args); va_end(args); - snprintf(error_buf, error_buf_size, - "AOT module instantiate failed: %s", buf); + snprintf(error_buf, error_buf_size, "AOT module instantiate failed: %s", + buf); } } @@ -44,10 +43,8 @@ runtime_malloc(uint64 size, char *error_buf, uint32 error_buf_size) { void *mem; - if (size >= UINT32_MAX - || !(mem = wasm_runtime_malloc((uint32)size))) { - set_error_buf(error_buf, error_buf_size, - "allocate memory failed"); + if (size >= UINT32_MAX || !(mem = wasm_runtime_malloc((uint32)size))) { + set_error_buf(error_buf, error_buf_size, "allocate memory failed"); return NULL; } @@ -60,8 +57,8 @@ check_global_init_expr(const AOTModule *module, uint32 global_index, char *error_buf, uint32 error_buf_size) { if (global_index >= module->import_global_count + module->global_count) { - set_error_buf_v(error_buf, error_buf_size, - "unknown global %d", global_index); + set_error_buf_v(error_buf, error_buf_size, "unknown global %d", + global_index); return false; } @@ -83,8 +80,7 @@ check_global_init_expr(const AOTModule *module, uint32 global_index, } static void -init_global_data(uint8 *global_data, uint8 type, - WASMValue *initial_value) +init_global_data(uint8 *global_data, uint8 type, WASMValue *initial_value) { switch (type) { case VALUE_TYPE_I32: @@ -93,17 +89,17 @@ init_global_data(uint8 *global_data, uint8 type, case VALUE_TYPE_FUNCREF: case VALUE_TYPE_EXTERNREF: #endif - *(int32*)global_data = initial_value->i32; + *(int32 *)global_data = initial_value->i32; break; case VALUE_TYPE_I64: case VALUE_TYPE_F64: - bh_memcpy_s(global_data, sizeof(int64), - &initial_value->i64, sizeof(int64)); + bh_memcpy_s(global_data, sizeof(int64), &initial_value->i64, + sizeof(int64)); break; #if WASM_ENABLE_SIMD != 0 case VALUE_TYPE_V128: - bh_memcpy_s(global_data, sizeof(V128), - &initial_value->i64, sizeof(V128)); + bh_memcpy_s(global_data, sizeof(V128), &initial_value->i64, + sizeof(V128)); break; #endif default: @@ -117,14 +113,14 @@ global_instantiate(AOTModuleInstance *module_inst, AOTModule *module, { uint32 i; InitializerExpression *init_expr; - uint8 *p = (uint8*)module_inst->global_data.ptr; + uint8 *p = (uint8 *)module_inst->global_data.ptr; AOTImportGlobal *import_global = module->import_globals; AOTGlobal *global = module->globals; /* Initialize import global data */ for (i = 0; i < module->import_global_count; i++, import_global++) { - bh_assert(import_global->data_offset == - (uint32)(p - (uint8*)module_inst->global_data.ptr)); + bh_assert(import_global->data_offset + == (uint32)(p - (uint8 *)module_inst->global_data.ptr)); init_global_data(p, import_global->type, &import_global->global_data_linked); p += import_global->size; @@ -132,8 +128,8 @@ global_instantiate(AOTModuleInstance *module_inst, AOTModule *module, /* Initialize defined global data */ for (i = 0; i < module->global_count; i++, global++) { - bh_assert(global->data_offset == - (uint32)(p - (uint8*)module_inst->global_data.ptr)); + bh_assert(global->data_offset + == (uint32)(p - (uint8 *)module_inst->global_data.ptr)); init_expr = &global->init_expr; switch (init_expr->init_expr_type) { case INIT_EXPR_TYPE_GET_GLOBAL: @@ -142,9 +138,10 @@ global_instantiate(AOTModuleInstance *module_inst, AOTModule *module, error_buf, error_buf_size)) { return false; } - init_global_data(p, global->type, - &module->import_globals[init_expr->u.global_index] - .global_data_linked); + init_global_data( + p, global->type, + &module->import_globals[init_expr->u.global_index] + .global_data_linked); break; } #if WASM_ENABLE_REF_TYPES != 0 @@ -163,8 +160,8 @@ global_instantiate(AOTModuleInstance *module_inst, AOTModule *module, p += global->size; } - bh_assert(module_inst->global_data_size == - (uint32)(p - (uint8*)module_inst->global_data.ptr)); + bh_assert(module_inst->global_data_size + == (uint32)(p - (uint8 *)module_inst->global_data.ptr)); return true; } @@ -180,7 +177,7 @@ static inline AOTTableInstance * aot_get_table_inst(const AOTModuleInstance *module_inst, uint32 tbl_idx) { uint32 i = 0; - AOTTableInstance *tbl_inst = (AOTTableInstance*)module_inst->tables.ptr; + AOTTableInstance *tbl_inst = (AOTTableInstance *)module_inst->tables.ptr; while (i != tbl_idx) { tbl_inst = aot_next_tbl_inst(tbl_inst); @@ -196,7 +193,7 @@ table_instantiate(AOTModuleInstance *module_inst, AOTModule *module, { uint32 i, global_index, global_data_offset, base_offset, length; AOTTableInitData *table_seg; - AOTTableInstance *tbl_inst = (AOTTableInstance*)module_inst->tables.ptr; + AOTTableInstance *tbl_inst = (AOTTableInstance *)module_inst->tables.ptr; /* * treat import table like a local one until we enable module linking @@ -209,8 +206,7 @@ table_instantiate(AOTModuleInstance *module_inst, AOTModule *module, tbl_inst->max_size = aot_get_imp_tbl_data_slots(import_table); } else { - AOTTable *table = - module->tables + (i - module->import_table_count); + AOTTable *table = module->tables + (i - module->import_table_count); tbl_inst->cur_size = table->table_init_size; tbl_inst->max_size = aot_get_tbl_data_slots(table); } @@ -235,34 +231,30 @@ table_instantiate(AOTModuleInstance *module_inst, AOTModule *module, bh_assert(tbl_inst); bh_assert( - table_seg->offset.init_expr_type == INIT_EXPR_TYPE_I32_CONST - || table_seg->offset.init_expr_type == INIT_EXPR_TYPE_GET_GLOBAL + table_seg->offset.init_expr_type == INIT_EXPR_TYPE_I32_CONST + || table_seg->offset.init_expr_type == INIT_EXPR_TYPE_GET_GLOBAL #if WASM_ENABLE_REF_TYPES != 0 - || table_seg->offset.init_expr_type - == INIT_EXPR_TYPE_FUNCREF_CONST - || table_seg->offset.init_expr_type - == INIT_EXPR_TYPE_REFNULL_CONST + || table_seg->offset.init_expr_type == INIT_EXPR_TYPE_FUNCREF_CONST + || table_seg->offset.init_expr_type == INIT_EXPR_TYPE_REFNULL_CONST #endif ); /* Resolve table data base offset */ - if (table_seg->offset.init_expr_type - == INIT_EXPR_TYPE_GET_GLOBAL) { + if (table_seg->offset.init_expr_type == INIT_EXPR_TYPE_GET_GLOBAL) { global_index = table_seg->offset.u.global_index; - if (!check_global_init_expr(module, global_index, - error_buf, error_buf_size)) { + if (!check_global_init_expr(module, global_index, error_buf, + error_buf_size)) { return false; } if (global_index < module->import_global_count) global_data_offset = - module->import_globals[global_index].data_offset; + module->import_globals[global_index].data_offset; else global_data_offset = - module - ->globals[global_index - module->import_global_count] - .data_offset; + module->globals[global_index - module->import_global_count] + .data_offset; base_offset = *(uint32 *)((uint8 *)module_inst->global_data.ptr + global_data_offset); @@ -319,9 +311,8 @@ memories_deinstantiate(AOTModuleInstance *module_inst) if (memory_inst) { #if WASM_ENABLE_SHARED_MEMORY != 0 if (memory_inst->is_shared) { - int32 ref_count = - shared_memory_dec_reference( - (WASMModuleCommon *)module_inst->aot_module.ptr); + int32 ref_count = shared_memory_dec_reference( + (WASMModuleCommon *)module_inst->aot_module.ptr); bh_assert(ref_count >= 0); /* if the reference count is not zero, @@ -342,9 +333,9 @@ memories_deinstantiate(AOTModuleInstance *module_inst) #ifdef BH_PLATFORM_WINDOWS os_mem_decommit(memory_inst->memory_data.ptr, memory_inst->num_bytes_per_page - * memory_inst->cur_page_count); + * memory_inst->cur_page_count); #endif - os_munmap((uint8*)memory_inst->memory_data.ptr, + os_munmap((uint8 *)memory_inst->memory_data.ptr, 8 * (uint64)BH_GB); #endif } @@ -353,7 +344,7 @@ memories_deinstantiate(AOTModuleInstance *module_inst) wasm_runtime_free(module_inst->memories.ptr); } -static AOTMemoryInstance* +static AOTMemoryInstance * memory_instantiate(AOTModuleInstance *module_inst, AOTModule *module, AOTMemoryInstance *memory_inst, AOTMemory *memory, uint32 heap_size, char *error_buf, uint32 error_buf_size) @@ -364,7 +355,7 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModule *module, uint32 max_page_count = memory->mem_max_page_count; uint32 inc_page_count, aux_heap_base, global_idx; uint32 bytes_of_last_page, bytes_to_page_end; - uint32 heap_offset = num_bytes_per_page *init_page_count; + uint32 heap_offset = num_bytes_per_page * init_page_count; uint64 total_size; uint8 *p = NULL, *global_addr; #ifdef OS_ENABLE_HW_BOUND_CHECK @@ -385,11 +376,10 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModule *module, return the memory instance directly */ if (node) { uint32 ref_count; - ref_count = shared_memory_inc_reference( - (WASMModuleCommon *)module); + ref_count = shared_memory_inc_reference((WASMModuleCommon *)module); bh_assert(ref_count > 0); shared_memory_instance = - (AOTMemoryInstance *)shared_memory_get_memory_inst(node); + (AOTMemoryInstance *)shared_memory_get_memory_inst(node); bh_assert(shared_memory_instance); (void)ref_count; @@ -398,8 +388,7 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModule *module, } #endif - if (heap_size > 0 - && module->malloc_func_index != (uint32)-1 + if (heap_size > 0 && module->malloc_func_index != (uint32)-1 && module->free_func_index != (uint32)-1) { /* Disable app heap, use malloc/free function exported by wasm app to allocate/free memory instead */ @@ -420,16 +409,16 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModule *module, } else if (heap_size > 0) { if (module->aux_heap_base_global_index != (uint32)-1 - && module->aux_heap_base < num_bytes_per_page - * init_page_count) { + && module->aux_heap_base < num_bytes_per_page * init_page_count) { /* Insert app heap before __heap_base */ aux_heap_base = module->aux_heap_base; bytes_of_last_page = aux_heap_base % num_bytes_per_page; if (bytes_of_last_page == 0) bytes_of_last_page = num_bytes_per_page; bytes_to_page_end = num_bytes_per_page - bytes_of_last_page; - inc_page_count = (heap_size - bytes_to_page_end - + num_bytes_per_page - 1) / num_bytes_per_page; + inc_page_count = + (heap_size - bytes_to_page_end + num_bytes_per_page - 1) + / num_bytes_per_page; heap_offset = aux_heap_base; aux_heap_base += heap_size; @@ -445,15 +434,15 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModule *module, /* Adjust __heap_base global value */ global_idx = module->aux_heap_base_global_index - module->import_global_count; - global_addr = (uint8*)module_inst->global_data.ptr + - module->globals[global_idx].data_offset; + global_addr = (uint8 *)module_inst->global_data.ptr + + module->globals[global_idx].data_offset; *(uint32 *)global_addr = aux_heap_base; LOG_VERBOSE("Reset __heap_base global to %u", aux_heap_base); } else { /* Insert app heap before new page */ - inc_page_count = (heap_size + num_bytes_per_page - 1) - / num_bytes_per_page; + inc_page_count = + (heap_size + num_bytes_per_page - 1) / num_bytes_per_page; heap_offset = num_bytes_per_page * init_page_count; heap_size = num_bytes_per_page * inc_page_count; if (heap_size > 0) @@ -498,8 +487,8 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModule *module, * so the range of ea is 0 to 8G */ if (total_size >= UINT32_MAX - || !(p = mapped_mem = os_mmap(NULL, map_size, - MMAP_PROT_NONE, MMAP_MAP_NONE))) { + || !(p = mapped_mem = + os_mmap(NULL, map_size, MMAP_PROT_NONE, MMAP_MAP_NONE))) { set_error_buf(error_buf, error_buf_size, "mmap memory failed"); return NULL; } @@ -539,46 +528,46 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModule *module, if (heap_size > 0) { uint32 heap_struct_size = mem_allocator_get_heap_struct_size(); - if (!(heap_handle = runtime_malloc((uint64)heap_struct_size, - error_buf, error_buf_size))) { + if (!(heap_handle = runtime_malloc((uint64)heap_struct_size, error_buf, + error_buf_size))) { goto fail1; } memory_inst->heap_handle.ptr = heap_handle; - if (!mem_allocator_create_with_struct_and_pool - (heap_handle, heap_struct_size, - memory_inst->heap_data.ptr, heap_size)) { - set_error_buf(error_buf, error_buf_size, - "init app heap failed"); + if (!mem_allocator_create_with_struct_and_pool( + heap_handle, heap_struct_size, memory_inst->heap_data.ptr, + heap_size)) { + set_error_buf(error_buf, error_buf_size, "init app heap failed"); goto fail2; } } if (total_size > 0) { - if (sizeof(uintptr_t) == sizeof(uint64)) { - memory_inst->mem_bound_check_1byte.u64 = total_size - 1; - memory_inst->mem_bound_check_2bytes.u64 = total_size - 2; - memory_inst->mem_bound_check_4bytes.u64 = total_size - 4; - memory_inst->mem_bound_check_8bytes.u64 = total_size - 8; - memory_inst->mem_bound_check_16bytes.u64 = total_size - 16; - } - else { - memory_inst->mem_bound_check_1byte.u32[0] = (uint32)total_size - 1; - memory_inst->mem_bound_check_2bytes.u32[0] = (uint32)total_size - 2; - memory_inst->mem_bound_check_4bytes.u32[0] = (uint32)total_size - 4; - memory_inst->mem_bound_check_8bytes.u32[0] = (uint32)total_size - 8; - memory_inst->mem_bound_check_16bytes.u32[0] = (uint32)total_size - 16; - } + if (sizeof(uintptr_t) == sizeof(uint64)) { + memory_inst->mem_bound_check_1byte.u64 = total_size - 1; + memory_inst->mem_bound_check_2bytes.u64 = total_size - 2; + memory_inst->mem_bound_check_4bytes.u64 = total_size - 4; + memory_inst->mem_bound_check_8bytes.u64 = total_size - 8; + memory_inst->mem_bound_check_16bytes.u64 = total_size - 16; + } + else { + memory_inst->mem_bound_check_1byte.u32[0] = (uint32)total_size - 1; + memory_inst->mem_bound_check_2bytes.u32[0] = (uint32)total_size - 2; + memory_inst->mem_bound_check_4bytes.u32[0] = (uint32)total_size - 4; + memory_inst->mem_bound_check_8bytes.u32[0] = (uint32)total_size - 8; + memory_inst->mem_bound_check_16bytes.u32[0] = + (uint32)total_size - 16; + } } #if WASM_ENABLE_SHARED_MEMORY != 0 if (is_shared_memory) { memory_inst->is_shared = true; - if (!shared_memory_set_memory_inst((WASMModuleCommon *)module, - (WASMMemoryInstanceCommon *)memory_inst)) { - set_error_buf(error_buf, error_buf_size, - "allocate memory failed"); + if (!shared_memory_set_memory_inst( + (WASMModuleCommon *)module, + (WASMMemoryInstanceCommon *)memory_inst)) { + set_error_buf(error_buf, error_buf_size, "allocate memory failed"); goto fail3; } } @@ -609,7 +598,7 @@ fail1: return NULL; } -static AOTMemoryInstance* +static AOTMemoryInstance * aot_get_default_memory(AOTModuleInstance *module_inst) { if (module_inst->memories.ptr) @@ -631,16 +620,15 @@ memories_instantiate(AOTModuleInstance *module_inst, AOTModule *module, module_inst->memory_count = memory_count; total_size = sizeof(AOTPointer) * (uint64)memory_count; if (!(module_inst->memories.ptr = - runtime_malloc(total_size, error_buf, error_buf_size))) { + runtime_malloc(total_size, error_buf, error_buf_size))) { return false; } memories = module_inst->global_table_data.memory_instances; for (i = 0; i < memory_count; i++, memories++) { - memory_inst = - memory_instantiate(module_inst, module, - memories, &module->memories[i], - heap_size, error_buf, error_buf_size); + memory_inst = memory_instantiate(module_inst, module, memories, + &module->memories[i], heap_size, + error_buf, error_buf_size); if (!memory_inst) { return false; } @@ -658,17 +646,16 @@ memories_instantiate(AOTModuleInstance *module_inst, AOTModule *module, continue; #endif - bh_assert(data_seg->offset.init_expr_type == - INIT_EXPR_TYPE_I32_CONST - || data_seg->offset.init_expr_type == - INIT_EXPR_TYPE_GET_GLOBAL); + bh_assert(data_seg->offset.init_expr_type == INIT_EXPR_TYPE_I32_CONST + || data_seg->offset.init_expr_type + == INIT_EXPR_TYPE_GET_GLOBAL); /* Resolve memory data base offset */ if (data_seg->offset.init_expr_type == INIT_EXPR_TYPE_GET_GLOBAL) { global_index = data_seg->offset.u.global_index; - if (!check_global_init_expr(module, global_index, - error_buf, error_buf_size)) { + if (!check_global_init_expr(module, global_index, error_buf, + error_buf_size)) { return false; } @@ -678,10 +665,10 @@ memories_instantiate(AOTModuleInstance *module_inst, AOTModule *module, else global_data_offset = module->globals[global_index - module->import_global_count] - .data_offset; + .data_offset; - base_offset = *(uint32*) - ((uint8*)module_inst->global_data.ptr + global_data_offset); + base_offset = *(uint32 *)((uint8 *)module_inst->global_data.ptr + + global_data_offset); } else { base_offset = (uint32)data_seg->offset.u.i32; @@ -722,7 +709,7 @@ memories_instantiate(AOTModuleInstance *module_inst, AOTModule *module, } if (memory_inst->memory_data.ptr) { - bh_memcpy_s((uint8*)memory_inst->memory_data.ptr + base_offset, + bh_memcpy_s((uint8 *)memory_inst->memory_data.ptr + base_offset, memory_inst->memory_data_size - base_offset, data_seg->bytes, length); } @@ -737,22 +724,22 @@ init_func_ptrs(AOTModuleInstance *module_inst, AOTModule *module, { uint32 i; void **func_ptrs; - uint64 total_size = - ((uint64)module->import_func_count + module->func_count) * sizeof(void*); + uint64 total_size = ((uint64)module->import_func_count + module->func_count) + * sizeof(void *); if (module->import_func_count + module->func_count == 0) return true; /* Allocate memory */ - if (!(module_inst->func_ptrs.ptr = runtime_malloc - (total_size, error_buf, error_buf_size))) { + if (!(module_inst->func_ptrs.ptr = + runtime_malloc(total_size, error_buf, error_buf_size))) { return false; } /* Set import function pointers */ - func_ptrs = (void**)module_inst->func_ptrs.ptr; + func_ptrs = (void **)module_inst->func_ptrs.ptr; for (i = 0; i < module->import_func_count; i++, func_ptrs++) { - *func_ptrs = (void*)module->import_funcs[i].func_ptr_linked; + *func_ptrs = (void *)module->import_funcs[i].func_ptr_linked; if (!*func_ptrs) { const char *module_name = module->import_funcs[i].module_name; const char *field_name = module->import_funcs[i].func_name; @@ -762,8 +749,8 @@ init_func_ptrs(AOTModuleInstance *module_inst, AOTModule *module, } /* Set defined function pointers */ - bh_memcpy_s(func_ptrs, sizeof(void*) * module->func_count, - module->func_ptrs, sizeof(void*) * module->func_count); + bh_memcpy_s(func_ptrs, sizeof(void *) * module->func_count, + module->func_ptrs, sizeof(void *) * module->func_count); return true; } @@ -773,20 +760,20 @@ init_func_type_indexes(AOTModuleInstance *module_inst, AOTModule *module, { uint32 i; uint32 *func_type_index; - uint64 total_size = - ((uint64)module->import_func_count + module->func_count) * sizeof(uint32); + uint64 total_size = ((uint64)module->import_func_count + module->func_count) + * sizeof(uint32); if (module->import_func_count + module->func_count == 0) return true; /* Allocate memory */ if (!(module_inst->func_type_indexes.ptr = - runtime_malloc(total_size, error_buf, error_buf_size))) { + runtime_malloc(total_size, error_buf, error_buf_size))) { return false; } /* Set import function type indexes */ - func_type_index = (uint32*)module_inst->func_type_indexes.ptr; + func_type_index = (uint32 *)module_inst->func_type_indexes.ptr; for (i = 0; i < module->import_func_count; i++, func_type_index++) *func_type_index = module->import_funcs[i].func_type_index; @@ -809,7 +796,7 @@ create_export_funcs(AOTModuleInstance *module_inst, AOTModule *module, size = sizeof(AOTFunctionInstance) * (uint64)module_inst->export_func_count; if (!(module_inst->export_funcs.ptr = export_func = - runtime_malloc(size, error_buf, error_buf_size))) { + runtime_malloc(size, error_buf, error_buf_size))) { return false; } @@ -824,13 +811,13 @@ create_export_funcs(AOTModuleInstance *module_inst, AOTModule *module, } else { export_func->is_import_func = false; - func_index = export_func->func_index - - module->import_func_count; + func_index = + export_func->func_index - module->import_func_count; ftype_index = module->func_type_indexes[func_index]; export_func->u.func.func_type = - module->func_types[ftype_index]; + module->func_types[ftype_index]; export_func->u.func.func_ptr = - module->func_ptrs[func_index]; + module->func_ptrs[func_index]; } export_func++; } @@ -866,8 +853,7 @@ create_exports(AOTModuleInstance *module_inst, AOTModule *module, } } - return create_export_funcs(module_inst, module, - error_buf, error_buf_size); + return create_export_funcs(module_inst, module, error_buf, error_buf_size); } static bool @@ -898,22 +884,27 @@ execute_post_inst_function(AOTModuleInstance *module_inst) /* Not found */ return true; - return aot_create_exec_env_and_call_function(module_inst, post_inst_func, 0, NULL); + return aot_create_exec_env_and_call_function(module_inst, post_inst_func, 0, + NULL); } static bool execute_start_function(AOTModuleInstance *module_inst) { - AOTModule *module = (AOTModule*)module_inst->aot_module.ptr; + AOTModule *module = (AOTModule *)module_inst->aot_module.ptr; WASMExecEnv *exec_env; - typedef void (*F)(WASMExecEnv*); - union { F f; void *v; } u; + typedef void (*F)(WASMExecEnv *); + union { + F f; + void *v; + } u; if (!module->start_function) return true; - if (!(exec_env = wasm_exec_env_create((WASMModuleInstanceCommon*)module_inst, - module_inst->default_wasm_stack_size))) { + if (!(exec_env = + wasm_exec_env_create((WASMModuleInstanceCommon *)module_inst, + module_inst->default_wasm_stack_size))) { aot_set_exception(module_inst, "allocate memory failed"); return false; } @@ -942,10 +933,9 @@ execute_memory_init_function(AOTModuleInstance *module_inst) } #endif -AOTModuleInstance* -aot_instantiate(AOTModule *module, bool is_sub_inst, - uint32 stack_size, uint32 heap_size, - char *error_buf, uint32 error_buf_size) +AOTModuleInstance * +aot_instantiate(AOTModule *module, bool is_sub_inst, uint32 stack_size, + uint32 heap_size, char *error_buf, uint32 error_buf_size) { AOTModuleInstance *module_inst; const uint32 module_inst_struct_size = @@ -970,8 +960,8 @@ aot_instantiate(AOTModule *module, bool is_sub_inst, for (i = 0; i != module->import_table_count; ++i) { table_size += offsetof(AOTTableInstance, data); table_size += - (uint64)sizeof(uint32) - * (uint64)aot_get_imp_tbl_data_slots(module->import_tables + i); + (uint64)sizeof(uint32) + * (uint64)aot_get_imp_tbl_data_slots(module->import_tables + i); } for (i = 0; i != module->table_count; ++i) { @@ -982,8 +972,8 @@ aot_instantiate(AOTModule *module, bool is_sub_inst, total_size += table_size; /* Allocate module instance, global data, table data and heap data */ - if (!(module_inst = runtime_malloc(total_size, - error_buf, error_buf_size))) { + if (!(module_inst = + runtime_malloc(total_size, error_buf, error_buf_size))) { return NULL; } @@ -991,8 +981,8 @@ aot_instantiate(AOTModule *module, bool is_sub_inst, module_inst->aot_module.ptr = module; /* Initialize global info */ - p = (uint8*)module_inst + module_inst_struct_size + - module_inst_mem_inst_size; + p = (uint8 *)module_inst + module_inst_struct_size + + module_inst_mem_inst_size; module_inst->global_data.ptr = p; module_inst->global_data_size = module->global_data_size; if (!global_instantiate(module_inst, module, error_buf, error_buf_size)) @@ -1001,16 +991,15 @@ aot_instantiate(AOTModule *module, bool is_sub_inst, /* Initialize table info */ p += module->global_data_size; module_inst->tables.ptr = p; - module_inst->table_count = - module->table_count + module->import_table_count; + module_inst->table_count = module->table_count + module->import_table_count; /* Set all elements to -1 to mark them as uninitialized elements */ memset(module_inst->tables.ptr, 0xff, (uint32)table_size); if (!table_instantiate(module_inst, module, error_buf, error_buf_size)) goto fail; /* Initialize memory space */ - if (!memories_instantiate(module_inst, module, heap_size, - error_buf, error_buf_size)) + if (!memories_instantiate(module_inst, module, heap_size, error_buf, + error_buf_size)) goto fail; /* Initialize function pointers */ @@ -1026,19 +1015,14 @@ aot_instantiate(AOTModule *module, bool is_sub_inst, #if WASM_ENABLE_LIBC_WASI != 0 if (!is_sub_inst) { - if (!wasm_runtime_init_wasi((WASMModuleInstanceCommon*)module_inst, - module->wasi_args.dir_list, - module->wasi_args.dir_count, - module->wasi_args.map_dir_list, - module->wasi_args.map_dir_count, - module->wasi_args.env, - module->wasi_args.env_count, - module->wasi_args.argv, - module->wasi_args.argc, - module->wasi_args.stdio[0], - module->wasi_args.stdio[1], - module->wasi_args.stdio[2], - error_buf, error_buf_size)) + if (!wasm_runtime_init_wasi( + (WASMModuleInstanceCommon *)module_inst, + module->wasi_args.dir_list, module->wasi_args.dir_count, + module->wasi_args.map_dir_list, module->wasi_args.map_dir_count, + module->wasi_args.env, module->wasi_args.env_count, + module->wasi_args.argv, module->wasi_args.argc, + module->wasi_args.stdio[0], module->wasi_args.stdio[1], + module->wasi_args.stdio[2], error_buf, error_buf_size)) goto fail; } #endif @@ -1047,23 +1031,23 @@ aot_instantiate(AOTModule *module, bool is_sub_inst, if (stack_size == 0) stack_size = DEFAULT_WASM_STACK_SIZE; #if WASM_ENABLE_SPEC_TEST != 0 - if (stack_size < 48 *1024) + if (stack_size < 48 * 1024) stack_size = 48 * 1024; #endif module_inst->default_wasm_stack_size = stack_size; #if WASM_ENABLE_PERF_PROFILING != 0 - total_size = (uint64)sizeof(AOTFuncPerfProfInfo) * - (module->import_func_count + module->func_count); + total_size = (uint64)sizeof(AOTFuncPerfProfInfo) + * (module->import_func_count + module->func_count); if (!(module_inst->func_perf_profilings.ptr = - runtime_malloc(total_size, error_buf, error_buf_size))) { + runtime_malloc(total_size, error_buf, error_buf_size))) { goto fail; } #endif #if WASM_ENABLE_DUMP_CALL_STACK != 0 if (!(module_inst->frames.ptr = - runtime_malloc(sizeof(Vector), error_buf, error_buf_size))) { + runtime_malloc(sizeof(Vector), error_buf, error_buf_size))) { goto fail; } #endif @@ -1071,8 +1055,7 @@ aot_instantiate(AOTModule *module, bool is_sub_inst, /* Execute __post_instantiate function and start function*/ if (!execute_post_inst_function(module_inst) || !execute_start_function(module_inst)) { - set_error_buf(error_buf, error_buf_size, - module_inst->cur_exception); + set_error_buf(error_buf, error_buf_size, module_inst->cur_exception); goto fail; } @@ -1096,8 +1079,8 @@ aot_instantiate(AOTModule *module, bool is_sub_inst, #endif #if WASM_ENABLE_MEMORY_TRACING != 0 - wasm_runtime_dump_module_inst_mem_consumption - ((WASMModuleInstanceCommon *)module_inst); + wasm_runtime_dump_module_inst_mem_consumption( + (WASMModuleInstanceCommon *)module_inst); #endif return module_inst; @@ -1129,7 +1112,7 @@ aot_deinstantiate(AOTModuleInstance *module_inst, bool is_sub_inst) which may allocated from global heap. */ /* Only destroy wasi ctx in the main module instance */ if (!is_sub_inst) - wasm_runtime_destroy_wasi((WASMModuleInstanceCommon*)module_inst); + wasm_runtime_destroy_wasi((WASMModuleInstanceCommon *)module_inst); #endif #if WASM_ENABLE_PERF_PROFILING != 0 @@ -1158,19 +1141,19 @@ aot_deinstantiate(AOTModuleInstance *module_inst, bool is_sub_inst) wasm_runtime_free(module_inst->func_type_indexes.ptr); if (module_inst->exec_env_singleton.ptr) - wasm_exec_env_destroy((WASMExecEnv *) - module_inst->exec_env_singleton.ptr); + wasm_exec_env_destroy( + (WASMExecEnv *)module_inst->exec_env_singleton.ptr); wasm_runtime_free(module_inst); } -AOTFunctionInstance* -aot_lookup_function(const AOTModuleInstance *module_inst, - const char *name, const char *signature) +AOTFunctionInstance * +aot_lookup_function(const AOTModuleInstance *module_inst, const char *name, + const char *signature) { uint32 i; - AOTFunctionInstance *export_funcs = (AOTFunctionInstance *) - module_inst->export_funcs.ptr; + AOTFunctionInstance *export_funcs = + (AOTFunctionInstance *)module_inst->export_funcs.ptr; for (i = 0; i < module_inst->export_func_count; i++) if (!strcmp(export_funcs[i].func_name, name)) @@ -1197,17 +1180,16 @@ aot_signal_handler(void *sig_addr) uint32 guard_page_count = STACK_OVERFLOW_CHECK_GUARD_PAGE_COUNT; /* Check whether current thread is running aot function */ - if (aot_exec_env - && aot_exec_env->handle == os_self_thread() + if (aot_exec_env && aot_exec_env->handle == os_self_thread() && (jmpbuf_node = aot_exec_env->jmpbuf_stack_top)) { /* Get mapped mem info of current instance */ module_inst = (AOTModuleInstance *)aot_exec_env->module_inst; /* Get the default memory instance */ memory_inst = aot_get_default_memory(module_inst); if (memory_inst) { - mapped_mem_start_addr = (uint8*)memory_inst->memory_data.ptr; - mapped_mem_end_addr = (uint8*)memory_inst->memory_data.ptr - + 8 * (uint64)BH_GB; + mapped_mem_start_addr = (uint8 *)memory_inst->memory_data.ptr; + mapped_mem_end_addr = + (uint8 *)memory_inst->memory_data.ptr + 8 * (uint64)BH_GB; } /* Get stack info of current thread */ @@ -1215,16 +1197,17 @@ aot_signal_handler(void *sig_addr) stack_min_addr = os_thread_get_stack_boundary(); if (memory_inst - && (mapped_mem_start_addr <= (uint8*)sig_addr - && (uint8*)sig_addr < mapped_mem_end_addr)) { + && (mapped_mem_start_addr <= (uint8 *)sig_addr + && (uint8 *)sig_addr < mapped_mem_end_addr)) { /* The address which causes segmentation fault is inside aot instance's guard regions */ - aot_set_exception_with_id(module_inst, EXCE_OUT_OF_BOUNDS_MEMORY_ACCESS); + aot_set_exception_with_id(module_inst, + EXCE_OUT_OF_BOUNDS_MEMORY_ACCESS); os_longjmp(jmpbuf_node->jmpbuf, 1); } - else if (stack_min_addr - page_size <= (uint8*)sig_addr - && (uint8*)sig_addr < stack_min_addr - + page_size * guard_page_count) { + else if (stack_min_addr - page_size <= (uint8 *)sig_addr + && (uint8 *)sig_addr + < stack_min_addr + page_size * guard_page_count) { /* The address which causes segmentation fault is inside native thread's guard page */ aot_set_exception_with_id(module_inst, EXCE_NATIVE_STACK_OVERFLOW); @@ -1232,12 +1215,12 @@ aot_signal_handler(void *sig_addr) } } } -#else /* else of BH_PLATFORM_WINDOWS */ +#else /* else of BH_PLATFORM_WINDOWS */ static LONG aot_exception_handler(EXCEPTION_POINTERS *exce_info) { PEXCEPTION_RECORD ExceptionRecord = exce_info->ExceptionRecord; - uint8 *sig_addr = (uint8*)ExceptionRecord->ExceptionInformation[1]; + uint8 *sig_addr = (uint8 *)ExceptionRecord->ExceptionInformation[1]; AOTModuleInstance *module_inst; AOTMemoryInstance *memory_inst; WASMJmpBuf *jmpbuf_node; @@ -1245,19 +1228,18 @@ aot_exception_handler(EXCEPTION_POINTERS *exce_info) uint8 *mapped_mem_end_addr = NULL; uint32 page_size = os_getpagesize(); - if (aot_exec_env - && aot_exec_env->handle == os_self_thread() + if (aot_exec_env && aot_exec_env->handle == os_self_thread() && (jmpbuf_node = aot_exec_env->jmpbuf_stack_top)) { - module_inst = (AOTModuleInstance*)aot_exec_env->module_inst; + module_inst = (AOTModuleInstance *)aot_exec_env->module_inst; if (ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION) { /* Get the default memory instance */ memory_inst = aot_get_default_memory(module_inst); if (memory_inst) { - mapped_mem_start_addr = (uint8*)memory_inst->memory_data.ptr; - mapped_mem_end_addr = (uint8*)memory_inst->memory_data.ptr - + 8 * (uint64)BH_GB; - if (mapped_mem_start_addr <= (uint8*)sig_addr - && (uint8*)sig_addr < mapped_mem_end_addr) { + mapped_mem_start_addr = (uint8 *)memory_inst->memory_data.ptr; + mapped_mem_end_addr = + (uint8 *)memory_inst->memory_data.ptr + 8 * (uint64)BH_GB; + if (mapped_mem_start_addr <= (uint8 *)sig_addr + && (uint8 *)sig_addr < mapped_mem_end_addr) { /* The address which causes segmentation fault is inside aot instance's guard regions. Set exception and let the aot func continue to run, when @@ -1312,11 +1294,11 @@ aot_signal_destroy() static bool invoke_native_with_hw_bound_check(WASMExecEnv *exec_env, void *func_ptr, - const WASMType *func_type, const char *signature, - void *attachment, - uint32 *argv, uint32 argc, uint32 *argv_ret) + const WASMType *func_type, + const char *signature, void *attachment, + uint32 *argv, uint32 argc, uint32 *argv_ret) { - AOTModuleInstance *module_inst = (AOTModuleInstance*)exec_env->module_inst; + AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst; WASMExecEnv **p_aot_exec_env = &aot_exec_env; WASMJmpBuf jmpbuf_node = { 0 }, *jmpbuf_node_pop; uint32 page_size = os_getpagesize(); @@ -1333,8 +1315,8 @@ invoke_native_with_hw_bound_check(WASMExecEnv *exec_env, void *func_ptr, /* Check native stack overflow firstly to ensure we have enough native stack to run the following codes before actually calling the aot function in invokeNative function. */ - if ((uint8*)&module_inst < exec_env->native_stack_boundary - + page_size * (guard_page_count + 1)) { + if ((uint8 *)&module_inst < exec_env->native_stack_boundary + + page_size * (guard_page_count + 1)) { aot_set_exception_with_id(module_inst, EXCE_NATIVE_STACK_OVERFLOW); return false; } @@ -1356,27 +1338,28 @@ invoke_native_with_hw_bound_check(WASMExecEnv *exec_env, void *func_ptr, /* Quick call with func_ptr if the function signature is simple */ if (!signature && param_count == 1 && types[0] == VALUE_TYPE_I32) { if (result_count == 0) { - void (*NativeFunc)(WASMExecEnv*, uint32) = - (void (*)(WASMExecEnv*, uint32))func_ptr; + void (*NativeFunc)(WASMExecEnv *, uint32) = + (void (*)(WASMExecEnv *, uint32))func_ptr; NativeFunc(exec_env, argv[0]); ret = aot_get_exception(module_inst) ? false : true; } - else if (result_count == 1 && types[param_count] == VALUE_TYPE_I32) { - uint32 (*NativeFunc)(WASMExecEnv*, uint32) = - (uint32 (*)(WASMExecEnv*, uint32))func_ptr; + else if (result_count == 1 + && types[param_count] == VALUE_TYPE_I32) { + uint32 (*NativeFunc)(WASMExecEnv *, uint32) = + (uint32(*)(WASMExecEnv *, uint32))func_ptr; argv_ret[0] = NativeFunc(exec_env, argv[0]); ret = aot_get_exception(module_inst) ? false : true; } else { ret = wasm_runtime_invoke_native(exec_env, func_ptr, func_type, - signature, attachment, - argv, argc, argv_ret); + signature, attachment, argv, + argc, argv_ret); } } else { ret = wasm_runtime_invoke_native(exec_env, func_ptr, func_type, - signature, attachment, - argv, argc, argv_ret); + signature, attachment, argv, argc, + argv_ret); } #ifdef BH_PLATFORM_WINDOWS if ((exce = aot_get_exception(module_inst)) @@ -1412,11 +1395,10 @@ invoke_native_with_hw_bound_check(WASMExecEnv *exec_env, void *func_ptr, #endif /* end of OS_ENABLE_HW_BOUND_CHECK */ bool -aot_call_function(WASMExecEnv *exec_env, - AOTFunctionInstance *function, +aot_call_function(WASMExecEnv *exec_env, AOTFunctionInstance *function, unsigned argc, uint32 argv[]) { - AOTModuleInstance *module_inst = (AOTModuleInstance*)exec_env->module_inst; + AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst; AOTFuncType *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; @@ -1434,9 +1416,11 @@ aot_call_function(WASMExecEnv *exec_env, 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 */ + 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) && !(argv1 = runtime_malloc(size, module_inst->cur_exception, sizeof(module_inst->cur_exception)))) { @@ -1448,11 +1432,12 @@ aot_call_function(WASMExecEnv *exec_env, 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; + 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 *)(argv1 + argc + sizeof(void *) / sizeof(uint32) * i) = (uintptr_t)(ext_rets + cell_num); cell_num += wasm_value_type_cell_num(ext_ret_types[i]); } @@ -1512,9 +1497,10 @@ aot_call_function(WASMExecEnv *exec_env, 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); + 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); @@ -1549,8 +1535,8 @@ aot_call_function(WASMExecEnv *exec_env, bool aot_create_exec_env_and_call_function(AOTModuleInstance *module_inst, - AOTFunctionInstance *func, - unsigned argc, uint32 argv[]) + AOTFunctionInstance *func, unsigned argc, + uint32 argv[]) { WASMExecEnv *exec_env = NULL, *existing_exec_env = NULL; bool ret; @@ -1558,14 +1544,14 @@ aot_create_exec_env_and_call_function(AOTModuleInstance *module_inst, #if defined(OS_ENABLE_HW_BOUND_CHECK) existing_exec_env = exec_env = aot_exec_env; #elif WASM_ENABLE_THREAD_MGR != 0 - existing_exec_env = exec_env = wasm_clusters_search_exec_env( - (WASMModuleInstanceCommon*)module_inst); + existing_exec_env = exec_env = + wasm_clusters_search_exec_env((WASMModuleInstanceCommon *)module_inst); #endif if (!existing_exec_env) { if (!(exec_env = - wasm_exec_env_create((WASMModuleInstanceCommon *)module_inst, - module_inst->default_wasm_stack_size))) { + wasm_exec_env_create((WASMModuleInstanceCommon *)module_inst, + module_inst->default_wasm_stack_size))) { aot_set_exception(module_inst, "allocate memory failed"); return false; } @@ -1589,20 +1575,17 @@ aot_create_exec_env_and_call_function(AOTModuleInstance *module_inst, } void -aot_set_exception(AOTModuleInstance *module_inst, - const char *exception) +aot_set_exception(AOTModuleInstance *module_inst, const char *exception) { if (exception) - snprintf(module_inst->cur_exception, - sizeof(module_inst->cur_exception), + snprintf(module_inst->cur_exception, sizeof(module_inst->cur_exception), "Exception: %s", exception); else module_inst->cur_exception[0] = '\0'; } void -aot_set_exception_with_id(AOTModuleInstance *module_inst, - uint32 id) +aot_set_exception_with_id(AOTModuleInstance *module_inst, uint32 id) { switch (id) { case EXCE_UNREACHABLE: @@ -1636,7 +1619,8 @@ aot_set_exception_with_id(AOTModuleInstance *module_inst, aot_set_exception(module_inst, "uninitialized element"); break; case EXCE_CALL_UNLINKED_IMPORT_FUNC: - aot_set_exception(module_inst, "failed to call unlinked import function"); + aot_set_exception(module_inst, + "failed to call unlinked import function"); break; case EXCE_NATIVE_STACK_OVERFLOW: aot_set_exception(module_inst, "native stack overflow"); @@ -1658,7 +1642,7 @@ aot_set_exception_with_id(AOTModuleInstance *module_inst, } } -const char* +const char * aot_get_exception(AOTModuleInstance *module_inst) { if (module_inst->cur_exception[0] == '\0') @@ -1676,8 +1660,8 @@ aot_clear_exception(AOTModuleInstance *module_inst) static bool execute_malloc_function(AOTModuleInstance *module_inst, AOTFunctionInstance *malloc_func, - AOTFunctionInstance *retain_func, - uint32 size, uint32 *p_result) + AOTFunctionInstance *retain_func, uint32 size, + uint32 *p_result) { uint32 argv[2], argc; bool ret; @@ -1702,12 +1686,12 @@ execute_malloc_function(AOTModuleInstance *module_inst, else #endif { - ret = aot_create_exec_env_and_call_function - (module_inst, malloc_func, argc, argv); + ret = aot_create_exec_env_and_call_function(module_inst, malloc_func, + argc, argv); if (retain_func && ret) { - ret = aot_create_exec_env_and_call_function - (module_inst, retain_func, 1, argv); + ret = aot_create_exec_env_and_call_function(module_inst, + retain_func, 1, argv); } } @@ -1718,8 +1702,7 @@ execute_malloc_function(AOTModuleInstance *module_inst, static bool execute_free_function(AOTModuleInstance *module_inst, - AOTFunctionInstance *free_func, - uint32 offset) + AOTFunctionInstance *free_func, uint32 offset) { uint32 argv[2]; @@ -1733,8 +1716,8 @@ execute_free_function(AOTModuleInstance *module_inst, else #endif { - return aot_create_exec_env_and_call_function - (module_inst, free_func, 1, argv); + return aot_create_exec_env_and_call_function(module_inst, free_func, 1, + argv); } } @@ -1764,8 +1747,7 @@ aot_module_malloc(AOTModuleInstance *module_inst, uint32 size, if (module->retain_func_index != (uint32)-1) { malloc_func_name = "__new"; malloc_func_sig = "(ii)i"; - retain_func = - aot_lookup_function(module_inst, "__retain", "(i)i"); + retain_func = aot_lookup_function(module_inst, "__retain", "(i)i"); if (!retain_func) retain_func = aot_lookup_function(module_inst, "__pin", "(i)i"); bh_assert(retain_func); @@ -1775,17 +1757,14 @@ aot_module_malloc(AOTModuleInstance *module_inst, uint32 size, malloc_func_sig = "(i)i"; } malloc_func = - aot_lookup_function(module_inst, - malloc_func_name, malloc_func_sig); + aot_lookup_function(module_inst, malloc_func_name, malloc_func_sig); bh_assert(malloc_func); if (!execute_malloc_function(module_inst, malloc_func, retain_func, size, &offset)) { return 0; } - addr = offset - ? (uint8*)memory_inst->memory_data.ptr + offset - : NULL; + addr = offset ? (uint8 *)memory_inst->memory_data.ptr + offset : NULL; } if (!addr) { @@ -1804,12 +1783,12 @@ aot_module_malloc(AOTModuleInstance *module_inst, uint32 size, } if (p_native_addr) *p_native_addr = addr; - return (uint32)(addr - (uint8*)memory_inst->memory_data.ptr); + return (uint32)(addr - (uint8 *)memory_inst->memory_data.ptr); } uint32 -aot_module_realloc(AOTModuleInstance *module_inst, uint32 ptr, - uint32 size, void **p_native_addr) +aot_module_realloc(AOTModuleInstance *module_inst, uint32 ptr, uint32 size, + void **p_native_addr) { AOTMemoryInstance *memory_inst = aot_get_default_memory(module_inst); uint8 *addr = NULL; @@ -1820,10 +1799,9 @@ aot_module_realloc(AOTModuleInstance *module_inst, uint32 ptr, } if (memory_inst->heap_handle.ptr) { - addr = - mem_allocator_realloc(memory_inst->heap_handle.ptr, - (uint8*)memory_inst->memory_data.ptr + ptr, - size); + addr = mem_allocator_realloc( + memory_inst->heap_handle.ptr, + (uint8 *)memory_inst->memory_data.ptr + ptr, size); } /* Only support realloc in WAMR's app heap */ @@ -1841,7 +1819,7 @@ aot_module_realloc(AOTModuleInstance *module_inst, uint32 ptr, if (p_native_addr) *p_native_addr = addr; - return (uint32)(addr - (uint8*)memory_inst->memory_data.ptr); + return (uint32)(addr - (uint8 *)memory_inst->memory_data.ptr); } void @@ -1857,7 +1835,7 @@ aot_module_free(AOTModuleInstance *module_inst, uint32 ptr) if (ptr) { uint8 *addr = (uint8 *)memory_inst->memory_data.ptr + ptr; if (memory_inst->heap_handle.ptr - &&(uint8 *)memory_inst->heap_data.ptr < addr + && (uint8 *)memory_inst->heap_data.ptr < addr && addr < (uint8 *)memory_inst->heap_data_end.ptr) { mem_allocator_free(memory_inst->heap_handle.ptr, addr); } @@ -1886,12 +1864,12 @@ aot_module_free(AOTModuleInstance *module_inst, uint32 ptr) } uint32 -aot_module_dup_data(AOTModuleInstance *module_inst, - const char *src, uint32 size) +aot_module_dup_data(AOTModuleInstance *module_inst, const char *src, + uint32 size) { char *buffer; - uint32 buffer_offset = aot_module_malloc(module_inst, size, - (void**)&buffer); + uint32 buffer_offset = + aot_module_malloc(module_inst, size, (void **)&buffer); if (buffer_offset != 0) { buffer = aot_addr_app_to_native(module_inst, buffer_offset); @@ -1901,8 +1879,8 @@ aot_module_dup_data(AOTModuleInstance *module_inst, } bool -aot_validate_app_addr(AOTModuleInstance *module_inst, - uint32 app_offset, uint32 size) +aot_validate_app_addr(AOTModuleInstance *module_inst, uint32 app_offset, + uint32 size) { AOTMemoryInstance *memory_inst = aot_get_default_memory(module_inst); @@ -1911,7 +1889,7 @@ aot_validate_app_addr(AOTModuleInstance *module_inst, } /* integer overflow check */ - if(app_offset > UINT32_MAX - size) { + if (app_offset > UINT32_MAX - size) { goto fail; } @@ -1924,8 +1902,8 @@ fail: } bool -aot_validate_native_addr(AOTModuleInstance *module_inst, - void *native_ptr, uint32 size) +aot_validate_native_addr(AOTModuleInstance *module_inst, void *native_ptr, + uint32 size) { AOTMemoryInstance *memory_inst = aot_get_default_memory(module_inst); uint8 *addr = (uint8 *)native_ptr; @@ -1982,10 +1960,8 @@ aot_addr_native_to_app(AOTModuleInstance *module_inst, void *native_ptr) } bool -aot_get_app_addr_range(AOTModuleInstance *module_inst, - uint32 app_offset, - uint32 *p_app_start_offset, - uint32 *p_app_end_offset) +aot_get_app_addr_range(AOTModuleInstance *module_inst, uint32 app_offset, + uint32 *p_app_start_offset, uint32 *p_app_end_offset) { AOTMemoryInstance *memory_inst = aot_get_default_memory(module_inst); uint32 memory_data_size; @@ -2007,8 +1983,7 @@ aot_get_app_addr_range(AOTModuleInstance *module_inst, } bool -aot_get_native_addr_range(AOTModuleInstance *module_inst, - uint8 *native_ptr, +aot_get_native_addr_range(AOTModuleInstance *module_inst, uint8 *native_ptr, uint8 **p_native_start_addr, uint8 **p_native_end_addr) { @@ -2076,20 +2051,20 @@ aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count) } #endif - if (!(memory_data = wasm_runtime_realloc(memory_data_old, - (uint32)total_size))) { + if (!(memory_data = + wasm_runtime_realloc(memory_data_old, (uint32)total_size))) { if (!(memory_data = wasm_runtime_malloc((uint32)total_size))) { return false; } if (memory_data_old) { - bh_memcpy_s(memory_data, (uint32)total_size, - memory_data_old, total_size_old); + bh_memcpy_s(memory_data, (uint32)total_size, memory_data_old, + total_size_old); wasm_runtime_free(memory_data_old); } } - memset(memory_data + total_size_old, - 0, (uint32)total_size - total_size_old); + memset(memory_data + total_size_old, 0, + (uint32)total_size - total_size_old); memory_inst->cur_page_count = total_page_count; memory_inst->memory_data_size = (uint32)total_size; @@ -2098,8 +2073,8 @@ aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count) if (heap_size > 0) { if (mem_allocator_migrate(memory_inst->heap_handle.ptr, - (char*)heap_data_old - + (memory_data - memory_data_old), + (char *)heap_data_old + + (memory_data - memory_data_old), heap_size)) { return false; } @@ -2162,7 +2137,8 @@ aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count) if (os_mprotect(memory_inst->memory_data_end.ptr, num_bytes_per_page * inc_page_count, - MMAP_PROT_READ | MMAP_PROT_WRITE) != 0) { + MMAP_PROT_READ | MMAP_PROT_WRITE) + != 0) { #ifdef BH_PLATFORM_WINDOWS os_mem_decommit(memory_inst->memory_data_end.ptr, num_bytes_per_page * inc_page_count); @@ -2175,8 +2151,8 @@ aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count) memory_inst->cur_page_count = total_page_count; memory_inst->memory_data_size = (uint32)total_size; - memory_inst->memory_data_end.ptr = (uint8 *)memory_inst->memory_data.ptr - + (uint32)total_size; + memory_inst->memory_data_end.ptr = + (uint8 *)memory_inst->memory_data.ptr + (uint32)total_size; if (sizeof(uintptr_t) == sizeof(uint64)) { memory_inst->mem_bound_check_1byte.u64 = total_size - 1; @@ -2197,11 +2173,11 @@ aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count) #endif /* end of OS_ENABLE_HW_BOUND_CHECK */ bool -aot_is_wasm_type_equal(AOTModuleInstance *module_inst, - uint32 type1_idx, uint32 type2_idx) +aot_is_wasm_type_equal(AOTModuleInstance *module_inst, uint32 type1_idx, + uint32 type2_idx) { WASMType *type1, *type2; - AOTModule *module = (AOTModule*)module_inst->aot_module.ptr; + AOTModule *module = (AOTModule *)module_inst->aot_module.ptr; if (type1_idx >= module->func_type_count || type2_idx >= module->func_type_count) { @@ -2219,16 +2195,16 @@ aot_is_wasm_type_equal(AOTModuleInstance *module_inst, } bool -aot_invoke_native(WASMExecEnv *exec_env, uint32 func_idx, - uint32 argc, uint32 *argv) +aot_invoke_native(WASMExecEnv *exec_env, uint32 func_idx, uint32 argc, + uint32 *argv) { - AOTModuleInstance *module_inst = (AOTModuleInstance*) - wasm_runtime_get_module_inst(exec_env); - AOTModule *aot_module = (AOTModule*)module_inst->aot_module.ptr; - uint32 *func_type_indexes = (uint32*)module_inst->func_type_indexes.ptr; + AOTModuleInstance *module_inst = + (AOTModuleInstance *)wasm_runtime_get_module_inst(exec_env); + AOTModule *aot_module = (AOTModule *)module_inst->aot_module.ptr; + uint32 *func_type_indexes = (uint32 *)module_inst->func_type_indexes.ptr; uint32 func_type_idx = func_type_indexes[func_idx]; AOTFuncType *func_type = aot_module->func_types[func_type_idx]; - void **func_ptrs = (void**)module_inst->func_ptrs.ptr; + void **func_ptrs = (void **)module_inst->func_ptrs.ptr; void *func_ptr = func_ptrs[func_idx]; AOTImportFunc *import_func; const char *signature; @@ -2249,35 +2225,34 @@ aot_invoke_native(WASMExecEnv *exec_env, uint32 func_idx, attachment = import_func->attachment; if (import_func->call_conv_wasm_c_api) { return wasm_runtime_invoke_c_api_native( - (WASMModuleInstanceCommon *)module_inst, func_ptr, func_type, argc, - argv, import_func->wasm_c_api_with_env, attachment); + (WASMModuleInstanceCommon *)module_inst, func_ptr, func_type, argc, + argv, import_func->wasm_c_api_with_env, attachment); } else if (!import_func->call_conv_raw) { signature = import_func->signature; - return wasm_runtime_invoke_native(exec_env, func_ptr, - func_type, signature, attachment, - argv, argc, argv); + return wasm_runtime_invoke_native(exec_env, func_ptr, func_type, + signature, attachment, argv, argc, + argv); } else { signature = import_func->signature; - return wasm_runtime_invoke_native_raw(exec_env, func_ptr, - func_type, signature, attachment, - argv, argc, argv); + return wasm_runtime_invoke_native_raw(exec_env, func_ptr, func_type, + signature, attachment, argv, argc, + argv); } } bool -aot_call_indirect(WASMExecEnv *exec_env, - uint32 tbl_idx, uint32 table_elem_idx, +aot_call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 table_elem_idx, uint32 argc, uint32 *argv) { - AOTModuleInstance *module_inst = (AOTModuleInstance*) - wasm_runtime_get_module_inst(exec_env); - AOTModule *aot_module = (AOTModule*)module_inst->aot_module.ptr; - uint32 *func_type_indexes = (uint32*)module_inst->func_type_indexes.ptr; + AOTModuleInstance *module_inst = + (AOTModuleInstance *)wasm_runtime_get_module_inst(exec_env); + AOTModule *aot_module = (AOTModule *)module_inst->aot_module.ptr; + uint32 *func_type_indexes = (uint32 *)module_inst->func_type_indexes.ptr; AOTTableInstance *tbl_inst; AOTFuncType *func_type; - void **func_ptrs = (void**)module_inst->func_ptrs.ptr, *func_ptr; + void **func_ptrs = (void **)module_inst->func_ptrs.ptr, *func_ptr; uint32 func_type_idx, func_idx, ext_ret_count; AOTImportFunc *import_func; const char *signature = NULL; @@ -2289,7 +2264,7 @@ aot_call_indirect(WASMExecEnv *exec_env, exec_env->native_stack_boundary must have been set, we don't set it again */ - if ((uint8*)&module_inst < exec_env->native_stack_boundary) { + if ((uint8 *)&module_inst < exec_env->native_stack_boundary) { aot_set_exception_with_id(module_inst, EXCE_NATIVE_STACK_OVERFLOW); return false; } @@ -2302,7 +2277,7 @@ aot_call_indirect(WASMExecEnv *exec_env, return false; } - func_idx = ((uint32*)tbl_inst->data)[table_elem_idx]; + func_idx = ((uint32 *)tbl_inst->data)[table_elem_idx]; if (func_idx == (uint32)-1) { aot_set_exception_with_id(module_inst, EXCE_UNINITIALIZED_ELEMENT); return false; @@ -2327,15 +2302,14 @@ aot_call_indirect(WASMExecEnv *exec_env, signature = import_func->signature; if (import_func->call_conv_raw) { attachment = import_func->attachment; - return wasm_runtime_invoke_native_raw(exec_env, func_ptr, - func_type, signature, - attachment, - argv, argc, argv); + return wasm_runtime_invoke_native_raw(exec_env, func_ptr, func_type, + signature, attachment, argv, + argc, argv); } } - ext_ret_count = func_type->result_count > 1 - ? func_type->result_count - 1 : 0; + ext_ret_count = + func_type->result_count > 1 ? func_type->result_count - 1 : 0; if (ext_ret_count > 0) { uint32 argv1_buf[32], *argv1 = argv1_buf; uint32 *ext_rets = NULL, *argv_ret = argv; @@ -2345,9 +2319,11 @@ aot_call_indirect(WASMExecEnv *exec_env, 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 */ + 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) && !(argv1 = runtime_malloc(size, module_inst->cur_exception, sizeof(module_inst->cur_exception)))) { @@ -2359,18 +2335,18 @@ aot_call_indirect(WASMExecEnv *exec_env, 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; + 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 *)(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 = invoke_native_internal(exec_env, func_ptr, - func_type, signature, attachment, - argv1, argc, argv); + ret = invoke_native_internal(exec_env, func_ptr, func_type, signature, + attachment, argv1, argc, argv); if (!ret || aot_get_exception(module_inst)) { if (argv1 != argv1_buf) wasm_runtime_free(argv1); @@ -2402,9 +2378,10 @@ aot_call_indirect(WASMExecEnv *exec_env, 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); + 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); @@ -2412,9 +2389,8 @@ aot_call_indirect(WASMExecEnv *exec_env, return true; } else { - ret = invoke_native_internal(exec_env, func_ptr, - func_type, signature, attachment, - argv, argc, argv); + ret = invoke_native_internal(exec_env, func_ptr, func_type, signature, + attachment, argv, argc, argv); if (clear_wasi_proc_exit_exception(module_inst)) return true; return ret; @@ -2435,8 +2411,8 @@ aot_memset(void *s, int c, size_t n) #if WASM_ENABLE_BULK_MEMORY != 0 bool -aot_memory_init(AOTModuleInstance *module_inst, uint32 seg_index, - uint32 offset, uint32 len, uint32 dst) +aot_memory_init(AOTModuleInstance *module_inst, uint32 seg_index, uint32 offset, + uint32 len, uint32 dst) { AOTMemoryInstance *memory_inst = aot_get_default_memory(module_inst); AOTModule *aot_module; @@ -2447,7 +2423,8 @@ aot_memory_init(AOTModuleInstance *module_inst, uint32 seg_index, aot_module = (AOTModule *)module_inst->aot_module.ptr; if (aot_module->is_jit_mode) { #if WASM_ENABLE_JIT != 0 - seg_len = aot_module->wasm_module->data_segments[seg_index]->data_length; + seg_len = + aot_module->wasm_module->data_segments[seg_index]->data_length; data = aot_module->wasm_module->data_segments[seg_index]->data; #endif } @@ -2466,8 +2443,7 @@ aot_memory_init(AOTModuleInstance *module_inst, uint32 seg_index, maddr = aot_addr_app_to_native(module_inst, dst); - bh_memcpy_s(maddr, memory_inst->memory_data_size - dst, - data + offset, len); + bh_memcpy_s(maddr, memory_inst->memory_data_size - dst, data + offset, len); return true; } @@ -2494,11 +2470,9 @@ aot_data_drop(AOTModuleInstance *module_inst, uint32 seg_index) #if WASM_ENABLE_THREAD_MGR != 0 bool -aot_set_aux_stack(WASMExecEnv *exec_env, - uint32 start_offset, uint32 size) +aot_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, uint32 size) { - AOTModuleInstance *module_inst = - (AOTModuleInstance*)exec_env->module_inst; + AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst; AOTModule *module = (AOTModule *)module_inst->aot_module.ptr; uint32 stack_top_idx = module->aux_stack_top_global_index; @@ -2514,10 +2488,10 @@ aot_set_aux_stack(WASMExecEnv *exec_env, if (stack_top_idx != (uint32)-1) { /* The aux stack top is a wasm global, set the initial value for the global */ - uint32 global_offset = - module->globals[stack_top_idx].data_offset; - uint8 *global_addr = (uint8 *)module_inst->global_data.ptr + global_offset; - *(int32*)global_addr = start_offset; + uint32 global_offset = module->globals[stack_top_idx].data_offset; + uint8 *global_addr = + (uint8 *)module_inst->global_data.ptr + global_offset; + *(int32 *)global_addr = start_offset; /* The aux stack boundary is a constant value, set the value to exec_env */ @@ -2530,11 +2504,9 @@ aot_set_aux_stack(WASMExecEnv *exec_env, } bool -aot_get_aux_stack(WASMExecEnv *exec_env, - uint32 *start_offset, uint32 *size) +aot_get_aux_stack(WASMExecEnv *exec_env, uint32 *start_offset, uint32 *size) { - AOTModuleInstance *module_inst = - (AOTModuleInstance*)exec_env->module_inst; + AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst; AOTModule *module = (AOTModule *)module_inst->aot_module.ptr; /* The aux stack information is resolved in loader @@ -2555,13 +2527,12 @@ aot_get_aux_stack(WASMExecEnv *exec_env, #if (WASM_ENABLE_MEMORY_PROFILING != 0) || (WASM_ENABLE_MEMORY_TRACING != 0) static void -const_string_node_size_cb(void *key, void *value, - void *p_const_string_size) +const_string_node_size_cb(void *key, void *value, void *p_const_string_size) { - uint32 const_string_size = *(uint32*)p_const_string_size; + uint32 const_string_size = *(uint32 *)p_const_string_size; const_string_size += bh_hash_map_get_elem_struct_size(); const_string_size += strlen((const char *)value) + 1; - *(uint32*)p_const_string_size += const_string_size; + *(uint32 *)p_const_string_size += const_string_size; } void @@ -2577,8 +2548,8 @@ aot_get_module_mem_consumption(const AOTModule *module, mem_conspn->types_size = sizeof(AOTFuncType *) * module->func_type_count; for (i = 0; i < module->func_type_count; i++) { AOTFuncType *type = module->func_types[i]; - size = offsetof(AOTFuncType, types) + - sizeof(uint8) * (type->param_count + type->result_count); + size = offsetof(AOTFuncType, types) + + sizeof(uint8) * (type->param_count + type->result_count); mem_conspn->types_size += size; } @@ -2607,8 +2578,8 @@ aot_get_module_mem_consumption(const AOTModule *module, mem_conspn->table_segs_size += size; } - mem_conspn->data_segs_size = sizeof(AOTMemInitData *) - * module->mem_init_data_count; + mem_conspn->data_segs_size = + sizeof(AOTMemInitData *) * module->mem_init_data_count; for (i = 0; i < module->mem_init_data_count; i++) { mem_conspn->data_segs_size += sizeof(AOTMemInitData); } @@ -2619,14 +2590,14 @@ aot_get_module_mem_consumption(const AOTModule *module, mem_conspn->const_strs_size = bh_hash_map_get_struct_size(module->const_str_set); - bh_hash_map_traverse(module->const_str_set, - const_string_node_size_cb, - (void*)&const_string_size); + bh_hash_map_traverse(module->const_str_set, const_string_node_size_cb, + (void *)&const_string_size); mem_conspn->const_strs_size += const_string_size; } /* code size + literal size + object data section size */ - mem_conspn->aot_code_size = module->code_size + module->literal_size + mem_conspn->aot_code_size = + module->code_size + module->literal_size + sizeof(AOTObjectDataSection) * module->data_section_count; for (i = 0; i < module->data_section_count; i++) { AOTObjectDataSection *obj_data = module->data_sections + i; @@ -2666,11 +2637,10 @@ aot_get_module_inst_mem_consumption(const AOTModuleInstance *module_inst, ((AOTMemoryInstance **)module_inst->memories.ptr)[i]; mem_conspn->memories_size += mem_inst->num_bytes_per_page * mem_inst->cur_page_count; - mem_conspn->app_heap_size = - (uint8 *) mem_inst->heap_data_end.ptr - (uint8 *) mem_inst->heap_data.ptr; + mem_conspn->app_heap_size = (uint8 *)mem_inst->heap_data_end.ptr + - (uint8 *)mem_inst->heap_data.ptr; /* size of app heap structure */ - mem_conspn->memories_size += - mem_allocator_get_heap_struct_size(); + mem_conspn->memories_size += mem_allocator_get_heap_struct_size(); } tbl_inst = module_inst->tables.ptr; @@ -2681,9 +2651,10 @@ aot_get_module_inst_mem_consumption(const AOTModuleInstance *module_inst, } /* func_ptrs and func_type_indexes */ - mem_conspn->functions_size = (sizeof(void *) + sizeof(uint32)) * - (((AOTModule *)module_inst->aot_module.ptr)->import_func_count - + ((AOTModule *)module_inst->aot_module.ptr)->func_count); + mem_conspn->functions_size = + (sizeof(void *) + sizeof(uint32)) + * (((AOTModule *)module_inst->aot_module.ptr)->import_func_count + + ((AOTModule *)module_inst->aot_module.ptr)->func_count); mem_conspn->globals_size = module_inst->global_data_size; @@ -2697,7 +2668,7 @@ aot_get_module_inst_mem_consumption(const AOTModuleInstance *module_inst, mem_conspn->total_size += mem_conspn->globals_size; mem_conspn->total_size += mem_conspn->exports_size; } -#endif /* end of (WASM_ENABLE_MEMORY_PROFILING != 0) +#endif /* end of (WASM_ENABLE_MEMORY_PROFILING != 0) \ || (WASM_ENABLE_MEMORY_TRACING != 0) */ #if WASM_ENABLE_REF_TYPES != 0 @@ -2710,9 +2681,9 @@ aot_drop_table_seg(AOTModuleInstance *module_inst, uint32 tbl_seg_idx) } void -aot_table_init(AOTModuleInstance *module_inst, - uint32 tbl_idx, uint32 tbl_seg_idx, - uint32 length, uint32 src_offset, uint32 dst_offset) +aot_table_init(AOTModuleInstance *module_inst, uint32 tbl_idx, + uint32 tbl_seg_idx, uint32 length, uint32 src_offset, + uint32 dst_offset) { AOTTableInstance *tbl_inst; AOTTableInitData *tbl_seg; @@ -2730,33 +2701,30 @@ aot_table_init(AOTModuleInstance *module_inst, if (length + src_offset > tbl_seg->func_index_count || dst_offset + length > tbl_inst->cur_size) { - aot_set_exception_with_id(module_inst, - EXCE_OUT_OF_BOUNDS_TABLE_ACCESS); + aot_set_exception_with_id(module_inst, EXCE_OUT_OF_BOUNDS_TABLE_ACCESS); return; } if (tbl_seg->is_dropped) { - aot_set_exception_with_id(module_inst, - EXCE_OUT_OF_BOUNDS_TABLE_ACCESS); + aot_set_exception_with_id(module_inst, EXCE_OUT_OF_BOUNDS_TABLE_ACCESS); return; } if (!wasm_elem_is_passive(tbl_seg->mode)) { - aot_set_exception_with_id(module_inst, - EXCE_OUT_OF_BOUNDS_TABLE_ACCESS); + aot_set_exception_with_id(module_inst, EXCE_OUT_OF_BOUNDS_TABLE_ACCESS); return; } bh_memcpy_s((uint8 *)tbl_inst + offsetof(AOTTableInstance, data) - + dst_offset * sizeof(uint32), + + dst_offset * sizeof(uint32), (tbl_inst->cur_size - dst_offset) * sizeof(uint32), tbl_seg->func_indexes + src_offset, length * sizeof(uint32)); } void -aot_table_copy(AOTModuleInstance *module_inst, - uint32 src_tbl_idx, uint32 dst_tbl_idx, - uint32 length, uint32 src_offset, uint32 dst_offset) +aot_table_copy(AOTModuleInstance *module_inst, uint32 src_tbl_idx, + uint32 dst_tbl_idx, uint32 length, uint32 src_offset, + uint32 dst_offset) { AOTTableInstance *src_tbl_inst, *dst_tbl_inst; @@ -2768,8 +2736,7 @@ aot_table_copy(AOTModuleInstance *module_inst, if ((uint64)src_offset + length > dst_tbl_inst->cur_size || (uint64)dst_offset + length > src_tbl_inst->cur_size) { - aot_set_exception_with_id(module_inst, - EXCE_OUT_OF_BOUNDS_TABLE_ACCESS); + aot_set_exception_with_id(module_inst, EXCE_OUT_OF_BOUNDS_TABLE_ACCESS); return; } @@ -2777,16 +2744,16 @@ aot_table_copy(AOTModuleInstance *module_inst, /* if src_offset < dst_offset, copy from back to front */ /* merge all together */ bh_memmove_s((uint8 *)(dst_tbl_inst) + offsetof(AOTTableInstance, data) - + dst_offset * sizeof(uint32), + + dst_offset * sizeof(uint32), (dst_tbl_inst->cur_size - dst_offset) * sizeof(uint32), (uint8 *)(src_tbl_inst) + offsetof(AOTTableInstance, data) - + src_offset * sizeof(uint32), + + src_offset * sizeof(uint32), length * sizeof(uint32)); } void -aot_table_fill(AOTModuleInstance *module_inst, uint32 tbl_idx, - uint32 length, uint32 val, uint32 data_offset) +aot_table_fill(AOTModuleInstance *module_inst, uint32 tbl_idx, uint32 length, + uint32 val, uint32 data_offset) { AOTTableInstance *tbl_inst; @@ -2794,8 +2761,7 @@ aot_table_fill(AOTModuleInstance *module_inst, uint32 tbl_idx, bh_assert(tbl_inst); if (data_offset + length > tbl_inst->cur_size) { - aot_set_exception_with_id(module_inst, - EXCE_OUT_OF_BOUNDS_TABLE_ACCESS); + aot_set_exception_with_id(module_inst, EXCE_OUT_OF_BOUNDS_TABLE_ACCESS); return; } @@ -2857,8 +2823,7 @@ get_func_name_from_index(const AOTModuleInstance *module_inst, for (i = 0; i < module->export_count; i++) { AOTExport export = module->exports[i]; - if (export.index == func_index - && export.kind == EXPORT_KIND_FUNC) { + if (export.index == func_index && export.kind == EXPORT_KIND_FUNC) { func_name = export.name; break; } @@ -2874,14 +2839,14 @@ aot_alloc_frame(WASMExecEnv *exec_env, uint32 func_index) AOTFrame *frame = wasm_exec_env_alloc_wasm_frame(exec_env, sizeof(AOTFrame)); #if WASM_ENABLE_PERF_PROFILING != 0 - AOTModuleInstance *module_inst = - (AOTModuleInstance*)exec_env->module_inst; + AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst; AOTFuncPerfProfInfo *func_perf_prof = - (AOTFuncPerfProfInfo*)module_inst->func_perf_profilings.ptr + func_index; + (AOTFuncPerfProfInfo *)module_inst->func_perf_profilings.ptr + + func_index; #endif if (!frame) { - aot_set_exception((AOTModuleInstance*)exec_env->module_inst, + aot_set_exception((AOTModuleInstance *)exec_env->module_inst, "auxiliary call stack overflow"); return false; } @@ -2906,14 +2871,14 @@ aot_free_frame(WASMExecEnv *exec_env) #if WASM_ENABLE_PERF_PROFILING != 0 cur_frame->func_perf_prof_info->total_exec_time += - os_time_get_boot_microsecond() - cur_frame->time_started; + os_time_get_boot_microsecond() - cur_frame->time_started; cur_frame->func_perf_prof_info->total_exec_cnt++; #endif wasm_exec_env_free_wasm_frame(exec_env, cur_frame); exec_env->cur_frame = (struct WASMInterpFrame *)prev_frame; } -#endif /* end of (WASM_ENABLE_DUMP_CALL_STACK != 0) +#endif /* end of (WASM_ENABLE_DUMP_CALL_STACK != 0) \ || (WASM_ENABLE_PERF_PROFILING != 0) */ #if WASM_ENABLE_DUMP_CALL_STACK != 0 @@ -2922,8 +2887,7 @@ aot_dump_call_stack(WASMExecEnv *exec_env) { AOTFrame *cur_frame = (AOTFrame *)exec_env->cur_frame, *first_frame = cur_frame; - AOTModuleInstance *module_inst = - (AOTModuleInstance *)exec_env->module_inst; + AOTModuleInstance *module_inst = (AOTModuleInstance *)exec_env->module_inst; const char *func_name; uint32 n = 0; @@ -2947,8 +2911,7 @@ aot_dump_call_stack(WASMExecEnv *exec_env) /* release previous stack frames and create new ones */ if (!bh_vector_destroy(module_inst->frames.ptr) - || !bh_vector_init(module_inst->frames.ptr, n, - sizeof(WASMCApiFrame))) { + || !bh_vector_init(module_inst->frames.ptr, n, sizeof(WASMCApiFrame))) { return; } @@ -2974,8 +2937,8 @@ aot_dump_call_stack(WASMExecEnv *exec_env) void aot_dump_perf_profiling(const AOTModuleInstance *module_inst) { - AOTFuncPerfProfInfo *perf_prof = (AOTFuncPerfProfInfo *) - module_inst->func_perf_profilings.ptr; + AOTFuncPerfProfInfo *perf_prof = + (AOTFuncPerfProfInfo *)module_inst->func_perf_profilings.ptr; AOTModule *module = (AOTModule *)module_inst->aot_module.ptr; uint32 total_func_count = module->import_func_count + module->func_count, i; const char *func_name; @@ -2985,14 +2948,15 @@ aot_dump_perf_profiling(const AOTModuleInstance *module_inst) func_name = get_func_name_from_index(module_inst, i); if (func_name) - os_printf(" func %s, execution time: %.3f ms, execution count: %d times\n", + os_printf(" func %s, execution time: %.3f ms, execution count: %d " + "times\n", func_name, perf_prof->total_exec_time / 1000.0f, perf_prof->total_exec_cnt); else - os_printf(" func %d, execution time: %.3f ms, execution count: %d times\n", + os_printf(" func %d, execution time: %.3f ms, execution count: %d " + "times\n", i, perf_prof->total_exec_time / 1000.0f, perf_prof->total_exec_cnt); } } #endif /* end of WASM_ENABLE_PERF_PROFILING */ - diff --git a/core/iwasm/aot/aot_runtime.h b/core/iwasm/aot/aot_runtime.h index 70c0697e..4fe9889e 100644 --- a/core/iwasm/aot/aot_runtime.h +++ b/core/iwasm/aot/aot_runtime.h @@ -95,6 +95,7 @@ typedef struct AOTFunctionInstance { } AOTFunctionInstance; #if defined(OS_ENABLE_HW_BOUND_CHECK) && defined(BH_PLATFORM_WINDOWS) +/* clang-format off */ typedef struct AOTUnwindInfo { uint8 Version : 3; uint8 Flags : 5; @@ -111,6 +112,7 @@ typedef struct AOTUnwindInfo { uint16 FrameOffset; } UnwindCode[1]; } AOTUnwindInfo; +/* clang-format on */ /* size of mov instruction and jmp instruction */ #define PLT_ITEM_SIZE 12 @@ -328,7 +330,7 @@ typedef struct AOTModuleInstance { * TODO: for now we treate imported table like a local table */ uint32 table_count; - /* points to global_data */ + /* points to global_data */ AOTPointer global_data; /* points to AOTTableInstance[] */ AOTPointer tables; @@ -373,15 +375,15 @@ typedef struct AOTModuleInstance { /* reserved */ uint32 reserved[6]; - /* - * +------------------------------+ <-- memories.ptr - * | #0 AOTMemoryInstance - * +------------------------------+ <-- global_data.ptr - * | global data - * +------------------------------+ <-- tables.ptr - * | AOTTableInstance[table_count] - * +------------------------------+ - */ + /* + * +------------------------------+ <-- memories.ptr + * | #0 AOTMemoryInstance + * +------------------------------+ <-- global_data.ptr + * | global data + * +------------------------------+ <-- tables.ptr + * | AOTTableInstance[table_count] + * +------------------------------+ + */ union { uint64 _make_it_8_byte_aligned_; AOTMemoryInstance memory_instances[1]; @@ -409,8 +411,7 @@ typedef struct AOTTargetInfo { char arch[16]; } AOTTargetInfo; -typedef struct AOTFuncPerfProfInfo -{ +typedef struct AOTFuncPerfProfInfo { /* total execution time */ uint64 total_exec_time; /* total execution count */ @@ -436,9 +437,9 @@ typedef struct AOTFrame { * * @return return AOT module loaded, NULL if failed */ -AOTModule* -aot_load_from_aot_file(const uint8 *buf, uint32 size, - char *error_buf, uint32 error_buf_size); +AOTModule * +aot_load_from_aot_file(const uint8 *buf, uint32 size, char *error_buf, + uint32 error_buf_size); /** * Load a AOT module from a specified AOT section list. @@ -449,9 +450,9 @@ aot_load_from_aot_file(const uint8 *buf, uint32 size, * * @return return AOT module loaded, NULL if failed */ -AOTModule* -aot_load_from_sections(AOTSection *section_list, - char *error_buf, uint32 error_buf_size); +AOTModule * +aot_load_from_sections(AOTSection *section_list, char *error_buf, + uint32 error_buf_size); #if WASM_ENABLE_JIT != 0 /** @@ -463,9 +464,9 @@ aot_load_from_sections(AOTSection *section_list, * * @return return AOT module loaded, NULL if failed */ -AOTModule* -aot_convert_wasm_module(WASMModule *wasm_module, - char *error_buf, uint32 error_buf_size); +AOTModule * +aot_convert_wasm_module(WASMModule *wasm_module, char *error_buf, + uint32 error_buf_size); #endif /** @@ -490,10 +491,9 @@ aot_unload(AOTModule *module); * * @return return the instantiated AOT module instance, NULL if failed */ -AOTModuleInstance* -aot_instantiate(AOTModule *module, bool is_sub_inst, - uint32 stack_size, uint32 heap_size, - char *error_buf, uint32 error_buf_size); +AOTModuleInstance * +aot_instantiate(AOTModule *module, bool is_sub_inst, uint32 stack_size, + uint32 heap_size, char *error_buf, uint32 error_buf_size); /** * Deinstantiate a AOT module instance, destroy the resources. @@ -514,9 +514,9 @@ aot_deinstantiate(AOTModuleInstance *module_inst, bool is_sub_inst); * * @return the function instance found */ -AOTFunctionInstance* -aot_lookup_function(const AOTModuleInstance *module_inst, - const char *name, const char *signature); +AOTFunctionInstance * +aot_lookup_function(const AOTModuleInstance *module_inst, const char *name, + const char *signature); /** * Call the given AOT function of a AOT module instance with * arguments. @@ -533,8 +533,7 @@ aot_lookup_function(const AOTModuleInstance *module_inst, * the caller can call aot_get_exception to get exception info. */ bool -aot_call_function(WASMExecEnv *exec_env, - AOTFunctionInstance *function, +aot_call_function(WASMExecEnv *exec_env, AOTFunctionInstance *function, unsigned argc, uint32 argv[]); bool @@ -553,12 +552,10 @@ aot_create_exec_env_singleton(AOTModuleInstance *module_inst); * @param exception current exception string */ void -aot_set_exception(AOTModuleInstance *module_inst, - const char *exception); +aot_set_exception(AOTModuleInstance *module_inst, const char *exception); void -aot_set_exception_with_id(AOTModuleInstance *module_inst, - uint32 id); +aot_set_exception_with_id(AOTModuleInstance *module_inst, uint32 id); /** * Get exception info of the AOT module instance. @@ -567,7 +564,7 @@ aot_set_exception_with_id(AOTModuleInstance *module_inst, * * @return the exception string */ -const char* +const char * aot_get_exception(AOTModuleInstance *module_inst); /** @@ -583,24 +580,23 @@ aot_module_malloc(AOTModuleInstance *module_inst, uint32 size, void **p_native_addr); uint32 -aot_module_realloc(AOTModuleInstance *module_inst, uint32 ptr, - uint32 size, void **p_native_addr); +aot_module_realloc(AOTModuleInstance *module_inst, uint32 ptr, uint32 size, + void **p_native_addr); void aot_module_free(AOTModuleInstance *module_inst, uint32 ptr); uint32 -aot_module_dup_data(AOTModuleInstance *module_inst, - const char *src, uint32 size); +aot_module_dup_data(AOTModuleInstance *module_inst, const char *src, + uint32 size); bool -aot_validate_app_addr(AOTModuleInstance *module_inst, - uint32 app_offset, uint32 size); - +aot_validate_app_addr(AOTModuleInstance *module_inst, uint32 app_offset, + uint32 size); bool -aot_validate_native_addr(AOTModuleInstance *module_inst, - void *native_ptr, uint32 size); +aot_validate_native_addr(AOTModuleInstance *module_inst, void *native_ptr, + uint32 size); void * aot_addr_app_to_native(AOTModuleInstance *module_inst, uint32 app_offset); @@ -609,14 +605,11 @@ uint32 aot_addr_native_to_app(AOTModuleInstance *module_inst, void *native_ptr); bool -aot_get_app_addr_range(AOTModuleInstance *module_inst, - uint32 app_offset, - uint32 *p_app_start_offset, - uint32 *p_app_end_offset); +aot_get_app_addr_range(AOTModuleInstance *module_inst, uint32 app_offset, + uint32 *p_app_start_offset, uint32 *p_app_end_offset); bool -aot_get_native_addr_range(AOTModuleInstance *module_inst, - uint8 *native_ptr, +aot_get_native_addr_range(AOTModuleInstance *module_inst, uint8 *native_ptr, uint8 **p_native_start_addr, uint8 **p_native_end_addr); @@ -633,19 +626,18 @@ aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count); * @return true if equal, false otherwise */ bool -aot_is_wasm_type_equal(AOTModuleInstance *module_inst, - uint32 type1_idx, uint32 type2_idx); +aot_is_wasm_type_equal(AOTModuleInstance *module_inst, uint32 type1_idx, + uint32 type2_idx); /** * Invoke native function from aot code */ bool -aot_invoke_native(WASMExecEnv *exec_env, uint32 func_idx, - uint32 argc, uint32 *argv); +aot_invoke_native(WASMExecEnv *exec_env, uint32 func_idx, uint32 argc, + uint32 *argv); bool -aot_call_indirect(WASMExecEnv *exec_env, - uint32 tbl_idx, uint32 table_elem_idx, +aot_call_indirect(WASMExecEnv *exec_env, uint32 tbl_idx, uint32 table_elem_idx, uint32 argc, uint32 *argv); uint32 @@ -659,8 +651,8 @@ aot_memset(void *s, int c, size_t n); #if WASM_ENABLE_BULK_MEMORY != 0 bool -aot_memory_init(AOTModuleInstance *module_inst, uint32 seg_index, - uint32 offset, uint32 len, uint32 dst); +aot_memory_init(AOTModuleInstance *module_inst, uint32 seg_index, uint32 offset, + uint32 len, uint32 dst); bool aot_data_drop(AOTModuleInstance *module_inst, uint32 seg_index); @@ -668,12 +660,10 @@ aot_data_drop(AOTModuleInstance *module_inst, uint32 seg_index); #if WASM_ENABLE_THREAD_MGR != 0 bool -aot_set_aux_stack(WASMExecEnv *exec_env, - uint32 start_offset, uint32 size); +aot_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, uint32 size); bool -aot_get_aux_stack(WASMExecEnv *exec_env, - uint32 *start_offset, uint32 *size); +aot_get_aux_stack(WASMExecEnv *exec_env, uint32 *start_offset, uint32 *size); #endif #ifdef OS_ENABLE_HW_BOUND_CHECK @@ -697,18 +687,18 @@ void aot_drop_table_seg(AOTModuleInstance *module_inst, uint32 tbl_seg_idx); void -aot_table_init(AOTModuleInstance *module_inst, - uint32 tbl_idx, uint32 tbl_seg_idx, - uint32 length, uint32 src_offset, uint32 dst_offset); +aot_table_init(AOTModuleInstance *module_inst, uint32 tbl_idx, + uint32 tbl_seg_idx, uint32 length, uint32 src_offset, + uint32 dst_offset); void -aot_table_copy(AOTModuleInstance *module_inst, - uint32 src_tbl_idx, uint32 dst_tbl_idx, - uint32 length, uint32 src_offset, uint32 dst_offset); +aot_table_copy(AOTModuleInstance *module_inst, uint32 src_tbl_idx, + uint32 dst_tbl_idx, uint32 length, uint32 src_offset, + uint32 dst_offset); void -aot_table_fill(AOTModuleInstance *module_inst, uint32 tbl_idx, - uint32 length, uint32 val, uint32 data_offset); +aot_table_fill(AOTModuleInstance *module_inst, uint32 tbl_idx, uint32 length, + uint32 val, uint32 data_offset); uint32 aot_table_grow(AOTModuleInstance *module_inst, uint32 tbl_idx, @@ -735,4 +725,3 @@ aot_dump_perf_profiling(const AOTModuleInstance *module_inst); #endif #endif /* end of _AOT_RUNTIME_H_ */ - diff --git a/core/iwasm/aot/arch/aot_reloc_aarch64.c b/core/iwasm/aot/arch/aot_reloc_aarch64.c index 14e4ac7d..0ca22b84 100644 --- a/core/iwasm/aot/arch/aot_reloc_aarch64.c +++ b/core/iwasm/aot/arch/aot_reloc_aarch64.c @@ -5,37 +5,39 @@ #include "aot_reloc.h" -#define R_AARCH64_MOVW_UABS_G0 263 -#define R_AARCH64_MOVW_UABS_G0_NC 264 -#define R_AARCH64_MOVW_UABS_G1 265 -#define R_AARCH64_MOVW_UABS_G1_NC 266 -#define R_AARCH64_MOVW_UABS_G2 267 -#define R_AARCH64_MOVW_UABS_G2_NC 268 -#define R_AARCH64_MOVW_UABS_G3 269 +#define R_AARCH64_MOVW_UABS_G0 263 +#define R_AARCH64_MOVW_UABS_G0_NC 264 +#define R_AARCH64_MOVW_UABS_G1 265 +#define R_AARCH64_MOVW_UABS_G1_NC 266 +#define R_AARCH64_MOVW_UABS_G2 267 +#define R_AARCH64_MOVW_UABS_G2_NC 268 +#define R_AARCH64_MOVW_UABS_G3 269 -#define R_AARCH64_MOVW_SABS_G0 270 -#define R_AARCH64_MOVW_SABS_G1 271 -#define R_AARCH64_MOVW_SABS_G2 272 +#define R_AARCH64_MOVW_SABS_G0 270 +#define R_AARCH64_MOVW_SABS_G1 271 +#define R_AARCH64_MOVW_SABS_G2 272 -#define R_AARCH64_ADR_PREL_LO19 273 -#define R_AARCH64_ADR_PREL_LO21 274 -#define R_AARCH64_ADR_PREL_PG_HI21 275 -#define R_AARCH64_ADR_PREL_PG_HI21_NC 276 +#define R_AARCH64_ADR_PREL_LO19 273 +#define R_AARCH64_ADR_PREL_LO21 274 +#define R_AARCH64_ADR_PREL_PG_HI21 275 +#define R_AARCH64_ADR_PREL_PG_HI21_NC 276 -#define R_AARCH64_ADD_ABS_LO12_NC 277 +#define R_AARCH64_ADD_ABS_LO12_NC 277 -#define R_AARCH64_LDST8_ABS_LO12_NC 278 -#define R_AARCH64_LDST16_ABS_LO12_NC 284 -#define R_AARCH64_LDST32_ABS_LO12_NC 285 -#define R_AARCH64_LDST64_ABS_LO12_NC 286 -#define R_AARCH64_LDST128_ABS_LO12_NC 299 +#define R_AARCH64_LDST8_ABS_LO12_NC 278 +#define R_AARCH64_LDST16_ABS_LO12_NC 284 +#define R_AARCH64_LDST32_ABS_LO12_NC 285 +#define R_AARCH64_LDST64_ABS_LO12_NC 286 +#define R_AARCH64_LDST128_ABS_LO12_NC 299 -#define R_AARCH64_JUMP26 282 -#define R_AARCH64_CALL26 283 +#define R_AARCH64_JUMP26 282 +#define R_AARCH64_CALL26 283 +/* clang-format off */ static SymbolMap target_sym_map[] = { REG_COMMON_SYMBOLS }; +/* clang-format on */ static void set_error_buf(char *error_buf, uint32 error_buf_size, const char *string) @@ -55,7 +57,7 @@ get_target_symbol_map(uint32 *sym_num) void get_current_target(char *target_buf, uint32 target_buf_size) { - const char * s = BUILD_TARGET; + const char *s = BUILD_TARGET; size_t s_size = sizeof(BUILD_TARGET); char *d = target_buf; @@ -64,14 +66,14 @@ get_current_target(char *target_buf, uint32 target_buf_size) s = BUILD_TARGET_AARCH64_DEFAULT; s_size = sizeof(BUILD_TARGET_AARCH64_DEFAULT); } - if(target_buf_size < s_size){ + if (target_buf_size < s_size) { s_size = target_buf_size; } while (--s_size) { if (*s >= 'A' && *s <= 'Z') *d++ = *s++ + 'a' - 'A'; else - *d++ = *s++ ; + *d++ = *s++; } /* Ensure the string is null byte ('\0') terminated */ *d = '\0'; @@ -90,15 +92,16 @@ init_plt_table(uint8 *plt) { uint32 i, num = sizeof(target_sym_map) / sizeof(SymbolMap); for (i = 0; i < num; i++) { - uint32 *p = (uint32*)plt; + uint32 *p = (uint32 *)plt; *p++ = 0xf81f0ffe; /* str x30, [sp, #-16]! */ - *p++ = 0x100000be; /* adr x30, #20 ;symbol addr is PC + 5 instructions below */ + *p++ = 0x100000be; /* adr x30, #20; symbol addr is PC + 5 instructions + below */ *p++ = 0xf94003de; /* ldr x30, [x30] */ *p++ = 0xd63f03c0; /* blr x30 */ *p++ = 0xf84107fe; /* ldr x30, [sp], #16 */ *p++ = 0xd61f03c0; /* br x30 */ /* symbol addr */ - *(uint64*)p = (uint64)(uintptr_t)target_sym_map[i].symbol_addr; + *(uint64 *)p = (uint64)(uintptr_t)target_sym_map[i].symbol_addr; p += 2; plt += get_plt_item_size(); } @@ -110,17 +113,18 @@ get_plt_table_size() return get_plt_item_size() * (sizeof(target_sym_map) / sizeof(SymbolMap)); } -#define SIGN_EXTEND_TO_INT64(val, bits, val_ext) do { \ - int64 m = (int64)((uint64)1 << (bits - 1)); \ - val_ext = ((int64)val ^ m) - m; \ -} while (0) +#define SIGN_EXTEND_TO_INT64(val, bits, val_ext) \ + do { \ + int64 m = (int64)((uint64)1 << (bits - 1)); \ + val_ext = ((int64)val ^ m) - m; \ + } while (0) #define Page(expr) ((expr) & ~0xFFF) static bool -check_reloc_offset(uint32 target_section_size, - uint64 reloc_offset, uint32 reloc_data_size, - char *error_buf, uint32 error_buf_size) +check_reloc_offset(uint32 target_section_size, uint64 reloc_offset, + uint32 reloc_data_size, char *error_buf, + uint32 error_buf_size) { if (!(reloc_offset < (uint64)target_section_size && reloc_offset + reloc_data_size <= (uint64)target_section_size)) { @@ -132,22 +136,21 @@ check_reloc_offset(uint32 target_section_size, } bool -apply_relocation(AOTModule *module, - uint8 *target_section_addr, uint32 target_section_size, - uint64 reloc_offset, uint64 reloc_addend, - uint32 reloc_type, void *symbol_addr, int32 symbol_index, - char *error_buf, uint32 error_buf_size) +apply_relocation(AOTModule *module, uint8 *target_section_addr, + uint32 target_section_size, uint64 reloc_offset, + uint64 reloc_addend, uint32 reloc_type, void *symbol_addr, + int32 symbol_index, char *error_buf, uint32 error_buf_size) { switch (reloc_type) { case R_AARCH64_CALL26: { - void *S, *P = (void*)(target_section_addr + reloc_offset); + void *S, *P = (void *)(target_section_addr + reloc_offset); int64 X, A, initial_addend; int32 insn, imm26; CHECK_RELOC_OFFSET(sizeof(int32)); - insn = *(int32*)P; + insn = *(int32 *)P; imm26 = insn & 0x3FFFFFF; SIGN_EXTEND_TO_INT64(imm26 << 2, 28, initial_addend); A = initial_addend; @@ -164,17 +167,18 @@ apply_relocation(AOTModule *module, else { uint8 *plt; if (reloc_addend > 0) { - set_error_buf(error_buf, error_buf_size, - "AOT module load failed: relocate to plt table " - "with reloc addend larger than 0 is unsupported."); - return false; + set_error_buf( + error_buf, error_buf_size, + "AOT module load failed: relocate to plt table " + "with reloc addend larger than 0 is unsupported."); + return false; } /* Symbol address is not an AOT function, * but a function of runtime or native. Its address is * beyond of the +-128MB space. Apply relocation with * the PLT which branch to the target symbol address. */ - S = plt = (uint8*)module->code + module->code_size + S = plt = (uint8 *)module->code + module->code_size - get_plt_table_size() + get_plt_item_size() * symbol_index; } @@ -191,7 +195,7 @@ apply_relocation(AOTModule *module, } /* write the imm26 back to instruction */ - *(int32*)P = (insn & 0xFC000000) | ((int32)((X >> 2) & 0x3FFFFFF)); + *(int32 *)P = (insn & 0xFC000000) | ((int32)((X >> 2) & 0x3FFFFFF)); break; } @@ -203,13 +207,14 @@ apply_relocation(AOTModule *module, case R_AARCH64_MOVW_UABS_G2_NC: case R_AARCH64_MOVW_UABS_G3: { - void *S = symbol_addr, *P = (void*)(target_section_addr + reloc_offset); + void *S = symbol_addr, + *P = (void *)(target_section_addr + reloc_offset); int64 X, A, initial_addend; int32 insn, imm16; CHECK_RELOC_OFFSET(sizeof(int32)); - insn = *(int32*)P; + insn = *(int32 *)P; imm16 = (insn >> 5) & 0xFFFF; SIGN_EXTEND_TO_INT64(imm16, 16, initial_addend); @@ -241,18 +246,22 @@ apply_relocation(AOTModule *module, switch (reloc_type) { case R_AARCH64_MOVW_UABS_G0: case R_AARCH64_MOVW_UABS_G0_NC: - *(int32*)P = (insn & 0xFFE0001F) | ((int32)((X & 0xFFFF) << 5)); + *(int32 *)P = + (insn & 0xFFE0001F) | ((int32)((X & 0xFFFF) << 5)); break; case R_AARCH64_MOVW_UABS_G1: case R_AARCH64_MOVW_UABS_G1_NC: - *(int32*)P = (insn & 0xFFE0001F) | ((int32)(((X >> 16) & 0xFFFF) << 5)); + *(int32 *)P = (insn & 0xFFE0001F) + | ((int32)(((X >> 16) & 0xFFFF) << 5)); break; case R_AARCH64_MOVW_UABS_G2: case R_AARCH64_MOVW_UABS_G2_NC: - *(int32*)P = (insn & 0xFFE0001F) | ((int32)(((X >> 32) & 0xFFFF) << 5)); + *(int32 *)P = (insn & 0xFFE0001F) + | ((int32)(((X >> 32) & 0xFFFF) << 5)); break; case R_AARCH64_MOVW_UABS_G3: - *(int32*)P = (insn & 0xFFE0001F) | ((int32)(((X >> 48) & 0xFFFF) << 5)); + *(int32 *)P = (insn & 0xFFE0001F) + | ((int32)(((X >> 48) & 0xFFFF) << 5)); break; default: bh_assert(0); @@ -264,13 +273,14 @@ apply_relocation(AOTModule *module, case R_AARCH64_ADR_PREL_PG_HI21: case R_AARCH64_ADR_PREL_PG_HI21_NC: { - void *S = symbol_addr, *P = (void*)(target_section_addr + reloc_offset); + void *S = symbol_addr, + *P = (void *)(target_section_addr + reloc_offset); int64 X, A, initial_addend; int32 insn, immhi19, immlo2, imm21; CHECK_RELOC_OFFSET(sizeof(int32)); - insn = *(int32*)P; + insn = *(int32 *)P; immhi19 = (insn >> 5) & 0x7FFFF; immlo2 = (insn >> 29) & 0x3; imm21 = (immhi19 << 2) | immlo2; @@ -290,20 +300,21 @@ apply_relocation(AOTModule *module, /* write the imm21 back to instruction */ immhi19 = (int32)(((X >> 12) >> 2) & 0x7FFFF); immlo2 = (int32)((X >> 12) & 0x3); - *(int32*)P = (insn & 0x9F00001F) | (immlo2 << 29) | (immhi19 << 5); + *(int32 *)P = (insn & 0x9F00001F) | (immlo2 << 29) | (immhi19 << 5); break; } case R_AARCH64_ADD_ABS_LO12_NC: { - void *S = symbol_addr, *P = (void*)(target_section_addr + reloc_offset); + void *S = symbol_addr, + *P = (void *)(target_section_addr + reloc_offset); int64 X, A, initial_addend; int32 insn, imm12; CHECK_RELOC_OFFSET(sizeof(int32)); - insn = *(int32*)P; + insn = *(int32 *)P; imm12 = (insn >> 10) & 0xFFF; SIGN_EXTEND_TO_INT64(imm12, 12, initial_addend); @@ -316,7 +327,7 @@ apply_relocation(AOTModule *module, /* No need to check overflow for this reloction type */ /* write the imm12 back to instruction */ - *(int32*)P = (insn & 0xFFC003FF) | ((int32)((X & 0xFFF) << 10)); + *(int32 *)P = (insn & 0xFFC003FF) | ((int32)((X & 0xFFF) << 10)); break; } @@ -326,13 +337,14 @@ apply_relocation(AOTModule *module, case R_AARCH64_LDST64_ABS_LO12_NC: case R_AARCH64_LDST128_ABS_LO12_NC: { - void *S = symbol_addr, *P = (void*)(target_section_addr + reloc_offset); + void *S = symbol_addr, + *P = (void *)(target_section_addr + reloc_offset); int64 X, A, initial_addend; int32 insn, imm12; CHECK_RELOC_OFFSET(sizeof(int32)); - insn = *(int32*)P; + insn = *(int32 *)P; imm12 = (insn >> 10) & 0xFFF; SIGN_EXTEND_TO_INT64(imm12, 12, initial_addend); @@ -347,19 +359,24 @@ apply_relocation(AOTModule *module, /* write the imm12 back to instruction */ switch (reloc_type) { case R_AARCH64_LDST8_ABS_LO12_NC: - *(int32*)P = (insn & 0xFFC003FF) | ((int32)((X & 0xFFF) << 10)); + *(int32 *)P = + (insn & 0xFFC003FF) | ((int32)((X & 0xFFF) << 10)); break; case R_AARCH64_LDST16_ABS_LO12_NC: - *(int32*)P = (insn & 0xFFC003FF) | ((int32)(((X & 0xFFF) >> 1) << 10)); + *(int32 *)P = (insn & 0xFFC003FF) + | ((int32)(((X & 0xFFF) >> 1) << 10)); break; case R_AARCH64_LDST32_ABS_LO12_NC: - *(int32*)P = (insn & 0xFFC003FF) | ((int32)(((X & 0xFFF) >> 2) << 10)); + *(int32 *)P = (insn & 0xFFC003FF) + | ((int32)(((X & 0xFFF) >> 2) << 10)); break; case R_AARCH64_LDST64_ABS_LO12_NC: - *(int32*)P = (insn & 0xFFC003FF) | ((int32)(((X & 0xFFF) >> 3) << 10)); + *(int32 *)P = (insn & 0xFFC003FF) + | ((int32)(((X & 0xFFF) >> 3) << 10)); break; case R_AARCH64_LDST128_ABS_LO12_NC: - *(int32*)P = (insn & 0xFFC003FF) | ((int32)(((X & 0xFFF) >> 4) << 10)); + *(int32 *)P = (insn & 0xFFC003FF) + | ((int32)(((X & 0xFFF) >> 4) << 10)); break; default: bh_assert(0); diff --git a/core/iwasm/aot/arch/aot_reloc_arc.c b/core/iwasm/aot/arch/aot_reloc_arc.c index d3dbcf21..6c23ac67 100644 --- a/core/iwasm/aot/arch/aot_reloc_arc.c +++ b/core/iwasm/aot/arch/aot_reloc_arc.c @@ -5,13 +5,14 @@ #include "aot_reloc.h" -#define R_ARC_S21H_PCREL 14 -#define R_ARC_S21W_PCREL 15 -#define R_ARC_S25H_PCREL 16 -#define R_ARC_S25W_PCREL 17 -#define R_ARC_32 4 -#define R_ARC_32_ME 27 +#define R_ARC_S21H_PCREL 14 +#define R_ARC_S21W_PCREL 15 +#define R_ARC_S25H_PCREL 16 +#define R_ARC_S25W_PCREL 17 +#define R_ARC_32 4 +#define R_ARC_32_ME 27 +/* clang-format off */ void __st_r13_to_r15(); void __st_r13_to_r16(); void __st_r13_to_r17(); @@ -56,10 +57,13 @@ void __subdf3(); void __subsf3(); void __truncdfsf2(); void __unorddf2(); +/* clang-format on */ static SymbolMap target_sym_map[] = { + /* clang-format off */ REG_COMMON_SYMBOLS REG_SYM(__st_r13_to_r15), + /* clang-format on */ REG_SYM(__st_r13_to_r16), REG_SYM(__st_r13_to_r17), REG_SYM(__st_r13_to_r18), @@ -81,29 +85,28 @@ static SymbolMap target_sym_map[] = { REG_SYM(__ld_r13_to_r23), REG_SYM(__ld_r13_to_r24), REG_SYM(__ld_r13_to_r25), - REG_SYM (__adddf3), - REG_SYM (__addsf3), - REG_SYM (__divdf3), - REG_SYM (__divdi3), - REG_SYM (__divsf3), - REG_SYM (__divsi3), - REG_SYM (__eqsf2), - REG_SYM (__extendsfdf2), - REG_SYM (__fixdfsi), - REG_SYM (__floatsidf), - REG_SYM (__floatsisf), - REG_SYM (__gedf2), - REG_SYM (__gtdf2), - REG_SYM (__ledf2), - REG_SYM (__lesf2), - REG_SYM (__ltdf2), - REG_SYM (__muldf3), - REG_SYM (__mulsf3), - REG_SYM (__subdf3), - REG_SYM (__subsf3), - REG_SYM (__truncdfsf2), - REG_SYM (__unorddf2), - + REG_SYM(__adddf3), + REG_SYM(__addsf3), + REG_SYM(__divdf3), + REG_SYM(__divdi3), + REG_SYM(__divsf3), + REG_SYM(__divsi3), + REG_SYM(__eqsf2), + REG_SYM(__extendsfdf2), + REG_SYM(__fixdfsi), + REG_SYM(__floatsidf), + REG_SYM(__floatsisf), + REG_SYM(__gedf2), + REG_SYM(__gtdf2), + REG_SYM(__ledf2), + REG_SYM(__lesf2), + REG_SYM(__ltdf2), + REG_SYM(__muldf3), + REG_SYM(__mulsf3), + REG_SYM(__subdf3), + REG_SYM(__subsf3), + REG_SYM(__truncdfsf2), + REG_SYM(__unorddf2), }; static void @@ -139,9 +142,9 @@ init_plt_table(uint8 *plt) } static bool -check_reloc_offset(uint32 target_section_size, - uint64 reloc_offset, uint32 reloc_data_size, - char *error_buf, uint32 error_buf_size) +check_reloc_offset(uint32 target_section_size, uint64 reloc_offset, + uint32 reloc_data_size, char *error_buf, + uint32 error_buf_size) { if (!(reloc_offset < (uint64)target_section_size && reloc_offset + reloc_data_size <= (uint64)target_section_size)) { @@ -159,11 +162,10 @@ middle_endian_convert(uint32 insn) } bool -apply_relocation(AOTModule *module, - uint8 *target_section_addr, uint32 target_section_size, - uint64 reloc_offset, uint64 reloc_addend, - uint32 reloc_type, void *symbol_addr, int32 symbol_index, - char *error_buf, uint32 error_buf_size) +apply_relocation(AOTModule *module, uint8 *target_section_addr, + uint32 target_section_size, uint64 reloc_offset, + uint64 reloc_addend, uint32 reloc_type, void *symbol_addr, + int32 symbol_index, char *error_buf, uint32 error_buf_size) { switch (reloc_type) { case R_ARC_S25W_PCREL: @@ -172,7 +174,7 @@ apply_relocation(AOTModule *module, int32 addend, value; uintptr_t S, A, P; - CHECK_RELOC_OFFSET(sizeof(void*)); + CHECK_RELOC_OFFSET(sizeof(void *)); /* Convert from middle endian */ insn = middle_endian_convert(insn); @@ -187,7 +189,7 @@ apply_relocation(AOTModule *module, addend = addend << 2; /* (S + A) - P */ - S = (uintptr_t)(uint8*)symbol_addr; + S = (uintptr_t)(uint8 *)symbol_addr; A = (uintptr_t)reloc_addend; P = (uintptr_t)(target_section_addr + reloc_offset); P &= (uintptr_t)~3; @@ -209,11 +211,10 @@ apply_relocation(AOTModule *module, { uint32 insn; - CHECK_RELOC_OFFSET(sizeof(void*)); + CHECK_RELOC_OFFSET(sizeof(void *)); /* (S + A) */ - insn = (uint32)(uintptr_t) - ((uint8*)symbol_addr + reloc_addend); + insn = (uint32)(uintptr_t)((uint8 *)symbol_addr + reloc_addend); if (reloc_type == R_ARC_32_ME) /* Convert to middle endian */ @@ -234,4 +235,3 @@ apply_relocation(AOTModule *module, } return true; } - diff --git a/core/iwasm/aot/arch/aot_reloc_arm.c b/core/iwasm/aot/arch/aot_reloc_arm.c index e3e2d1a7..5d5091c6 100644 --- a/core/iwasm/aot/arch/aot_reloc_arm.c +++ b/core/iwasm/aot/arch/aot_reloc_arm.c @@ -5,10 +5,11 @@ #include "aot_reloc.h" -#define R_ARM_CALL 28 /* PC relative 24 bit (BL, BLX). */ -#define R_ARM_JMP24 29 /* PC relative 24 bit (B/BL). */ -#define R_ARM_ABS32 2 /* Direct 32 bit */ +#define R_ARM_CALL 28 /* PC relative 24 bit (BL, BLX). */ +#define R_ARM_JMP24 29 /* PC relative 24 bit (B/BL). */ +#define R_ARM_ABS32 2 /* Direct 32 bit */ +/* clang-format off */ void __divdi3(); void __udivdi3(); void __moddi3(); @@ -54,11 +55,14 @@ void __aeabi_fcmple(); void __aeabi_fcmpge(); void __aeabi_f2iz(); void __aeabi_f2d(); +/* clang-format on */ static SymbolMap target_sym_map[] = { + /* clang-format off */ REG_COMMON_SYMBOLS /* compiler-rt symbols that come from compiler(e.g. gcc) */ REG_SYM(__divdi3), + /* clang-format on */ REG_SYM(__udivdi3), REG_SYM(__umoddi3), REG_SYM(__divsi3), @@ -122,7 +126,7 @@ get_target_symbol_map(uint32 *sym_num) void get_current_target(char *target_buf, uint32 target_buf_size) { - const char * s = BUILD_TARGET; + const char *s = BUILD_TARGET; size_t s_size = sizeof(BUILD_TARGET); char *d = target_buf; @@ -131,14 +135,14 @@ get_current_target(char *target_buf, uint32 target_buf_size) s = BUILD_TARGET_ARM_DEFAULT; s_size = sizeof(BUILD_TARGET_ARM_DEFAULT); } - if(target_buf_size < s_size){ + if (target_buf_size < s_size) { s_size = target_buf_size; } while (--s_size) { if (*s >= 'A' && *s <= 'Z') *d++ = *s++ + 'a' - 'A'; else - *d++ = *s++ ; + *d++ = *s++; } /* Ensure the string is null byte ('\0') terminated */ *d = '\0'; @@ -163,7 +167,7 @@ init_plt_table(uint8 *plt) { uint32 i, num = sizeof(target_sym_map) / sizeof(SymbolMap); for (i = 0; i < num; i++) { - uint32 *p = (uint32*)plt; + uint32 *p = (uint32 *)plt; /* ldr pc, [pc] */ *p++ = 0xe59ff000; /* nop */ @@ -175,9 +179,9 @@ init_plt_table(uint8 *plt) } static bool -check_reloc_offset(uint32 target_section_size, - uint64 reloc_offset, uint32 reloc_data_size, - char *error_buf, uint32 error_buf_size) +check_reloc_offset(uint32 target_section_size, uint64 reloc_offset, + uint32 reloc_data_size, char *error_buf, + uint32 error_buf_size) { if (!(reloc_offset < (uint64)target_section_size && reloc_offset + reloc_data_size <= (uint64)target_section_size)) { @@ -189,11 +193,10 @@ check_reloc_offset(uint32 target_section_size, } bool -apply_relocation(AOTModule *module, - uint8 *target_section_addr, uint32 target_section_size, - uint64 reloc_offset, uint64 reloc_addend, - uint32 reloc_type, void *symbol_addr, int32 symbol_index, - char *error_buf, uint32 error_buf_size) +apply_relocation(AOTModule *module, uint8 *target_section_addr, + uint32 target_section_size, uint64 reloc_offset, + uint64 reloc_addend, uint32 reloc_type, void *symbol_addr, + int32 symbol_index, char *error_buf, uint32 error_buf_size) { switch (reloc_type) { case R_ARM_CALL: @@ -201,10 +204,10 @@ apply_relocation(AOTModule *module, { intptr_t result; int32 RESULT_MASK = 0x03FFFFFE; - int32 insn = *(int32*)(target_section_addr + reloc_offset); + int32 insn = *(int32 *)(target_section_addr + reloc_offset); /* Initial addend: sign_extend(insn[23:0] << 2) */ - int32 initial_addend = ((insn & 0xFFFFFF) << 2) - | ((insn & 0x800000) ? 0xFC000000 : 0); + int32 initial_addend = + ((insn & 0xFFFFFF) << 2) | ((insn & 0x800000) ? 0xFC000000 : 0); CHECK_RELOC_OFFSET(sizeof(int32)); @@ -214,17 +217,18 @@ apply_relocation(AOTModule *module, * Suppose the symbol address is in +-32MB relative * to the relocation address. */ - /* operation: ((S + A) | T) - P where S is symbol address and T is 0 */ - result = (intptr_t) - ((uint8*)symbol_addr + reloc_addend - - (target_section_addr + reloc_offset)); + /* operation: ((S + A) | T) - P where S is symbol address and T + * is 0 */ + result = (intptr_t)((uint8 *)symbol_addr + reloc_addend + - (target_section_addr + reloc_offset)); } else { if (reloc_addend > 0) { - set_error_buf(error_buf, error_buf_size, - "AOT module load failed: relocate to plt table " - "with reloc addend larger than 0 is unsupported."); - return false; + set_error_buf( + error_buf, error_buf_size, + "AOT module load failed: relocate to plt table " + "with reloc addend larger than 0 is unsupported."); + return false; } /* Symbol address is not an AOT function, @@ -232,12 +236,13 @@ apply_relocation(AOTModule *module, * beyond of the +-32MB space. Apply relocation with * the PLT which branch to the target symbol address. */ - /* operation: ((S + A) | T) - P where S is PLT address and T is 0 */ - uint8 *plt = (uint8*)module->code + module->code_size - get_plt_table_size() + /* operation: ((S + A) | T) - P where S is PLT address and T is + * 0 */ + uint8 *plt = (uint8 *)module->code + module->code_size + - get_plt_table_size() + get_plt_item_size() * symbol_index; - result = (intptr_t) - (plt + reloc_addend - - (target_section_addr + reloc_offset)); + result = (intptr_t)(plt + reloc_addend + - (target_section_addr + reloc_offset)); } result += initial_addend; @@ -250,20 +255,20 @@ apply_relocation(AOTModule *module, return false; } - *(int32*)(target_section_addr + reloc_offset) = - (int32) - ((insn & 0xff000000) - | (((int32)result & RESULT_MASK) >> 2)); + *(int32 *)(target_section_addr + reloc_offset) = + (int32)((insn & 0xff000000) + | (((int32)result & RESULT_MASK) >> 2)); break; } case R_ARM_ABS32: { intptr_t initial_addend; /* (S + A) | T where T is 0 */ - CHECK_RELOC_OFFSET(sizeof(void*)); - initial_addend = *(intptr_t*)(target_section_addr + (uint32)reloc_offset); - *(uint8**)(target_section_addr + reloc_offset) - = (uint8*)symbol_addr + initial_addend + reloc_addend; + CHECK_RELOC_OFFSET(sizeof(void *)); + initial_addend = + *(intptr_t *)(target_section_addr + (uint32)reloc_offset); + *(uint8 **)(target_section_addr + reloc_offset) = + (uint8 *)symbol_addr + initial_addend + reloc_addend; break; } @@ -278,4 +283,3 @@ apply_relocation(AOTModule *module, return true; } - diff --git a/core/iwasm/aot/arch/aot_reloc_mips.c b/core/iwasm/aot/arch/aot_reloc_mips.c index c1b3fa54..8e43cc03 100644 --- a/core/iwasm/aot/arch/aot_reloc_mips.c +++ b/core/iwasm/aot/arch/aot_reloc_mips.c @@ -5,12 +5,14 @@ #include "aot_reloc.h" -#define R_MIPS_32 2 /* Direct 32 bit */ -#define R_MIPS_26 4 /* Direct 26 bit shifted */ +#define R_MIPS_32 2 /* Direct 32 bit */ +#define R_MIPS_26 4 /* Direct 26 bit shifted */ +/* clang-format off */ static SymbolMap target_sym_map[] = { REG_COMMON_SYMBOLS }; +/* clang-format on */ SymbolMap * get_target_symbol_map(uint32 *sym_num) @@ -44,11 +46,10 @@ get_plt_table_size() } bool -apply_relocation(AOTModule *module, - uint8 *target_section_addr, uint32 target_section_size, - uint64 reloc_offset, uint64 reloc_addend, - uint32 reloc_type, void *symbol_addr, int32 symbol_index, - char *error_buf, uint32 error_buf_size) +apply_relocation(AOTModule *module, uint8 *target_section_addr, + uint32 target_section_size, uint64 reloc_offset, + uint64 reloc_addend, uint32 reloc_type, void *symbol_addr, + int32 symbol_index, char *error_buf, uint32 error_buf_size) { switch (reloc_type) { /* TODO: implement relocation for mips */ @@ -66,4 +67,3 @@ apply_relocation(AOTModule *module, return true; } - diff --git a/core/iwasm/aot/arch/aot_reloc_riscv.c b/core/iwasm/aot/arch/aot_reloc_riscv.c index cb09b810..05b8d734 100644 --- a/core/iwasm/aot/arch/aot_reloc_riscv.c +++ b/core/iwasm/aot/arch/aot_reloc_riscv.c @@ -5,25 +5,29 @@ #include "aot_reloc.h" -#define R_RISCV_32 1 -#define R_RISCV_64 2 -#define R_RISCV_CALL 18 +#define R_RISCV_32 1 +#define R_RISCV_64 2 +#define R_RISCV_CALL 18 #define R_RISCV_CALL_PLT 19 -#define R_RISCV_HI20 26 -#define R_RISCV_LO12_I 27 -#define R_RISCV_LO12_S 28 +#define R_RISCV_HI20 26 +#define R_RISCV_LO12_I 27 +#define R_RISCV_LO12_S 28 #define RV_OPCODE_SW 0x23 +/* clang-format off */ void __divdi3(); void __moddi3(); void __muldi3(); void __udivdi3(); void __umoddi3(); +/* clang-format on */ static SymbolMap target_sym_map[] = { + /* clang-format off */ REG_COMMON_SYMBOLS REG_SYM(__divdi3), + /* clang-format on */ REG_SYM(__moddi3), REG_SYM(__muldi3), REG_SYM(__udivdi3), @@ -132,20 +136,20 @@ init_plt_table(uint8 *plt) for (i = 0; i < num; i++) { p = plt; /* auipc t1, 0 */ - *(uint16*)p = 0x0317; + *(uint16 *)p = 0x0317; p += 2; - *(uint16*)p = 0x0000; + *(uint16 *)p = 0x0000; p += 2; /* ld t1, 8(t1) */ - *(uint16*)p = 0x3303; + *(uint16 *)p = 0x3303; p += 2; - *(uint16*)p = 0x00C3; + *(uint16 *)p = 0x00C3; p += 2; /* jr t1 */ - *(uint16*)p = 0x8302; + *(uint16 *)p = 0x8302; p += 2; /* nop */ - *(uint16*)p = 0x0001; + *(uint16 *)p = 0x0001; p += 2; bh_memcpy_s(p, 8, &target_sym_map[i].symbol_addr, 8); p += 8; @@ -159,15 +163,15 @@ typedef struct RelocTypeStrMap { char *reloc_str; } RelocTypeStrMap; -#define RELOC_TYPE_MAP(reloc_type) { reloc_type, #reloc_type } +#define RELOC_TYPE_MAP(reloc_type) \ + { \ + reloc_type, #reloc_type \ + } static RelocTypeStrMap reloc_type_str_maps[] = { - RELOC_TYPE_MAP(R_RISCV_32), - RELOC_TYPE_MAP(R_RISCV_CALL), - RELOC_TYPE_MAP(R_RISCV_CALL_PLT), - RELOC_TYPE_MAP(R_RISCV_HI20), - RELOC_TYPE_MAP(R_RISCV_LO12_I), - RELOC_TYPE_MAP(R_RISCV_LO12_S), + RELOC_TYPE_MAP(R_RISCV_32), RELOC_TYPE_MAP(R_RISCV_CALL), + RELOC_TYPE_MAP(R_RISCV_CALL_PLT), RELOC_TYPE_MAP(R_RISCV_HI20), + RELOC_TYPE_MAP(R_RISCV_LO12_I), RELOC_TYPE_MAP(R_RISCV_LO12_S), }; static const char * @@ -175,7 +179,8 @@ reloc_type_to_str(uint32 reloc_type) { uint32 i; - for (i = 0; i < sizeof(reloc_type_str_maps) / sizeof(RelocTypeStrMap); i++) { + for (i = 0; i < sizeof(reloc_type_str_maps) / sizeof(RelocTypeStrMap); + i++) { if (reloc_type_str_maps[i].reloc_type == reloc_type) return reloc_type_str_maps[i].reloc_str; } @@ -184,9 +189,9 @@ reloc_type_to_str(uint32 reloc_type) } static bool -check_reloc_offset(uint32 target_section_size, - uint64 reloc_offset, uint32 reloc_data_size, - char *error_buf, uint32 error_buf_size) +check_reloc_offset(uint32 target_section_size, uint64 reloc_offset, + uint32 reloc_data_size, char *error_buf, + uint32 error_buf_size) { if (!(reloc_offset < (uint64)target_section_size && reloc_offset + reloc_data_size <= (uint64)target_section_size)) { @@ -198,11 +203,10 @@ check_reloc_offset(uint32 target_section_size, } bool -apply_relocation(AOTModule *module, - uint8 *target_section_addr, uint32 target_section_size, - uint64 reloc_offset, uint64 reloc_addend, uint32 reloc_type, - void *symbol_addr, int32 symbol_index, - char *error_buf, uint32 error_buf_size) +apply_relocation(AOTModule *module, uint8 *target_section_addr, + uint32 target_section_size, uint64 reloc_offset, + uint64 reloc_addend, uint32 reloc_type, void *symbol_addr, + int32 symbol_index, char *error_buf, uint32 error_buf_size) { int32 val, imm_hi, imm_lo, insn; uint8 *addr = target_section_addr + reloc_offset; @@ -211,7 +215,8 @@ apply_relocation(AOTModule *module, switch (reloc_type) { case R_RISCV_32: { - uint32 val_32 = (uint32)(uintptr_t)((uint8 *)symbol_addr + reloc_addend); + uint32 val_32 = + (uint32)(uintptr_t)((uint8 *)symbol_addr + reloc_addend); CHECK_RELOC_OFFSET(sizeof(uint32)); if (val_32 != (uintptr_t)((uint8 *)symbol_addr + reloc_addend)) { @@ -223,7 +228,8 @@ apply_relocation(AOTModule *module, } case R_RISCV_64: { - uint64 val_64 = (uint64)(uintptr_t)((uint8 *)symbol_addr + reloc_addend); + uint64 val_64 = + (uint64)(uintptr_t)((uint8 *)symbol_addr + reloc_addend); CHECK_RELOC_OFFSET(sizeof(uint64)); bh_memcpy_s(addr, 8, &val_64, 8); break; @@ -237,10 +243,10 @@ apply_relocation(AOTModule *module, if (val != (intptr_t)((uint8 *)symbol_addr - addr)) { if (symbol_index >= 0) { /* Call runtime function by plt code */ - symbol_addr = (uint8*)module->code + module->code_size + symbol_addr = (uint8 *)module->code + module->code_size - get_plt_table_size() + get_plt_item_size() * symbol_index; - val = (int32)(intptr_t)((uint8*)symbol_addr - addr); + val = (int32)(intptr_t)((uint8 *)symbol_addr - addr); } } @@ -253,8 +259,8 @@ apply_relocation(AOTModule *module, rv_add_val((uint16 *)addr, (imm_hi << 12)); if ((rv_get_val((uint16 *)(addr + 4)) & 0x7f) == RV_OPCODE_SW) { /* Adjust imm for SW : S-type */ - val = - (((int32)imm_lo >> 5) << 25) + (((int32)imm_lo & 0x1f) << 7); + val = (((int32)imm_lo >> 5) << 25) + + (((int32)imm_lo & 0x1f) << 7); rv_add_val((uint16 *)(addr + 4), val); } @@ -310,8 +316,7 @@ apply_relocation(AOTModule *module, addr = target_section_addr + reloc_offset; rv_calc_imm(val, &imm_hi, &imm_lo); - val = - (((int32)imm_lo >> 5) << 25) + (((int32)imm_lo & 0x1f) << 7); + val = (((int32)imm_lo >> 5) << 25) + (((int32)imm_lo & 0x1f) << 7); rv_add_val((uint16 *)addr, val); break; } diff --git a/core/iwasm/aot/arch/aot_reloc_thumb.c b/core/iwasm/aot/arch/aot_reloc_thumb.c index 19ed62c0..1da8c86d 100644 --- a/core/iwasm/aot/arch/aot_reloc_thumb.c +++ b/core/iwasm/aot/arch/aot_reloc_thumb.c @@ -5,9 +5,10 @@ #include "aot_reloc.h" -#define R_ARM_THM_CALL 10 /* PC relative (Thumb BL and ARMv5 Thumb BLX). */ -#define R_ARM_THM_JMP24 30 /* B.W */ +#define R_ARM_THM_CALL 10 /* PC relative (Thumb BL and ARMv5 Thumb BLX). */ +#define R_ARM_THM_JMP24 30 /* B.W */ +/* clang-format off */ void __ltdf2(); void __adddf3(); void __eqdf2(); @@ -69,11 +70,14 @@ void __aeabi_fcmple(); void __aeabi_fcmpge(); void __aeabi_f2iz(); void __aeabi_f2d(); +/* clang-format on */ static SymbolMap target_sym_map[] = { + /* clang-format off */ REG_COMMON_SYMBOLS /* compiler-rt symbols that come from compiler(e.g. gcc) */ REG_SYM(__ltdf2), + /* clang-format on */ REG_SYM(__adddf3), REG_SYM(__eqdf2), REG_SYM(__unorddf2), @@ -162,14 +166,14 @@ get_current_target(char *target_buf, uint32 target_buf_size) s = BUILD_TARGET_THUMB_V4T; s_size = sizeof(BUILD_TARGET_THUMB_V4T); } - if(target_buf_size < s_size){ + if (target_buf_size < s_size) { s_size = target_buf_size; } while (--s_size) { if (*s >= 'A' && *s <= 'Z') *d++ = *s++ + 'a' - 'A'; else - *d++ = *s++ ; + *d++ = *s++; } /* Ensure the string is null byte ('\0') terminated */ *d = '\0'; @@ -194,7 +198,7 @@ init_plt_table(uint8 *plt) { uint32 i, num = sizeof(target_sym_map) / sizeof(SymbolMap); for (i = 0; i < num; i++) { - uint16 *p = (uint16*)plt; + uint16 *p = (uint16 *)plt; /* nop */ *p++ = 0xbf00; /* push {r4} */ @@ -212,15 +216,15 @@ init_plt_table(uint8 *plt) /* nop */ *p++ = 0xbf00; /* symbol addr */ - *(uint32*)p = (uint32)(uintptr_t)target_sym_map[i].symbol_addr; + *(uint32 *)p = (uint32)(uintptr_t)target_sym_map[i].symbol_addr; plt += get_plt_item_size(); } } static bool -check_reloc_offset(uint32 target_section_size, - uint64 reloc_offset, uint32 reloc_data_size, - char *error_buf, uint32 error_buf_size) +check_reloc_offset(uint32 target_section_size, uint64 reloc_offset, + uint32 reloc_data_size, char *error_buf, + uint32 error_buf_size) { if (!(reloc_offset < (uint64)target_section_size && reloc_offset + reloc_data_size <= (uint64)target_section_size)) { @@ -232,11 +236,10 @@ check_reloc_offset(uint32 target_section_size, } bool -apply_relocation(AOTModule *module, - uint8 *target_section_addr, uint32 target_section_size, - uint64 reloc_offset, uint64 reloc_addend, - uint32 reloc_type, void *symbol_addr, int32 symbol_index, - char *error_buf, uint32 error_buf_size) +apply_relocation(AOTModule *module, uint8 *target_section_addr, + uint32 target_section_size, uint64 reloc_offset, + uint64 reloc_addend, uint32 reloc_type, void *symbol_addr, + int32 symbol_index, char *error_buf, uint32 error_buf_size) { switch (reloc_type) { case R_ARM_THM_CALL: @@ -250,7 +253,7 @@ apply_relocation(AOTModule *module, CHECK_RELOC_OFFSET(sizeof(int32)); - reloc_addr = (int16*)(target_section_addr + reloc_offset); + reloc_addr = (int16 *)(target_section_addr + reloc_offset); initial_addend_0 = (*reloc_addr) & 0x7FF; initial_addend_1 = (*(reloc_addr + 1)) & 0x7FF; sign = (initial_addend_0 & 0x400) ? true : false; @@ -263,16 +266,20 @@ apply_relocation(AOTModule *module, * Suppose the symbol address is in +-4MB relative * to the relocation address. */ - /* operation: ((S + A) | T) - P where S is symbol address and T is 1 */ - result = (int32)(((intptr_t)((uint8*)symbol_addr + reloc_addend) | 1) - - (intptr_t)(target_section_addr + reloc_offset)); + /* operation: ((S + A) | T) - P where S is symbol address + and T is 1 */ + result = + (int32)(((intptr_t)((uint8 *)symbol_addr + reloc_addend) + | 1) + - (intptr_t)(target_section_addr + reloc_offset)); } else { if (reloc_addend > 0) { - set_error_buf(error_buf, error_buf_size, - "AOT module load failed: relocate to plt table " - "with reloc addend larger than 0 is unsupported."); - return false; + set_error_buf( + error_buf, error_buf_size, + "AOT module load failed: relocate to plt table " + "with reloc addend larger than 0 is unsupported."); + return false; } /* Symbol address is not an AOT function, @@ -280,11 +287,14 @@ apply_relocation(AOTModule *module, * beyond of the +-4MB space. Apply relocation with * the PLT which branch to the target symbol address. */ - /* operation: ((S + A) | T) - P where S is PLT address and T is 1 */ - uint8 *plt = (uint8*)module->code + module->code_size - get_plt_table_size() + /* operation: ((S + A) | T) - P where S is PLT address + and T is 1 */ + uint8 *plt = (uint8 *)module->code + module->code_size + - get_plt_table_size() + get_plt_item_size() * symbol_index + 1; - result = (int32)(((intptr_t)plt | 1) - - (intptr_t)(target_section_addr + reloc_offset)); + result = + (int32)(((intptr_t)plt | 1) + - (intptr_t)(target_section_addr + reloc_offset)); } result += initial_addend; @@ -316,4 +326,3 @@ apply_relocation(AOTModule *module, } return true; } - diff --git a/core/iwasm/aot/arch/aot_reloc_x86_32.c b/core/iwasm/aot/arch/aot_reloc_x86_32.c index 2b13b1da..78446823 100644 --- a/core/iwasm/aot/arch/aot_reloc_x86_32.c +++ b/core/iwasm/aot/arch/aot_reloc_x86_32.c @@ -5,17 +5,19 @@ #include "aot_reloc.h" -#define R_386_32 1 /* Direct 32 bit */ -#define R_386_PC32 2 /* PC relative 32 bit */ +#define R_386_32 1 /* Direct 32 bit */ +#define R_386_PC32 2 /* PC relative 32 bit */ #if !defined(_WIN32) && !defined(_WIN32_) +/* clang-format off */ void __divdi3(); void __udivdi3(); void __moddi3(); void __umoddi3(); +/* clang-format on */ #else -#pragma function (floor) -#pragma function (ceil) +#pragma function(floor) +#pragma function(ceil) static int64 __divdi3(int64 a, int64 b) @@ -42,6 +44,7 @@ __umoddi3(uint64 a, uint64 b) } #endif +/* clang-format off */ static SymbolMap target_sym_map[] = { REG_COMMON_SYMBOLS /* compiler-rt symbols that come from compiler(e.g. gcc) */ @@ -50,6 +53,7 @@ static SymbolMap target_sym_map[] = { REG_SYM(__moddi3), REG_SYM(__umoddi3) }; +/* clang-format on */ static void set_error_buf(char *error_buf, uint32 error_buf_size, const char *string) @@ -84,9 +88,9 @@ init_plt_table(uint8 *plt) } static bool -check_reloc_offset(uint32 target_section_size, - uint64 reloc_offset, uint32 reloc_data_size, - char *error_buf, uint32 error_buf_size) +check_reloc_offset(uint32 target_section_size, uint64 reloc_offset, + uint32 reloc_data_size, char *error_buf, + uint32 error_buf_size) { if (!(reloc_offset < (uint64)target_section_size && reloc_offset + reloc_data_size <= (uint64)target_section_size)) { @@ -98,21 +102,20 @@ check_reloc_offset(uint32 target_section_size, } bool -apply_relocation(AOTModule *module, - uint8 *target_section_addr, uint32 target_section_size, - uint64 reloc_offset, uint64 reloc_addend, - uint32 reloc_type, void *symbol_addr, int32 symbol_index, - char *error_buf, uint32 error_buf_size) +apply_relocation(AOTModule *module, uint8 *target_section_addr, + uint32 target_section_size, uint64 reloc_offset, + uint64 reloc_addend, uint32 reloc_type, void *symbol_addr, + int32 symbol_index, char *error_buf, uint32 error_buf_size) { switch (reloc_type) { case R_386_32: { intptr_t value; - CHECK_RELOC_OFFSET(sizeof(void*)); - value = *(intptr_t*)(target_section_addr + (uint32)reloc_offset); - *(uint8**)(target_section_addr + reloc_offset) - = (uint8*)symbol_addr + reloc_addend + value; /* S + A */ + CHECK_RELOC_OFFSET(sizeof(void *)); + value = *(intptr_t *)(target_section_addr + (uint32)reloc_offset); + *(uint8 **)(target_section_addr + reloc_offset) = + (uint8 *)symbol_addr + reloc_addend + value; /* S + A */ break; } @@ -120,12 +123,12 @@ apply_relocation(AOTModule *module, { int32 value; - CHECK_RELOC_OFFSET(sizeof(void*)); - value = *(int32*)(target_section_addr + (uint32)reloc_offset); - *(uint32*)(target_section_addr + (uint32)reloc_offset) = (uint32) - ((uint8*)symbol_addr + (uint32)reloc_addend - - (uint8*)(target_section_addr + (uint32)reloc_offset) - + value); /* S + A - P */ + CHECK_RELOC_OFFSET(sizeof(void *)); + value = *(int32 *)(target_section_addr + (uint32)reloc_offset); + *(uint32 *)(target_section_addr + (uint32)reloc_offset) = + (uint32)((uint8 *)symbol_addr + (uint32)reloc_addend + - (uint8 *)(target_section_addr + (uint32)reloc_offset) + + value); /* S + A - P */ break; } @@ -139,4 +142,3 @@ apply_relocation(AOTModule *module, } return true; } - diff --git a/core/iwasm/aot/arch/aot_reloc_x86_64.c b/core/iwasm/aot/arch/aot_reloc_x86_64.c index a04b6a6e..be5d09f8 100644 --- a/core/iwasm/aot/arch/aot_reloc_x86_64.c +++ b/core/iwasm/aot/arch/aot_reloc_x86_64.c @@ -6,30 +6,34 @@ #include "aot_reloc.h" #if !defined(BH_PLATFORM_WINDOWS) -#define R_X86_64_64 1 /* Direct 64 bit */ -#define R_X86_64_PC32 2 /* PC relative 32 bit signed */ -#define R_X86_64_PLT32 4 /* 32 bit PLT address */ -#define R_X86_64_32 10 /* Direct 32 bit zero extended */ -#define R_X86_64_32S 11 /* Direct 32 bit sign extended */ +#define R_X86_64_64 1 /* Direct 64 bit */ +#define R_X86_64_PC32 2 /* PC relative 32 bit signed */ +#define R_X86_64_PLT32 4 /* 32 bit PLT address */ +#define R_X86_64_32 10 /* Direct 32 bit zero extended */ +#define R_X86_64_32S 11 /* Direct 32 bit sign extended */ #else #ifndef IMAGE_REL_AMD64_ADDR64 #define IMAGE_REL_AMD64_ADDR64 1 /* The 64-bit VA of the relocation target */ #define IMAGE_REL_AMD64_ADDR32 2 /* The 32-bit VA of the relocation target */ +/* clang-format off */ #define IMAGE_REL_AMD64_REL32 4 /* The 32-bit relative address from the byte following the relocation*/ +/* clang-format on */ #endif #endif #if defined(BH_PLATFORM_WINDOWS) -#pragma function (floor) -#pragma function (ceil) -#pragma function (floorf) -#pragma function (ceilf) +#pragma function(floor) +#pragma function(ceil) +#pragma function(floorf) +#pragma function(ceilf) #endif +/* clang-format off */ static SymbolMap target_sym_map[] = { REG_COMMON_SYMBOLS }; +/* clang-format on */ static void set_error_buf(char *error_buf, uint32 error_buf_size, const char *string) @@ -61,8 +65,8 @@ get_plt_item_size() uint32 get_plt_table_size() { - uint32 size = get_plt_item_size() - * (sizeof(target_sym_map) / sizeof(SymbolMap)); + uint32 size = + get_plt_item_size() * (sizeof(target_sym_map) / sizeof(SymbolMap)); #if defined(OS_ENABLE_HW_BOUND_CHECK) && defined(BH_PLATFORM_WINDOWS) size += get_plt_item_size() + sizeof(AOTUnwindInfo); #endif @@ -80,7 +84,7 @@ init_plt_table(uint8 *plt) /* mov symbol_addr, rax */ *p++ = 0x48; *p++ = 0xB8; - *(uint64*)p = (uint64)(uintptr_t)target_sym_map[i].symbol_addr; + *(uint64 *)p = (uint64)(uintptr_t)target_sym_map[i].symbol_addr; p += sizeof(uint64); /* jmp rax */ *p++ = 0xFF; @@ -92,19 +96,19 @@ init_plt_table(uint8 *plt) p = plt; /* mov exception_handler, rax */ *p++ = 0x48; - *p++ = 0xB8; - *(uint64*)p = 0;/*(uint64)(uintptr_t)aot_exception_handler;*/ + *p++ = 0xB8; + *(uint64 *)p = 0; /*(uint64)(uintptr_t)aot_exception_handler;*/ p += sizeof(uint64); /* jmp rax */ - *p++ = 0xFF; - *p++ = 0xE0; + *p++ = 0xFF; + *p++ = 0xE0; #endif } static bool -check_reloc_offset(uint32 target_section_size, - uint64 reloc_offset, uint32 reloc_data_size, - char *error_buf, uint32 error_buf_size) +check_reloc_offset(uint32 target_section_size, uint64 reloc_offset, + uint32 reloc_data_size, char *error_buf, + uint32 error_buf_size) { if (!(reloc_offset < (uint64)target_section_size && reloc_offset + reloc_data_size <= (uint64)target_section_size)) { @@ -116,11 +120,10 @@ check_reloc_offset(uint32 target_section_size, } bool -apply_relocation(AOTModule *module, - uint8 *target_section_addr, uint32 target_section_size, - uint64 reloc_offset, uint64 reloc_addend, - uint32 reloc_type, void *symbol_addr, int32 symbol_index, - char *error_buf, uint32 error_buf_size) +apply_relocation(AOTModule *module, uint8 *target_section_addr, + uint32 target_section_size, uint64 reloc_offset, + uint64 reloc_addend, uint32 reloc_type, void *symbol_addr, + int32 symbol_index, char *error_buf, uint32 error_buf_size) { switch (reloc_type) { #if !defined(BH_PLATFORM_WINDOWS) @@ -131,10 +134,10 @@ apply_relocation(AOTModule *module, { intptr_t value; - CHECK_RELOC_OFFSET(sizeof(void*)); - value = *(intptr_t*)(target_section_addr + (uint32)reloc_offset); - *(uint8**)(target_section_addr + reloc_offset) - = (uint8*)symbol_addr + reloc_addend + value; /* S + A */ + CHECK_RELOC_OFFSET(sizeof(void *)); + value = *(intptr_t *)(target_section_addr + (uint32)reloc_offset); + *(uint8 **)(target_section_addr + reloc_offset) = + (uint8 *)symbol_addr + reloc_addend + value; /* S + A */ break; } #if defined(BH_PLATFORM_WINDOWS) @@ -144,14 +147,14 @@ apply_relocation(AOTModule *module, uintptr_t target_addr; CHECK_RELOC_OFFSET(sizeof(void *)); - value = *(int32*)(target_section_addr + (uint32)reloc_offset); + value = *(int32 *)(target_section_addr + (uint32)reloc_offset); target_addr = (uintptr_t)symbol_addr + reloc_addend + value; if ((int32)target_addr != target_addr) { - set_error_buf( - error_buf, error_buf_size, - "AOT module load failed: " - "relocation truncated to fit IMAGE_REL_AMD64_ADDR32 failed. " - "Try using wamrc with --size-level=1 option."); + set_error_buf(error_buf, error_buf_size, + "AOT module load failed: " + "relocation truncated to fit " + "IMAGE_REL_AMD64_ADDR32 failed. " + "Try using wamrc with --size-level=1 option."); return false; } @@ -162,20 +165,21 @@ apply_relocation(AOTModule *module, #if !defined(BH_PLATFORM_WINDOWS) case R_X86_64_PC32: { - intptr_t target_addr = (intptr_t) /* S + A - P */ - ((uint8*)symbol_addr + reloc_addend - - (target_section_addr + reloc_offset)); + intptr_t target_addr = (intptr_t) /* S + A - P */ + ((uint8 *)symbol_addr + reloc_addend + - (target_section_addr + reloc_offset)); CHECK_RELOC_OFFSET(sizeof(int32)); if ((int32)target_addr != target_addr) { - set_error_buf(error_buf, error_buf_size, - "AOT module load failed: " - "relocation truncated to fit R_X86_64_PC32 failed. " - "Try using wamrc with --size-level=1 option."); + set_error_buf( + error_buf, error_buf_size, + "AOT module load failed: " + "relocation truncated to fit R_X86_64_PC32 failed. " + "Try using wamrc with --size-level=1 option."); return false; } - *(int32*)(target_section_addr + reloc_offset) = (int32)target_addr; + *(int32 *)(target_section_addr + reloc_offset) = (int32)target_addr; break; } case R_X86_64_32: @@ -183,7 +187,7 @@ apply_relocation(AOTModule *module, { char buf[128]; uintptr_t target_addr = (uintptr_t) /* S + A */ - ((uint8*)symbol_addr + reloc_addend); + ((uint8 *)symbol_addr + reloc_addend); CHECK_RELOC_OFFSET(sizeof(int32)); @@ -192,16 +196,16 @@ apply_relocation(AOTModule *module, || (reloc_type == R_X86_64_32S && (int32)target_addr != (int64)target_addr)) { snprintf(buf, sizeof(buf), - "AOT module load failed: " - "relocation truncated to fit %s failed. " - "Try using wamrc with --size-level=1 option.", - reloc_type == R_X86_64_32 - ? "R_X86_64_32" : "R_X86_64_32S"); + "AOT module load failed: " + "relocation truncated to fit %s failed. " + "Try using wamrc with --size-level=1 option.", + reloc_type == R_X86_64_32 ? "R_X86_64_32" + : "R_X86_64_32S"); set_error_buf(error_buf, error_buf_size, buf); return false; } - *(int32*)(target_section_addr + reloc_offset) = (int32)target_addr; + *(int32 *)(target_section_addr + reloc_offset) = (int32)target_addr; break; } #endif @@ -217,16 +221,16 @@ apply_relocation(AOTModule *module, CHECK_RELOC_OFFSET(sizeof(int32)); if (symbol_index >= 0) { - plt = (uint8*)module->code + module->code_size - get_plt_table_size() + plt = (uint8 *)module->code + module->code_size + - get_plt_table_size() + get_plt_item_size() * symbol_index; - target_addr = (intptr_t) /* L + A - P */ - (plt + reloc_addend - - (target_section_addr + reloc_offset)); + target_addr = (intptr_t) /* L + A - P */ + (plt + reloc_addend - (target_section_addr + reloc_offset)); } else { - target_addr = (intptr_t) /* L + A - P */ - ((uint8*)symbol_addr + reloc_addend - - (target_section_addr + reloc_offset)); + target_addr = (intptr_t) /* L + A - P */ + ((uint8 *)symbol_addr + reloc_addend + - (target_section_addr + reloc_offset)); } #if defined(BH_PLATFORM_WINDOWS) @@ -244,7 +248,7 @@ apply_relocation(AOTModule *module, "Try using wamrc with --size-level=1 option."); return false; } - *(int32*)(target_section_addr + reloc_offset) = (int32)target_addr; + *(int32 *)(target_section_addr + reloc_offset) = (int32)target_addr; break; } @@ -259,4 +263,3 @@ apply_relocation(AOTModule *module, return true; } - diff --git a/core/iwasm/aot/arch/aot_reloc_xtensa.c b/core/iwasm/aot/arch/aot_reloc_xtensa.c index 91499a17..d60231f8 100644 --- a/core/iwasm/aot/arch/aot_reloc_xtensa.c +++ b/core/iwasm/aot/arch/aot_reloc_xtensa.c @@ -5,9 +5,10 @@ #include "aot_reloc.h" -#define R_XTENSA_32 1 /* Direct 32 bit */ -#define R_XTENSA_SLOT0_OP 20 /* PC relative */ +#define R_XTENSA_32 1 /* Direct 32 bit */ +#define R_XTENSA_SLOT0_OP 20 /* PC relative */ +/* clang-format off */ /* for soft-float */ void __floatsidf(); void __divdf3(); @@ -38,9 +39,9 @@ static SymbolMap target_sym_map[] = { REG_SYM(__muldi3), REG_SYM(__modsi3), - REG_SYM(__divdi3), }; +/* clang-format on */ static void set_error_buf(char *error_buf, uint32 error_buf_size, const char *string) @@ -81,9 +82,9 @@ get_plt_table_size() } static bool -check_reloc_offset(uint32 target_section_size, - uint64 reloc_offset, uint32 reloc_data_size, - char *error_buf, uint32 error_buf_size) +check_reloc_offset(uint32 target_section_size, uint64 reloc_offset, + uint32 reloc_data_size, char *error_buf, + uint32 error_buf_size) { if (!(reloc_offset < (uint64)target_section_size && reloc_offset + reloc_data_size <= (uint64)target_section_size)) { @@ -106,18 +107,18 @@ put_imm16_to_addr(int16 imm16, int16 *addr) int8 bytes[8]; int32 *addr_aligned1, *addr_aligned2; - addr_aligned1 = (int32*)((intptr_t)addr & ~3); + addr_aligned1 = (int32 *)((intptr_t)addr & ~3); if ((intptr_t)addr % 4 != 3) { - *(int32*)bytes = *addr_aligned1; - *(int16*)(bytes + ((intptr_t)addr % 4)) = imm16; + *(int32 *)bytes = *addr_aligned1; + *(int16 *)(bytes + ((intptr_t)addr % 4)) = imm16; memcpy(addr_aligned1, bytes, 4); } else { - addr_aligned2 = (int32*)(((intptr_t)addr + 3) & ~3); - *(int32*)bytes = *addr_aligned1; - *(int32*)(bytes + 4) = *addr_aligned2; - *(int16*)(bytes + 3) = imm16; + addr_aligned2 = (int32 *)(((intptr_t)addr + 3) & ~3); + *(int32 *)bytes = *addr_aligned1; + *(int32 *)(bytes + 4) = *addr_aligned2; + *(int16 *)(bytes + 3) = imm16; memcpy(addr_aligned1, bytes, 8); } } @@ -142,11 +143,10 @@ typedef union { } l32r_insn_t; bool -apply_relocation(AOTModule *module, - uint8 *target_section_addr, uint32 target_section_size, - uint64 reloc_offset, uint64 reloc_addend, - uint32 reloc_type, void *symbol_addr, int32 symbol_index, - char *error_buf, uint32 error_buf_size) +apply_relocation(AOTModule *module, uint8 *target_section_addr, + uint32 target_section_size, uint64 reloc_offset, + uint64 reloc_addend, uint32 reloc_type, void *symbol_addr, + int32 symbol_index, char *error_buf, uint32 error_buf_size) { switch (reloc_type) { case R_XTENSA_32: @@ -161,19 +161,20 @@ apply_relocation(AOTModule *module, return false; } CHECK_RELOC_OFFSET(4); - initial_addend = *(int32*)insn_addr; - *(uint8**)insn_addr - = (uint8*)symbol_addr + initial_addend + reloc_addend; + initial_addend = *(int32 *)insn_addr; + *(uint8 **)insn_addr = + (uint8 *)symbol_addr + initial_addend + reloc_addend; break; } case R_XTENSA_SLOT0_OP: { uint8 *insn_addr = target_section_addr + reloc_offset; - /* Currently only l32r instruction generates R_XTENSA_SLOT0_OP relocation */ + /* Currently only l32r instruction generates R_XTENSA_SLOT0_OP + * relocation */ l32r_insn_t *l32r_insn = (l32r_insn_t *)insn_addr; uint8 *reloc_addr; - int32 relative_offset/*, initial_addend */; + int32 relative_offset /*, initial_addend */; int16 imm16; CHECK_RELOC_OFFSET(3); /* size of l32r instruction */ @@ -184,7 +185,7 @@ apply_relocation(AOTModule *module, initial_addend = (int32)imm16 << 2; */ - reloc_addr = (uint8*)symbol_addr + reloc_addend; + reloc_addr = (uint8 *)symbol_addr + reloc_addend; if ((intptr_t)reloc_addr & 3) { set_error_buf(error_buf, error_buf_size, @@ -193,9 +194,9 @@ apply_relocation(AOTModule *module, return false; } - relative_offset = (int32) - ((intptr_t)reloc_addr - - (((intptr_t)insn_addr + 3) & ~(intptr_t)3)); + relative_offset = + (int32)((intptr_t)reloc_addr + - (((intptr_t)insn_addr + 3) & ~(intptr_t)3)); /* relative_offset += initial_addend; */ /* check relative offset boundary */ @@ -228,4 +229,3 @@ apply_relocation(AOTModule *module, return true; } - diff --git a/core/iwasm/aot/debug/elf_parser.c b/core/iwasm/aot/debug/elf_parser.c index 57714ce6..2fe3e11f 100644 --- a/core/iwasm/aot/debug/elf_parser.c +++ b/core/iwasm/aot/debug/elf_parser.c @@ -114,12 +114,13 @@ get_text_section(void *buf, uint64_t *offset, uint64_t *size) if (sh_table) { read_section_header_table64(eh, sh_table); sh_str = get_section64(eh, sh_table[eh->e_shstrndx]); - for (i= 0; i < eh->e_shnum; i++) { + for (i = 0; i < eh->e_shnum; i++) { if (!strcmp(sh_str + sh_table[i]->sh_name, ".text")) { *offset = sh_table[i]->sh_offset; *size = sh_table[i]->sh_size; - sh_table[i]->sh_addr = (Elf64_Addr)(uintptr_t) - ((char *)buf + sh_table[i]->sh_offset); + sh_table[i]->sh_addr = + (Elf64_Addr)(uintptr_t)((char *)buf + + sh_table[i]->sh_offset); ret = true; break; } @@ -134,12 +135,13 @@ get_text_section(void *buf, uint64_t *offset, uint64_t *size) if (sh_table) { read_section_header_table(eh, sh_table); sh_str = get_section(eh, sh_table[eh->e_shstrndx]); - for (i= 0; i < eh->e_shnum; i++) { + for (i = 0; i < eh->e_shnum; i++) { if (!strcmp(sh_str + sh_table[i]->sh_name, ".text")) { *offset = sh_table[i]->sh_offset; *size = sh_table[i]->sh_size; - sh_table[i]->sh_addr = (Elf32_Addr)(uintptr_t) - ((char *)buf + sh_table[i]->sh_offset); + sh_table[i]->sh_addr = + (Elf32_Addr)(uintptr_t)((char *)buf + + sh_table[i]->sh_offset); ret = true; break; } diff --git a/core/iwasm/aot/debug/jit_debug.c b/core/iwasm/aot/debug/jit_debug.c index 8d79ff03..310662f5 100644 --- a/core/iwasm/aot/debug/jit_debug.c +++ b/core/iwasm/aot/debug/jit_debug.c @@ -12,14 +12,14 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - * + * * Copyright (C) 2021 Ant Group. All rights reserved. * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception */ #include "bh_log.h" #include "bh_platform.h" -#include "wasm_runtime.h" +#include "../../interpreter/wasm_runtime.h" #include #include @@ -35,11 +35,13 @@ extern "C" { #endif -typedef enum { +/* clang-format off */ +typedef enum JITAction { JIT_NOACTION = 0, JIT_REGISTER_FN, JIT_UNREGISTER_FN } JITAction; +/* clang-format on */ typedef struct JITCodeEntry { struct JITCodeEntry *next_; @@ -78,7 +80,8 @@ void __attribute__((noinline)) __jit_debug_register_code() JITDescriptor __jit_debug_descriptor = { 1, JIT_NOACTION, NULL, NULL }; #else -extern void __jit_debug_register_code(); +extern void +__jit_debug_register_code(); extern JITDescriptor __jit_debug_descriptor; #endif @@ -168,8 +171,7 @@ jit_debug_engine_init() return true; } - if (!(jit_debug_engine = - wasm_runtime_malloc(sizeof(WASMJITDebugEngine)))) { + if (!(jit_debug_engine = wasm_runtime_malloc(sizeof(WASMJITDebugEngine)))) { LOG_ERROR("WASM JIT Debug Engine error: failed to allocate memory"); return false; } diff --git a/core/iwasm/common/arch/invokeNative_general.c b/core/iwasm/common/arch/invokeNative_general.c index 8d6e70f4..4799c9fa 100644 --- a/core/iwasm/common/arch/invokeNative_general.c +++ b/core/iwasm/common/arch/invokeNative_general.c @@ -6,11 +6,12 @@ #include "../wasm_runtime_common.h" #include "../wasm_exec_env.h" -void invokeNative(void (*native_code)(), uint32 argv[], uint32 argc) +void +invokeNative(void (*native_code)(), uint32 argv[], uint32 argc) { - bh_assert(argc >= sizeof(WASMExecEnv*)/sizeof(uint32)); + bh_assert(argc >= sizeof(WASMExecEnv *) / sizeof(uint32)); - switch(argc) { + switch (argc) { case 0: native_code(); break; @@ -33,53 +34,80 @@ void invokeNative(void (*native_code)(), uint32 argv[], uint32 argc) native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); break; case 7: - native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]); + native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], + argv[6]); break; case 8: - native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]); + native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], + argv[6], argv[7]); break; case 9: - native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8]); + native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], + argv[6], argv[7], argv[8]); break; case 10: - native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9]); + native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], + argv[6], argv[7], argv[8], argv[9]); break; case 11: - native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10]); + native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], + argv[6], argv[7], argv[8], argv[9], argv[10]); break; case 12: - native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11]); + native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], + argv[6], argv[7], argv[8], argv[9], argv[10], argv[11]); break; case 13: - native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12]); + native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], + argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], + argv[12]); break; case 14: - native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13]); + native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], + argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], + argv[12], argv[13]); break; case 15: - native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14]); + native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], + argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], + argv[12], argv[13], argv[14]); break; case 16: - native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14], argv[15]); + native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], + argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], + argv[12], argv[13], argv[14], argv[15]); break; case 17: - native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14], argv[15], argv[16]); + native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], + argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], + argv[12], argv[13], argv[14], argv[15], argv[16]); break; case 18: - native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14], argv[15], argv[16], argv[17]); + native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], + argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], + argv[12], argv[13], argv[14], argv[15], argv[16], + argv[17]); break; case 19: - native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14], argv[15], argv[16], argv[17], argv[18]); + native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], + argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], + argv[12], argv[13], argv[14], argv[15], argv[16], + argv[17], argv[18]); break; case 20: - native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14], argv[15], argv[16], argv[17], argv[18], argv[19]); + native_code(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], + argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], + argv[12], argv[13], argv[14], argv[15], argv[16], + argv[17], argv[18], argv[19]); break; default: { /* FIXME: If this happen, add more cases. */ - WASMExecEnv *exec_env = *(WASMExecEnv**)argv; + WASMExecEnv *exec_env = *(WASMExecEnv **)argv; WASMModuleInstanceCommon *module_inst = exec_env->module_inst; - wasm_runtime_set_exception(module_inst, "the argument number of native function exceeds maximum"); + wasm_runtime_set_exception( + module_inst, + "the argument number of native function exceeds maximum"); return; } } diff --git a/core/iwasm/common/wasm_application.c b/core/iwasm/common/wasm_application.c index b3e979fc..03771b17 100644 --- a/core/iwasm/common/wasm_application.c +++ b/core/iwasm/common/wasm_application.c @@ -24,15 +24,12 @@ runtime_malloc(uint64 size, WASMModuleInstanceCommon *module_inst, { void *mem; - if (size >= UINT32_MAX - || !(mem = wasm_runtime_malloc((uint32)size))) { + if (size >= UINT32_MAX || !(mem = wasm_runtime_malloc((uint32)size))) { if (module_inst != NULL) { - wasm_runtime_set_exception(module_inst, - "allocate memory failed"); + wasm_runtime_set_exception(module_inst, "allocate memory failed"); } else if (error_buf != NULL) { - set_error_buf(error_buf, error_buf_size, - "allocate memory failed"); + set_error_buf(error_buf, error_buf_size, "allocate memory failed"); } return NULL; } @@ -52,29 +49,31 @@ static union { * Implementation of wasm_application_execute_main() */ -static WASMFunctionInstanceCommon* -resolve_function(const WASMModuleInstanceCommon *module_inst, - const char *name); +static WASMFunctionInstanceCommon * +resolve_function(const WASMModuleInstanceCommon *module_inst, const char *name); static bool check_main_func_type(const WASMType *type) { if (!(type->param_count == 0 || type->param_count == 2) - ||type->result_count > 1) { - LOG_ERROR("WASM execute application failed: invalid main function type.\n"); + || type->result_count > 1) { + LOG_ERROR( + "WASM execute application failed: invalid main function type.\n"); return false; } if (type->param_count == 2 && !(type->types[0] == VALUE_TYPE_I32 - && type->types[1] == VALUE_TYPE_I32)) { - LOG_ERROR("WASM execute application failed: invalid main function type.\n"); + && type->types[1] == VALUE_TYPE_I32)) { + LOG_ERROR( + "WASM execute application failed: invalid main function type.\n"); return false; } if (type->result_count && type->types[type->param_count] != VALUE_TYPE_I32) { - LOG_ERROR("WASM execute application failed: invalid main function type.\n"); + LOG_ERROR( + "WASM execute application failed: invalid main function type.\n"); return false; } @@ -82,8 +81,8 @@ check_main_func_type(const WASMType *type) } bool -wasm_application_execute_main(WASMModuleInstanceCommon *module_inst, - int32 argc, char *argv[]) +wasm_application_execute_main(WASMModuleInstanceCommon *module_inst, int32 argc, + char *argv[]) { WASMFunctionInstanceCommon *func; WASMType *func_type = NULL; @@ -103,9 +102,9 @@ wasm_application_execute_main(WASMModuleInstanceCommon *module_inst, the actual main function. Directly call main function may cause exception thrown. */ if ((func = wasm_runtime_lookup_wasi_start_function(module_inst))) - return wasm_runtime_create_exec_env_and_call_wasm( - module_inst, func, 0, NULL); - /* if no start function is found, we execute + return wasm_runtime_create_exec_env_and_call_wasm(module_inst, func, + 0, NULL); + /* If no start function was found, we execute the main function as normal */ } #endif /* end of WASM_ENABLE_LIBC_WASI */ @@ -113,25 +112,23 @@ wasm_application_execute_main(WASMModuleInstanceCommon *module_inst, if (!(func = resolve_function(module_inst, "main")) && !(func = resolve_function(module_inst, "__main_argc_argv")) && !(func = resolve_function(module_inst, "_main"))) { - wasm_runtime_set_exception(module_inst, - "lookup main function failed"); + wasm_runtime_set_exception(module_inst, "lookup main function failed"); return false; } #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { - is_import_func = ((WASMFunctionInstance*)func)->is_import_func; + is_import_func = ((WASMFunctionInstance *)func)->is_import_func; } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { - is_import_func = ((AOTFunctionInstance*)func)->is_import_func; + is_import_func = ((AOTFunctionInstance *)func)->is_import_func; } #endif if (is_import_func) { - wasm_runtime_set_exception(module_inst, - "lookup main function failed"); + wasm_runtime_set_exception(module_inst, "lookup main function failed"); return false; } @@ -157,34 +154,34 @@ wasm_application_execute_main(WASMModuleInstanceCommon *module_inst, total_size = (uint64)total_argv_size + sizeof(int32) * (uint64)argc; if (total_size >= UINT32_MAX - || !(argv_buf_offset = - wasm_runtime_module_malloc(module_inst, (uint32)total_size, - (void**)&argv_buf))) { - wasm_runtime_set_exception(module_inst, - "allocate memory failed"); + || !(argv_buf_offset = wasm_runtime_module_malloc( + module_inst, (uint32)total_size, (void **)&argv_buf))) { + wasm_runtime_set_exception(module_inst, "allocate memory failed"); return false; } p = argv_buf; - argv_offsets = (uint32*)(p + total_argv_size); + argv_offsets = (uint32 *)(p + total_argv_size); p_end = p + total_size; for (i = 0; i < argc; i++) { - bh_memcpy_s(p, (uint32)(p_end - p), argv[i], (uint32)(strlen(argv[i]) + 1)); + bh_memcpy_s(p, (uint32)(p_end - p), argv[i], + (uint32)(strlen(argv[i]) + 1)); argv_offsets[i] = argv_buf_offset + (uint32)(p - argv_buf); p += strlen(argv[i]) + 1; } argc1 = 2; argv1[0] = (uint32)argc; - argv1[1] = (uint32)wasm_runtime_addr_native_to_app(module_inst, argv_offsets); + argv1[1] = + (uint32)wasm_runtime_addr_native_to_app(module_inst, argv_offsets); } - ret = wasm_runtime_create_exec_env_and_call_wasm(module_inst, func, - argc1, argv1); + ret = wasm_runtime_create_exec_env_and_call_wasm(module_inst, func, argc1, + argv1); if (ret && func_type->result_count > 0 && argc > 0 && argv) /* copy the return value */ - *(int*)argv = (int)argv1[0]; + *(int *)argv = (int)argv1[0]; if (argv_buf_offset) wasm_runtime_module_free(module_inst, argv_buf_offset); @@ -197,7 +194,7 @@ get_sub_module_inst(const WASMModuleInstance *parent_module_inst, const char *sub_module_name) { WASMSubModInstNode *node = - bh_list_first_elem(parent_module_inst->sub_module_inst_list); + bh_list_first_elem(parent_module_inst->sub_module_inst_list); while (node && strcmp(node->module_name, sub_module_name)) { node = bh_list_elem_next(node); @@ -241,9 +238,8 @@ parse_function_name(char *orig_function_name, char **p_module_name, * Implementation of wasm_application_execute_func() */ -static WASMFunctionInstanceCommon* -resolve_function(const WASMModuleInstanceCommon *module_inst, - const char *name) +static WASMFunctionInstanceCommon * +resolve_function(const WASMModuleInstanceCommon *module_inst, const char *name) { uint32 i = 0; WASMFunctionInstanceCommon *ret = NULL; @@ -268,8 +264,8 @@ resolve_function(const WASMModuleInstanceCommon *module_inst, LOG_DEBUG("%s -> %s and %s", name, sub_module_name, function_name); if (sub_module_name) { - sub_module_inst = get_sub_module_inst( - (WASMModuleInstance *)module_inst, sub_module_name); + sub_module_inst = get_sub_module_inst((WASMModuleInstance *)module_inst, + sub_module_name); if (!sub_module_inst) { LOG_DEBUG("can not find a sub module named %s", sub_module_name); goto LEAVE; @@ -281,26 +277,26 @@ resolve_function(const WASMModuleInstanceCommon *module_inst, #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { - WASMModuleInstance *wasm_inst = (WASMModuleInstance*)module_inst; + WASMModuleInstance *wasm_inst = (WASMModuleInstance *)module_inst; #if WASM_ENABLE_MULTI_MODULE != 0 wasm_inst = sub_module_inst ? sub_module_inst : wasm_inst; #endif /* WASM_ENABLE_MULTI_MODULE */ for (i = 0; i < wasm_inst->export_func_count; i++) { - if (!strcmp(wasm_inst->export_functions[i].name, function_name)) { + if (!strcmp(wasm_inst->export_functions[i].name, function_name)) { ret = wasm_inst->export_functions[i].function; break; - } + } } } #endif /* WASM_ENABLE_INTERP */ #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { - AOTModuleInstance *aot_inst = (AOTModuleInstance*)module_inst; - AOTFunctionInstance *export_funcs = (AOTFunctionInstance *) - aot_inst->export_funcs.ptr; + AOTModuleInstance *aot_inst = (AOTModuleInstance *)module_inst; + AOTFunctionInstance *export_funcs = + (AOTFunctionInstance *)aot_inst->export_funcs.ptr; for (i = 0; i < aot_inst->export_func_count; i++) { if (!strcmp(export_funcs[i].func_name, function_name)) { ret = &export_funcs[i]; @@ -323,14 +319,14 @@ union ieee754_float { /* This is the IEEE 754 single-precision format. */ union { struct { - unsigned int negative:1; - unsigned int exponent:8; - unsigned int mantissa:23; + unsigned int negative : 1; + unsigned int exponent : 8; + unsigned int mantissa : 23; } ieee_big_endian; struct { - unsigned int mantissa:23; - unsigned int exponent:8; - unsigned int negative:1; + unsigned int mantissa : 23; + unsigned int exponent : 8; + unsigned int negative : 1; } ieee_little_endian; } ieee; }; @@ -341,19 +337,19 @@ union ieee754_double { /* This is the IEEE 754 double-precision format. */ union { struct { - unsigned int negative:1; - unsigned int exponent:11; + unsigned int negative : 1; + unsigned int exponent : 11; /* Together these comprise the mantissa. */ - unsigned int mantissa0:20; - unsigned int mantissa1:32; + unsigned int mantissa0 : 20; + unsigned int mantissa1 : 32; } ieee_big_endian; struct { /* Together these comprise the mantissa. */ - unsigned int mantissa1:32; - unsigned int mantissa0:20; - unsigned int exponent:11; - unsigned int negative:1; + unsigned int mantissa1 : 32; + unsigned int mantissa0 : 20; + unsigned int exponent : 11; + unsigned int negative : 1; } ieee_little_endian; } ieee; }; @@ -382,7 +378,7 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst, #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { - WASMFunctionInstance *wasm_func = (WASMFunctionInstance*)func; + WASMFunctionInstance *wasm_func = (WASMFunctionInstance *)func; if (wasm_func->is_import_func #if WASM_ENABLE_MULTI_MODULE != 0 && !wasm_func->import_func_inst @@ -404,8 +400,7 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst, } if (type->param_count != (uint32)argc) { - wasm_runtime_set_exception(module_inst, - "invalid input argument count"); + wasm_runtime_set_exception(module_inst, "invalid input argument count"); goto fail; } @@ -413,8 +408,7 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst, cell_num = (argc1 > type->ret_cell_num) ? argc1 : type->ret_cell_num; total_size = sizeof(uint32) * (uint64)(cell_num > 2 ? cell_num : 2); - if ((!(argv1 = runtime_malloc((uint32)total_size, module_inst, - NULL, 0)))) { + if ((!(argv1 = runtime_malloc((uint32)total_size, module_inst, NULL, 0)))) { goto fail; } @@ -433,7 +427,10 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst, break; case VALUE_TYPE_I64: { - union { uint64 val; uint32 parts[2]; } u; + union { + uint64 val; + uint32 parts[2]; + } u; u.val = strtoull(argv[i], &endptr, 0); argv1[p++] = u.parts[0]; argv1[p++] = u.parts[1]; @@ -469,7 +466,10 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst, } case VALUE_TYPE_F64: { - union { float64 val; uint32 parts[2]; } u; + union { + float64 val; + uint32 parts[2]; + } u; u.val = strtod(argv[i], &endptr); if (isnan(u.val)) { if (argv[i][0] == '-') { @@ -506,11 +506,11 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst, { /* it likes 0x123\0x234 or 123\234 */ /* retrive first i64 */ - *(uint64*)(argv1 + p) = strtoull(argv[i], &endptr, 0); + *(uint64 *)(argv1 + p) = strtoull(argv[i], &endptr, 0); /* skip \ */ endptr++; /* retrive second i64 */ - *(uint64*)(argv1 + p + 2) = strtoull(endptr, &endptr, 0); + *(uint64 *)(argv1 + p + 2) = strtoull(endptr, &endptr, 0); p += 4; break; } @@ -541,7 +541,7 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst, if (!wasm_externref_obj2ref(module_inst, extern_obj, &externref_idx)) { wasm_runtime_set_exception( - module_inst, "map extern object to ref failed"); + module_inst, "map extern object to ref failed"); goto fail; } argv1[p++] = externref_idx; @@ -554,8 +554,8 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst, break; } if (endptr && *endptr != '\0' && *endptr != '_') { - snprintf(buf, sizeof(buf), "invalid input argument %d: %s", - i, argv[i]); + snprintf(buf, sizeof(buf), "invalid input argument %d: %s", i, + argv[i]); wasm_runtime_set_exception(module_inst, buf); goto fail; } @@ -563,8 +563,8 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst, bh_assert(p == (int32)argc1); wasm_runtime_set_exception(module_inst, NULL); - if (!wasm_runtime_create_exec_env_and_call_wasm(module_inst, func, - argc1, argv1)) { + if (!wasm_runtime_create_exec_env_and_call_wasm(module_inst, func, argc1, + argv1)) { goto fail; } @@ -579,12 +579,15 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst, } case VALUE_TYPE_I64: { - union { uint64 val; uint32 parts[2]; } u; + union { + uint64 val; + uint32 parts[2]; + } u; u.parts[0] = argv1[k]; u.parts[1] = argv1[k + 1]; k += 2; #ifdef PRIx64 - os_printf("0x%"PRIx64":i64", u.val); + os_printf("0x%" PRIx64 ":i64", u.val); #else char buf[16]; if (sizeof(long) == 4) @@ -597,13 +600,16 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst, } case VALUE_TYPE_F32: { - os_printf("%.7g:f32", *(float32*)(argv1 + k)); + os_printf("%.7g:f32", *(float32 *)(argv1 + k)); k++; break; } case VALUE_TYPE_F64: { - union { float64 val; uint32 parts[2]; } u; + union { + float64 val; + uint32 parts[2]; + } u; u.parts[0] = argv1[k]; u.parts[1] = argv1[k + 1]; k += 2; @@ -638,9 +644,10 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst, #if WASM_ENABLE_SIMD != 0 case VALUE_TYPE_V128: { - uint64 *v = (uint64*)(argv1 + k); + uint64 *v = (uint64 *)(argv1 + k); #if defined(PRIx64) - os_printf("<0x%016"PRIx64" 0x%016"PRIx64">:v128", *v, *(v + 1)); + os_printf("<0x%016" PRIx64 " 0x%016" PRIx64 ">:v128", *v, + *(v + 1)); #else if (4 == sizeof(long)) { os_printf("<0x%016llx 0x%016llx>:v128", *v, *(v + 1)); diff --git a/core/iwasm/common/wasm_c_api.c b/core/iwasm/common/wasm_c_api.c index 6bf60e2e..e08363f8 100644 --- a/core/iwasm/common/wasm_c_api.c +++ b/core/iwasm/common/wasm_c_api.c @@ -14,7 +14,7 @@ #endif #define ASSERT_NOT_IMPLEMENTED() bh_assert(!"not implemented") -#define UNREACHABLE() bh_assert(!"unreachable") +#define UNREACHABLE() bh_assert(!"unreachable") typedef struct wasm_module_ex_t wasm_module_ex_t; @@ -63,160 +63,159 @@ malloc_internal(uint64 size) } /* clang-format off */ -#define RETURN_OBJ(obj, obj_del_func) \ - return obj; \ -failed: \ - obj_del_func(obj); \ +#define RETURN_OBJ(obj, obj_del_func) \ + return obj; \ +failed: \ + obj_del_func(obj); \ return NULL; -#define RETURN_VOID(obj, obj_del_func) \ - return; \ -failed: \ - obj_del_func(obj); \ +#define RETURN_VOID(obj, obj_del_func) \ + return; \ +failed: \ + obj_del_func(obj); \ return; /* clang-format on */ /* Vectors */ -#define INIT_VEC(vector_p, init_func, ...) \ - do { \ - if (!(vector_p = malloc_internal(sizeof(*(vector_p))))) { \ - goto failed; \ - } \ - \ - init_func(vector_p, ##__VA_ARGS__); \ - if (vector_p->size && !vector_p->data) { \ - LOG_DEBUG("%s failed", #init_func); \ - goto failed; \ - } \ +#define INIT_VEC(vector_p, init_func, ...) \ + do { \ + if (!(vector_p = malloc_internal(sizeof(*(vector_p))))) { \ + goto failed; \ + } \ + \ + init_func(vector_p, ##__VA_ARGS__); \ + if (vector_p->size && !vector_p->data) { \ + LOG_DEBUG("%s failed", #init_func); \ + goto failed; \ + } \ } while (false) -#define DEINIT_VEC(vector_p, deinit_func) \ - if ((vector_p)) { \ - deinit_func(vector_p); \ - wasm_runtime_free(vector_p); \ - vector_p = NULL; \ +#define DEINIT_VEC(vector_p, deinit_func) \ + if ((vector_p)) { \ + deinit_func(vector_p); \ + wasm_runtime_free(vector_p); \ + vector_p = NULL; \ } -#define WASM_DEFINE_VEC(name) \ - void wasm_##name##_vec_new_empty(own wasm_##name##_vec_t *out) \ - { \ - wasm_##name##_vec_new_uninitialized(out, 0); \ - } \ - void wasm_##name##_vec_new_uninitialized(own wasm_##name##_vec_t *out, \ - size_t size) \ - { \ - wasm_##name##_vec_new(out, size, NULL); \ +#define WASM_DEFINE_VEC(name) \ + void wasm_##name##_vec_new_empty(own wasm_##name##_vec_t *out) \ + { \ + wasm_##name##_vec_new_uninitialized(out, 0); \ + } \ + void wasm_##name##_vec_new_uninitialized(own wasm_##name##_vec_t *out, \ + size_t size) \ + { \ + wasm_##name##_vec_new(out, size, NULL); \ } /* vectors with no ownership management of elements */ -#define WASM_DEFINE_VEC_PLAIN(name) \ - WASM_DEFINE_VEC(name) \ - void wasm_##name##_vec_new(own wasm_##name##_vec_t *out, size_t size, \ - own wasm_##name##_t const data[]) \ - { \ - if (!out) { \ - return; \ - } \ - \ - memset(out, 0, sizeof(wasm_##name##_vec_t)); \ - \ - if (!size) { \ - return; \ - } \ - \ - if (!bh_vector_init((Vector *)out, size, sizeof(wasm_##name##_t))) { \ - LOG_DEBUG("bh_vector_init failed"); \ - goto failed; \ - } \ - \ - if (data) { \ - uint32 size_in_bytes = 0; \ - size_in_bytes = (uint32)(size * sizeof(wasm_##name##_t)); \ - bh_memcpy_s(out->data, size_in_bytes, data, size_in_bytes); \ - out->num_elems = size; \ - } \ - \ - RETURN_VOID(out, wasm_##name##_vec_delete) \ - } \ - void wasm_##name##_vec_copy(wasm_##name##_vec_t *out, \ - const wasm_##name##_vec_t *src) \ - { \ - wasm_##name##_vec_new(out, src->size, src->data); \ - } \ - void wasm_##name##_vec_delete(wasm_##name##_vec_t *v) \ - { \ - if (v) { \ - bh_vector_destroy((Vector *)v); \ - } \ +#define WASM_DEFINE_VEC_PLAIN(name) \ + WASM_DEFINE_VEC(name) \ + void wasm_##name##_vec_new(own wasm_##name##_vec_t *out, size_t size, \ + own wasm_##name##_t const data[]) \ + { \ + if (!out) { \ + return; \ + } \ + \ + memset(out, 0, sizeof(wasm_##name##_vec_t)); \ + \ + if (!size) { \ + return; \ + } \ + \ + if (!bh_vector_init((Vector *)out, size, sizeof(wasm_##name##_t))) { \ + LOG_DEBUG("bh_vector_init failed"); \ + goto failed; \ + } \ + \ + if (data) { \ + uint32 size_in_bytes = 0; \ + size_in_bytes = (uint32)(size * sizeof(wasm_##name##_t)); \ + bh_memcpy_s(out->data, size_in_bytes, data, size_in_bytes); \ + out->num_elems = size; \ + } \ + \ + RETURN_VOID(out, wasm_##name##_vec_delete) \ + } \ + void wasm_##name##_vec_copy(wasm_##name##_vec_t *out, \ + const wasm_##name##_vec_t *src) \ + { \ + wasm_##name##_vec_new(out, src->size, src->data); \ + } \ + void wasm_##name##_vec_delete(wasm_##name##_vec_t *v) \ + { \ + if (v) { \ + bh_vector_destroy((Vector *)v); \ + } \ } /* vectors that own their elements */ -#define WASM_DEFINE_VEC_OWN(name, elem_destroy_func) \ - WASM_DEFINE_VEC(name) \ - void wasm_##name##_vec_new(own wasm_##name##_vec_t *out, size_t size, \ - own wasm_##name##_t *const data[]) \ - { \ - if (!out) { \ - return; \ - } \ - \ - memset(out, 0, sizeof(wasm_##name##_vec_t)); \ - \ - if (!size) { \ - return; \ - } \ - \ - if (!bh_vector_init((Vector *)out, size, \ - sizeof(wasm_##name##_t *))) { \ - LOG_DEBUG("bh_vector_init failed"); \ - goto failed; \ - } \ - \ - if (data) { \ - uint32 size_in_bytes = 0; \ - size_in_bytes = (uint32)(size * sizeof(wasm_##name##_t *)); \ - bh_memcpy_s(out->data, size_in_bytes, data, size_in_bytes); \ - out->num_elems = size; \ - } \ - \ - RETURN_VOID(out, wasm_##name##_vec_delete) \ - } \ - void wasm_##name##_vec_copy(own wasm_##name##_vec_t *out, \ - const wasm_##name##_vec_t *src) \ - { \ - size_t i = 0; \ - memset(out, 0, sizeof(Vector)); \ - \ - if (!src || !src->size) { \ - return; \ - } \ - \ - if (!bh_vector_init((Vector *)out, src->size, \ - sizeof(wasm_##name##_t *))) { \ - LOG_DEBUG("bh_vector_init failed"); \ - goto failed; \ - } \ - \ - for (i = 0; i != src->num_elems; ++i) { \ - if (!(out->data[i] = wasm_##name##_copy(src->data[i]))) { \ - LOG_DEBUG("wasm_%s_copy failed", #name); \ - goto failed; \ - } \ - } \ - out->num_elems = src->num_elems; \ - \ - RETURN_VOID(out, wasm_##name##_vec_delete) \ - } \ - void wasm_##name##_vec_delete(wasm_##name##_vec_t *v) \ - { \ - size_t i = 0; \ - if (!v) { \ - return; \ - } \ - for (i = 0; i != v->num_elems; ++i) { \ - elem_destroy_func(*(v->data + i)); \ - } \ - bh_vector_destroy((Vector *)v); \ +#define WASM_DEFINE_VEC_OWN(name, elem_destroy_func) \ + WASM_DEFINE_VEC(name) \ + void wasm_##name##_vec_new(own wasm_##name##_vec_t *out, size_t size, \ + own wasm_##name##_t *const data[]) \ + { \ + if (!out) { \ + return; \ + } \ + \ + memset(out, 0, sizeof(wasm_##name##_vec_t)); \ + \ + if (!size) { \ + return; \ + } \ + \ + if (!bh_vector_init((Vector *)out, size, sizeof(wasm_##name##_t *))) { \ + LOG_DEBUG("bh_vector_init failed"); \ + goto failed; \ + } \ + \ + if (data) { \ + uint32 size_in_bytes = 0; \ + size_in_bytes = (uint32)(size * sizeof(wasm_##name##_t *)); \ + bh_memcpy_s(out->data, size_in_bytes, data, size_in_bytes); \ + out->num_elems = size; \ + } \ + \ + RETURN_VOID(out, wasm_##name##_vec_delete) \ + } \ + void wasm_##name##_vec_copy(own wasm_##name##_vec_t *out, \ + const wasm_##name##_vec_t *src) \ + { \ + size_t i = 0; \ + memset(out, 0, sizeof(Vector)); \ + \ + if (!src || !src->size) { \ + return; \ + } \ + \ + if (!bh_vector_init((Vector *)out, src->size, \ + sizeof(wasm_##name##_t *))) { \ + LOG_DEBUG("bh_vector_init failed"); \ + goto failed; \ + } \ + \ + for (i = 0; i != src->num_elems; ++i) { \ + if (!(out->data[i] = wasm_##name##_copy(src->data[i]))) { \ + LOG_DEBUG("wasm_%s_copy failed", #name); \ + goto failed; \ + } \ + } \ + out->num_elems = src->num_elems; \ + \ + RETURN_VOID(out, wasm_##name##_vec_delete) \ + } \ + void wasm_##name##_vec_delete(wasm_##name##_vec_t *v) \ + { \ + size_t i = 0; \ + if (!v) { \ + return; \ + } \ + for (i = 0; i != v->num_elems; ++i) { \ + elem_destroy_func(*(v->data + i)); \ + } \ + bh_vector_destroy((Vector *)v); \ } WASM_DEFINE_VEC_PLAIN(byte) @@ -241,13 +240,9 @@ void aot_compile_wasm_file_destroy(); uint8 * -aot_compile_wasm_file(const uint8 *wasm_file_buf, - uint32 wasm_file_size, - uint32 opt_level, - uint32 size_level, - char *error_buf, - uint32 error_buf_size, - uint32 *p_aot_file_size); +aot_compile_wasm_file(const uint8 *wasm_file_buf, uint32 wasm_file_size, + uint32 opt_level, uint32 size_level, char *error_buf, + uint32 error_buf_size, uint32 *p_aot_file_size); #endif /* Runtime Environment */ @@ -300,11 +295,11 @@ wasm_engine_new_internal(mem_alloc_type_t type, const MemAllocOption *opts) } init_args.mem_alloc_option.allocator.malloc_func = - opts->allocator.malloc_func; + opts->allocator.malloc_func; init_args.mem_alloc_option.allocator.free_func = - opts->allocator.free_func; + opts->allocator.free_func; init_args.mem_alloc_option.allocator.realloc_func = - opts->allocator.realloc_func; + opts->allocator.realloc_func; } else { init_args.mem_alloc_option.pool.heap_buf = NULL; @@ -347,7 +342,7 @@ wasm_engine_new() { if (!singleton_engine) { singleton_engine = - wasm_engine_new_internal(Alloc_With_System_Allocator, NULL); + wasm_engine_new_internal(Alloc_With_System_Allocator, NULL); } return singleton_engine; } @@ -463,8 +458,8 @@ static inline wasm_valkind_t val_type_rt_2_valkind(uint8 val_type_rt) { switch (val_type_rt) { -#define WAMR_VAL_TYPE_2_WASM_VAL_KIND(name) \ - case VALUE_TYPE_##name: \ +#define WAMR_VAL_TYPE_2_WASM_VAL_KIND(name) \ + case VALUE_TYPE_##name: \ return WASM_##name; WAMR_VAL_TYPE_2_WASM_VAL_KIND(I32) @@ -550,12 +545,13 @@ wasm_functype_new_internal(WASMType *type_rt) } } - /* WASMType->types[type_rt->param_count : type_rt->result_count) -> type->results */ + /* WASMType->types[type_rt->param_count : type_rt->result_count) -> + * type->results */ INIT_VEC(type->results, wasm_valtype_vec_new_uninitialized, type_rt->result_count); for (i = 0; i < type_rt->result_count; ++i) { if (!(result_type = wasm_valtype_new_internal( - *(type_rt->types + type_rt->param_count + i)))) { + *(type_rt->types + type_rt->param_count + i)))) { goto failed; } @@ -710,7 +706,7 @@ wasm_globaltype_new_internal(uint8 val_type_rt, bool is_mutable) } if (!(globaltype = wasm_globaltype_new( - val_type, is_mutable ? WASM_VAR : WASM_CONST))) { + val_type, is_mutable ? WASM_VAR : WASM_CONST))) { wasm_valtype_delete(val_type); } @@ -774,8 +770,7 @@ wasm_globaltype_mutability(const wasm_globaltype_t *global_type) } static wasm_tabletype_t * -wasm_tabletype_new_internal(uint8 val_type_rt, - uint32 init_size, +wasm_tabletype_new_internal(uint8 val_type_rt, uint32 init_size, uint32 max_size) { wasm_tabletype_t *table_type; @@ -935,46 +930,45 @@ wasm_externtype_kind(const wasm_externtype_t *extern_type) return extern_type->extern_kind; } -#define BASIC_FOUR_TYPE_LIST(V) \ - V(functype) \ - V(globaltype) \ - V(memorytype) \ +#define BASIC_FOUR_TYPE_LIST(V) \ + V(functype) \ + V(globaltype) \ + V(memorytype) \ V(tabletype) -#define WASM_EXTERNTYPE_AS_OTHERTYPE(name) \ - wasm_##name##_t *wasm_externtype_as_##name( \ - wasm_externtype_t *extern_type) \ - { \ - return (wasm_##name##_t *)extern_type; \ +#define WASM_EXTERNTYPE_AS_OTHERTYPE(name) \ + wasm_##name##_t *wasm_externtype_as_##name(wasm_externtype_t *extern_type) \ + { \ + return (wasm_##name##_t *)extern_type; \ } BASIC_FOUR_TYPE_LIST(WASM_EXTERNTYPE_AS_OTHERTYPE) #undef WASM_EXTERNTYPE_AS_OTHERTYPE -#define WASM_OTHERTYPE_AS_EXTERNTYPE(name) \ - wasm_externtype_t *wasm_##name##_as_externtype(wasm_##name##_t *other) \ - { \ - return (wasm_externtype_t *)other; \ +#define WASM_OTHERTYPE_AS_EXTERNTYPE(name) \ + wasm_externtype_t *wasm_##name##_as_externtype(wasm_##name##_t *other) \ + { \ + return (wasm_externtype_t *)other; \ } BASIC_FOUR_TYPE_LIST(WASM_OTHERTYPE_AS_EXTERNTYPE) #undef WASM_OTHERTYPE_AS_EXTERNTYPE -#define WASM_EXTERNTYPE_AS_OTHERTYPE_CONST(name) \ - const wasm_##name##_t *wasm_externtype_as_##name##_const( \ - const wasm_externtype_t *extern_type) \ - { \ - return (const wasm_##name##_t *)extern_type; \ +#define WASM_EXTERNTYPE_AS_OTHERTYPE_CONST(name) \ + const wasm_##name##_t *wasm_externtype_as_##name##_const( \ + const wasm_externtype_t *extern_type) \ + { \ + return (const wasm_##name##_t *)extern_type; \ } BASIC_FOUR_TYPE_LIST(WASM_EXTERNTYPE_AS_OTHERTYPE_CONST) #undef WASM_EXTERNTYPE_AS_OTHERTYPE_CONST -#define WASM_OTHERTYPE_AS_EXTERNTYPE_CONST(name) \ - const wasm_externtype_t *wasm_##name##_as_externtype_const( \ - const wasm_##name##_t *other) \ - { \ - return (const wasm_externtype_t *)other; \ +#define WASM_OTHERTYPE_AS_EXTERNTYPE_CONST(name) \ + const wasm_externtype_t *wasm_##name##_as_externtype_const( \ + const wasm_##name##_t *other) \ + { \ + return (const wasm_externtype_t *)other; \ } BASIC_FOUR_TYPE_LIST(WASM_OTHERTYPE_AS_EXTERNTYPE_CONST) @@ -990,12 +984,12 @@ wasm_externtype_copy(const wasm_externtype_t *src) } switch (src->extern_kind) { -#define COPY_EXTERNTYPE(NAME, name) \ - case WASM_EXTERN_##NAME: \ - { \ - extern_type = wasm_##name##_as_externtype( \ - wasm_##name##_copy(wasm_externtype_as_##name##_const(src))); \ - break; \ +#define COPY_EXTERNTYPE(NAME, name) \ + case WASM_EXTERN_##NAME: \ + { \ + extern_type = wasm_##name##_as_externtype( \ + wasm_##name##_copy(wasm_externtype_as_##name##_const(src))); \ + break; \ } COPY_EXTERNTYPE(FUNC, functype) COPY_EXTERNTYPE(GLOBAL, globaltype) @@ -1031,8 +1025,7 @@ wasm_externtype_delete(wasm_externtype_t *extern_type) wasm_tabletype_delete(wasm_externtype_as_tabletype(extern_type)); break; default: - LOG_WARNING("%s meets unsupported type", __FUNCTION__, - extern_type); + LOG_WARNING("%s meets unsupported type", __FUNCTION__, extern_type); break; } } @@ -1050,7 +1043,7 @@ wasm_importtype_new(own wasm_byte_vec_t *module_name, /* take ownership */ if (!(import_type->module_name = - malloc_internal(sizeof(wasm_byte_vec_t)))) { + malloc_internal(sizeof(wasm_byte_vec_t)))) { goto failed; } bh_memcpy_s(import_type->module_name, sizeof(wasm_byte_vec_t), module_name, @@ -1109,7 +1102,7 @@ wasm_importtype_copy(const wasm_importtype_t *src) } if (!(import_type = - wasm_importtype_new(&module_name, &name, extern_type))) { + wasm_importtype_new(&module_name, &name, extern_type))) { goto failed; } @@ -1298,10 +1291,8 @@ rt_val_to_wasm_val(const uint8 *data, uint8 val_type_rt, wasm_val_t *out) } bool -wasm_val_to_rt_val(WASMModuleInstanceCommon *inst_comm_rt, - uint8 val_type_rt, - const wasm_val_t *v, - uint8 *data) +wasm_val_to_rt_val(WASMModuleInstanceCommon *inst_comm_rt, uint8 val_type_rt, + const wasm_val_t *v, uint8 *data) { bool ret = true; switch (val_type_rt) { @@ -1325,7 +1316,7 @@ wasm_val_to_rt_val(WASMModuleInstanceCommon *inst_comm_rt, case VALUE_TYPE_EXTERNREF: bh_assert(WASM_ANYREF == v->kind); ret = - wasm_externref_obj2ref(inst_comm_rt, v->of.ref, (uint32 *)data); + wasm_externref_obj2ref(inst_comm_rt, v->of.ref, (uint32 *)data); break; #endif default: @@ -1338,10 +1329,8 @@ wasm_val_to_rt_val(WASMModuleInstanceCommon *inst_comm_rt, } wasm_ref_t * -wasm_ref_new_internal(wasm_store_t *store, - enum wasm_reference_kind kind, - uint32 ref_idx_rt, - WASMModuleInstanceCommon *inst_comm_rt) +wasm_ref_new_internal(wasm_store_t *store, enum wasm_reference_kind kind, + uint32 ref_idx_rt, WASMModuleInstanceCommon *inst_comm_rt) { wasm_ref_t *ref; @@ -1386,11 +1375,11 @@ wasm_ref_copy(const wasm_ref_t *src) src->inst_comm_rt); } -#define DELETE_HOST_INFO(obj) \ - if (obj->host_info.info) { \ - if (obj->host_info.finalizer) { \ - obj->host_info.finalizer(obj->host_info.info); \ - } \ +#define DELETE_HOST_INFO(obj) \ + if (obj->host_info.info) { \ + if (obj->host_info.finalizer) { \ + obj->host_info.finalizer(obj->host_info.info); \ + } \ } void @@ -1413,82 +1402,80 @@ wasm_ref_delete(own wasm_ref_t *ref) wasm_runtime_free(ref); } -#define WASM_DEFINE_REF_BASE(name) \ - bool wasm_##name##_same(const wasm_##name##_t *o1, \ - const wasm_##name##_t *o2) \ - { \ - return (!o1 && !o2) ? true \ - : (!o1 || !o2) ? false \ - : (o1->kind != o2->kind) \ - ? false \ - : o1->name##_idx_rt == o2->name##_idx_rt; \ - } \ - \ - void *wasm_##name##_get_host_info(const wasm_##name##_t *obj) \ - { \ - return obj ? obj->host_info.info : NULL; \ - } \ - \ - void wasm_##name##_set_host_info(wasm_##name##_t *obj, void *host_info) \ - { \ - if (obj) { \ - obj->host_info.info = host_info; \ - obj->host_info.finalizer = NULL; \ - } \ - } \ - \ - void wasm_##name##_set_host_info_with_finalizer( \ - wasm_##name##_t *obj, void *host_info, void (*finalizer)(void *)) \ - { \ - if (obj) { \ - obj->host_info.info = host_info; \ - obj->host_info.finalizer = finalizer; \ - } \ +#define WASM_DEFINE_REF_BASE(name) \ + bool wasm_##name##_same(const wasm_##name##_t *o1, \ + const wasm_##name##_t *o2) \ + { \ + return (!o1 && !o2) ? true \ + : (!o1 || !o2) ? false \ + : (o1->kind != o2->kind) \ + ? false \ + : o1->name##_idx_rt == o2->name##_idx_rt; \ + } \ + \ + void *wasm_##name##_get_host_info(const wasm_##name##_t *obj) \ + { \ + return obj ? obj->host_info.info : NULL; \ + } \ + \ + void wasm_##name##_set_host_info(wasm_##name##_t *obj, void *host_info) \ + { \ + if (obj) { \ + obj->host_info.info = host_info; \ + obj->host_info.finalizer = NULL; \ + } \ + } \ + \ + void wasm_##name##_set_host_info_with_finalizer( \ + wasm_##name##_t *obj, void *host_info, void (*finalizer)(void *)) \ + { \ + if (obj) { \ + obj->host_info.info = host_info; \ + obj->host_info.finalizer = finalizer; \ + } \ } -#define WASM_DEFINE_REF(name) \ - WASM_DEFINE_REF_BASE(name) \ - \ - wasm_ref_t *wasm_##name##_as_ref(wasm_##name##_t *name) \ - { \ - if (!name) { \ - return NULL; \ - } \ - \ - return wasm_ref_new_internal(name->store, WASM_REF_##name, \ - name->name##_idx_rt, \ - name->inst_comm_rt); \ - } \ - \ - const wasm_ref_t *wasm_##name##_as_ref_const(const wasm_##name##_t *name) \ - { \ - if (!name) { \ - return NULL; \ - } \ - \ - return wasm_ref_new_internal(name->store, WASM_REF_##name, \ - name->name##_idx_rt, \ - name->inst_comm_rt); \ - } \ - \ - wasm_##name##_t *wasm_ref_as_##name(wasm_ref_t *ref) \ - { \ - if (!ref || WASM_REF_##name != ref->kind) { \ - return NULL; \ - } \ - \ - return wasm_##name##_new_internal(ref->store, ref->ref_idx_rt, \ - ref->inst_comm_rt); \ - } \ - \ - const wasm_##name##_t *wasm_ref_as_##name##_const(const wasm_ref_t *ref) \ - { \ - if (!ref || WASM_REF_##name != ref->kind) { \ - return NULL; \ - } \ - \ - return wasm_##name##_new_internal(ref->store, ref->ref_idx_rt, \ - ref->inst_comm_rt); \ +#define WASM_DEFINE_REF(name) \ + WASM_DEFINE_REF_BASE(name) \ + \ + wasm_ref_t *wasm_##name##_as_ref(wasm_##name##_t *name) \ + { \ + if (!name) { \ + return NULL; \ + } \ + \ + return wasm_ref_new_internal(name->store, WASM_REF_##name, \ + name->name##_idx_rt, name->inst_comm_rt); \ + } \ + \ + const wasm_ref_t *wasm_##name##_as_ref_const(const wasm_##name##_t *name) \ + { \ + if (!name) { \ + return NULL; \ + } \ + \ + return wasm_ref_new_internal(name->store, WASM_REF_##name, \ + name->name##_idx_rt, name->inst_comm_rt); \ + } \ + \ + wasm_##name##_t *wasm_ref_as_##name(wasm_ref_t *ref) \ + { \ + if (!ref || WASM_REF_##name != ref->kind) { \ + return NULL; \ + } \ + \ + return wasm_##name##_new_internal(ref->store, ref->ref_idx_rt, \ + ref->inst_comm_rt); \ + } \ + \ + const wasm_##name##_t *wasm_ref_as_##name##_const(const wasm_ref_t *ref) \ + { \ + if (!ref || WASM_REF_##name != ref->kind) { \ + return NULL; \ + } \ + \ + return wasm_##name##_new_internal(ref->store, ref->ref_idx_rt, \ + ref->inst_comm_rt); \ } WASM_DEFINE_REF_BASE(ref) @@ -1499,10 +1486,8 @@ WASM_DEFINE_REF(memory) WASM_DEFINE_REF(table) static wasm_frame_t * -wasm_frame_new(wasm_instance_t *instance, - size_t module_offset, - uint32 func_index, - size_t func_offset) +wasm_frame_new(wasm_instance_t *instance, size_t module_offset, + uint32 func_index, size_t func_offset) { wasm_frame_t *frame; @@ -1578,7 +1563,7 @@ wasm_trap_new_internal(WASMModuleInstanceCommon *inst_comm_rt, #if WASM_ENABLE_INTERP != 0 if (inst_comm_rt->module_type == Wasm_Module_Bytecode) { if (!(error_info = - wasm_get_exception((WASMModuleInstance *)inst_comm_rt))) { + wasm_get_exception((WASMModuleInstance *)inst_comm_rt))) { return NULL; } } @@ -1587,7 +1572,7 @@ wasm_trap_new_internal(WASMModuleInstanceCommon *inst_comm_rt, #if WASM_ENABLE_AOT != 0 if (inst_comm_rt->module_type == Wasm_Module_AoT) { if (!(error_info = - aot_get_exception((AOTModuleInstance *)inst_comm_rt))) { + aot_get_exception((AOTModuleInstance *)inst_comm_rt))) { return NULL; } } @@ -1737,8 +1722,8 @@ wasm_trap_trace(const wasm_trap_t *trap, own wasm_frame_vec_t *out) frame = ((wasm_frame_t *)trap->frames->data) + i; if (!(out->data[i] = - wasm_frame_new(frame->instance, frame->module_offset, - frame->func_index, frame->func_offset))) { + wasm_frame_new(frame->instance, frame->module_offset, + frame->func_index, frame->func_offset))) { goto failed; } out->num_elems++; @@ -1756,8 +1741,7 @@ failed: } wasm_foreign_t * -wasm_foreign_new_internal(wasm_store_t *store, - uint32 foreign_idx_rt, +wasm_foreign_new_internal(wasm_store_t *store, uint32 foreign_idx_rt, WASMModuleInstanceCommon *inst_comm_rt) { wasm_foreign_t *foreign = NULL; @@ -1857,7 +1841,8 @@ wasm_module_new(wasm_store_t *store, const wasm_byte_vec_t *binary) pkg_type = get_package_type((uint8 *)binary->data, (uint32)binary->size); - /* whether the combination of compilation flags are compatable with the package type */ + /* whether the combination of compilation flags are compatable with the + * package type */ { bool result = false; #if WASM_ENABLE_INTERP != 0 @@ -1883,16 +1868,16 @@ wasm_module_new(wasm_store_t *store, const wasm_byte_vec_t *binary) #if WASM_ENABLE_AOT != 0 && WASM_ENABLE_JIT != 0 if (Wasm_Module_Bytecode == pkg_type) { if (!(aot_file_buf = aot_compile_wasm_file( - (uint8 *)module_ex->binary->data, - (uint32)module_ex->binary->size, 3, 3, error_buf, - (uint32)sizeof(error_buf), &aot_file_size))) { + (uint8 *)module_ex->binary->data, + (uint32)module_ex->binary->size, 3, 3, error_buf, + (uint32)sizeof(error_buf), &aot_file_size))) { LOG_ERROR(error_buf); goto failed; } if (!(module_ex->module_comm_rt = - wasm_runtime_load(aot_file_buf, aot_file_size, error_buf, - (uint32)sizeof(error_buf)))) { + wasm_runtime_load(aot_file_buf, aot_file_size, error_buf, + (uint32)sizeof(error_buf)))) { LOG_ERROR(error_buf); goto failed; } @@ -1901,8 +1886,8 @@ wasm_module_new(wasm_store_t *store, const wasm_byte_vec_t *binary) #endif { module_ex->module_comm_rt = wasm_runtime_load( - (uint8 *)module_ex->binary->data, (uint32)module_ex->binary->size, - error_buf, (uint32)sizeof(error_buf)); + (uint8 *)module_ex->binary->data, (uint32)module_ex->binary->size, + error_buf, (uint32)sizeof(error_buf)); if (!(module_ex->module_comm_rt)) { LOG_ERROR(error_buf); goto failed; @@ -1935,8 +1920,8 @@ wasm_module_validate(wasm_store_t *store, const wasm_byte_vec_t *binary) return false; } - if ((module_rt = wasm_runtime_load( - (uint8 *)binary->data, (uint32)binary->size, error_buf, 128))) { + if ((module_rt = wasm_runtime_load((uint8 *)binary->data, + (uint32)binary->size, error_buf, 128))) { wasm_runtime_unload(module_rt); return true; } @@ -1973,12 +1958,10 @@ wasm_module_delete(wasm_module_t *module) } void -wasm_module_imports(const wasm_module_t *module, - own wasm_importtype_vec_t *out) +wasm_module_imports(const wasm_module_t *module, own wasm_importtype_vec_t *out) { uint32 i, import_func_count = 0, import_memory_count = 0, - import_global_count = 0, import_table_count = 0, - import_count = 0; + import_global_count = 0, import_table_count = 0, import_count = 0; wasm_byte_vec_t module_name = { 0 }, name = { 0 }; wasm_externtype_t *extern_type = NULL; wasm_importtype_t *import_type = NULL; @@ -2027,7 +2010,7 @@ wasm_module_imports(const wasm_module_t *module, #if WASM_ENABLE_INTERP != 0 if ((*module)->module_type == Wasm_Module_Bytecode) { WASMImport *import = - MODULE_INTERP(module)->import_functions + i; + MODULE_INTERP(module)->import_functions + i; module_name_rt = import->u.names.module_name; field_name_rt = import->u.names.field_name; type_rt = import->u.function.func_type; @@ -2081,8 +2064,8 @@ wasm_module_imports(const wasm_module_t *module, #if WASM_ENABLE_AOT != 0 if ((*module)->module_type == Wasm_Module_AoT) { - AOTImportGlobal *import = - MODULE_AOT(module)->import_globals + (i - import_func_count); + AOTImportGlobal *import = MODULE_AOT(module)->import_globals + + (i - import_func_count); module_name_rt = import->module_name; field_name_rt = import->global_name; val_type_rt = import->type; @@ -2102,15 +2085,15 @@ wasm_module_imports(const wasm_module_t *module, extern_type = wasm_globaltype_as_externtype(type); } else if (i < import_func_count + import_global_count - + import_memory_count) { + + import_memory_count) { wasm_memorytype_t *type = NULL; uint32 min_page = 0, max_page = 0; #if WASM_ENABLE_INTERP != 0 if ((*module)->module_type == Wasm_Module_Bytecode) { WASMImport *import = - MODULE_INTERP(module)->import_memories - + (i - import_func_count - import_global_count); + MODULE_INTERP(module)->import_memories + + (i - import_func_count - import_global_count); module_name_rt = import->u.names.module_name; field_name_rt = import->u.names.field_name; min_page = import->u.memory.init_page_count; @@ -2121,8 +2104,8 @@ wasm_module_imports(const wasm_module_t *module, #if WASM_ENABLE_AOT != 0 if ((*module)->module_type == Wasm_Module_AoT) { AOTImportMemory *import = - MODULE_AOT(module)->import_memories - + (i - import_func_count - import_global_count); + MODULE_AOT(module)->import_memories + + (i - import_func_count - import_global_count); module_name_rt = import->module_name; field_name_rt = import->memory_name; min_page = import->mem_init_page_count; @@ -2158,9 +2141,9 @@ wasm_module_imports(const wasm_module_t *module, #if WASM_ENABLE_INTERP != 0 if ((*module)->module_type == Wasm_Module_Bytecode) { WASMImport *import = - MODULE_INTERP(module)->import_tables - + (i - import_func_count - import_global_count - - import_memory_count); + MODULE_INTERP(module)->import_tables + + (i - import_func_count - import_global_count + - import_memory_count); module_name_rt = import->u.names.module_name; field_name_rt = import->u.names.field_name; elem_type_rt = import->u.table.elem_type; @@ -2172,9 +2155,9 @@ wasm_module_imports(const wasm_module_t *module, #if WASM_ENABLE_AOT != 0 if ((*module)->module_type == Wasm_Module_AoT) { AOTImportTable *import = - MODULE_AOT(module)->import_tables - + (i - import_func_count - import_global_count - - import_memory_count); + MODULE_AOT(module)->import_tables + + (i - import_func_count - import_global_count + - import_memory_count); module_name_rt = import->module_name; field_name_rt = import->table_name; elem_type_rt = VALUE_TYPE_FUNCREF; @@ -2200,7 +2183,7 @@ wasm_module_imports(const wasm_module_t *module, } if (!(import_type = - wasm_importtype_new(&module_name, &name, extern_type))) { + wasm_importtype_new(&module_name, &name, extern_type))) { goto failed; } @@ -2277,7 +2260,8 @@ wasm_module_exports(const wasm_module_t *module, wasm_exporttype_vec_t *out) goto failed; } - /* WASMExport -> (WASMType, (uint8, bool)) -> (wasm_functype_t, wasm_globaltype_t) -> wasm_externtype_t*/ + /* WASMExport -> (WASMType, (uint8, bool)) -> (wasm_functype_t, + * wasm_globaltype_t) -> wasm_externtype_t*/ switch (export->kind) { case EXPORT_KIND_FUNC: { @@ -2303,7 +2287,7 @@ wasm_module_exports(const wasm_module_t *module, wasm_exporttype_vec_t *out) bool mutability_rt = 0; if (!wasm_runtime_get_export_global_type( - *module, export, &val_type_rt, &mutability_rt)) { + *module, export, &val_type_rt, &mutability_rt)) { goto failed; } @@ -2321,12 +2305,12 @@ wasm_module_exports(const wasm_module_t *module, wasm_exporttype_vec_t *out) uint32 min_page = 0, max_page = 0; if (!wasm_runtime_get_export_memory_type( - *module, export, &min_page, &max_page)) { + *module, export, &min_page, &max_page)) { goto failed; } if (!(type = - wasm_memorytype_new_internal(min_page, max_page))) { + wasm_memorytype_new_internal(min_page, max_page))) { goto failed; } @@ -2340,12 +2324,12 @@ wasm_module_exports(const wasm_module_t *module, wasm_exporttype_vec_t *out) uint32 min_size = 0, max_size = 0; if (!wasm_runtime_get_export_table_type( - *module, export, &elem_type_rt, &min_size, &max_size)) { + *module, export, &elem_type_rt, &min_size, &max_size)) { goto failed; } - if (!(type = wasm_tabletype_new_internal( - elem_type_rt, min_size, max_size))) { + if (!(type = wasm_tabletype_new_internal(elem_type_rt, min_size, + max_size))) { goto failed; } @@ -2380,8 +2364,7 @@ failed_exporttype_new: } static wasm_func_t * -wasm_func_new_basic(wasm_store_t *store, - const wasm_functype_t *type, +wasm_func_new_basic(wasm_store_t *store, const wasm_functype_t *type, wasm_func_callback_t func_callback) { wasm_func_t *func = NULL; @@ -2404,10 +2387,8 @@ wasm_func_new_basic(wasm_store_t *store, } static wasm_func_t * -wasm_func_new_with_env_basic(wasm_store_t *store, - const wasm_functype_t *type, - wasm_func_callback_with_env_t callback, - void *env, +wasm_func_new_with_env_basic(wasm_store_t *store, const wasm_functype_t *type, + wasm_func_callback_with_env_t callback, void *env, void (*finalizer)(void *)) { wasm_func_t *func = NULL; @@ -2432,8 +2413,7 @@ wasm_func_new_with_env_basic(wasm_store_t *store, } wasm_func_t * -wasm_func_new(wasm_store_t *store, - const wasm_functype_t *type, +wasm_func_new(wasm_store_t *store, const wasm_functype_t *type, wasm_func_callback_t callback) { bh_assert(singleton_engine); @@ -2441,10 +2421,8 @@ wasm_func_new(wasm_store_t *store, } wasm_func_t * -wasm_func_new_with_env(wasm_store_t *store, - const wasm_functype_t *type, - wasm_func_callback_with_env_t callback, - void *env, +wasm_func_new_with_env(wasm_store_t *store, const wasm_functype_t *type, + wasm_func_callback_with_env_t callback, void *env, void (*finalizer)(void *)) { bh_assert(singleton_engine); @@ -2452,8 +2430,7 @@ wasm_func_new_with_env(wasm_store_t *store, } wasm_func_t * -wasm_func_new_internal(wasm_store_t *store, - uint16 func_idx_rt, +wasm_func_new_internal(wasm_store_t *store, uint16 func_idx_rt, WASMModuleInstanceCommon *inst_comm_rt) { wasm_func_t *func = NULL; @@ -2477,26 +2454,27 @@ wasm_func_new_internal(wasm_store_t *store, bh_assert(func_idx_rt < ((WASMModuleInstance *)inst_comm_rt)->function_count); WASMFunctionInstance *func_interp = - ((WASMModuleInstance *)inst_comm_rt)->functions + func_idx_rt; + ((WASMModuleInstance *)inst_comm_rt)->functions + func_idx_rt; type_rt = func_interp->is_import_func - ? func_interp->u.func_import->func_type - : func_interp->u.func->func_type; + ? func_interp->u.func_import->func_type + : func_interp->u.func->func_type; } #endif #if WASM_ENABLE_AOT != 0 if (inst_comm_rt->module_type == Wasm_Module_AoT) { - /* use same index to trace the function type in AOTFuncType **func_types */ + /* use same index to trace the function type in AOTFuncType **func_types + */ AOTModule *module_aot = - ((AOTModuleInstance *)inst_comm_rt)->aot_module.ptr; + ((AOTModuleInstance *)inst_comm_rt)->aot_module.ptr; if (func_idx_rt < module_aot->import_func_count) { type_rt = (module_aot->import_funcs + func_idx_rt)->func_type; } else { type_rt = - module_aot - ->func_types[module_aot->func_type_indexes - [func_idx_rt - module_aot->import_func_count]]; + module_aot->func_types[module_aot->func_type_indexes + [func_idx_rt + - module_aot->import_func_count]]; } } #endif @@ -2563,10 +2541,10 @@ wasm_func_copy(const wasm_func_t *func) } if (!(cloned = func->with_env ? wasm_func_new_with_env_basic( - func->store, func->type, func->u.cb_env.cb, - func->u.cb_env.env, func->u.cb_env.finalizer) - : wasm_func_new_basic( - func->store, func->type, func->u.cb))) { + func->store, func->type, func->u.cb_env.cb, + func->u.cb_env.env, func->u.cb_env.finalizer) + : wasm_func_new_basic(func->store, func->type, + func->u.cb))) { goto failed; } @@ -2586,10 +2564,8 @@ wasm_func_type(const wasm_func_t *func) } static uint32 -params_to_argv(WASMModuleInstanceCommon *inst_comm_rt, - const wasm_val_t *params, - const wasm_valtype_vec_t *param_defs, - size_t param_arity, +params_to_argv(WASMModuleInstanceCommon *inst_comm_rt, const wasm_val_t *params, + const wasm_valtype_vec_t *param_defs, size_t param_arity, uint32 *out) { size_t i = 0; @@ -2630,8 +2606,7 @@ params_to_argv(WASMModuleInstanceCommon *inst_comm_rt, break; #if WASM_ENABLE_REF_TYPES != 0 case WASM_ANYREF: - if (!wasm_externref_obj2ref(inst_comm_rt, param->of.ref, - out)) { + if (!wasm_externref_obj2ref(inst_comm_rt, param->of.ref, out)) { goto failed; } @@ -2653,10 +2628,8 @@ failed: } static uint32 -argv_to_results(const uint32 *results, - const wasm_valtype_vec_t *result_defs, - size_t result_arity, - wasm_val_t *out) +argv_to_results(const uint32 *results, const wasm_valtype_vec_t *result_defs, + size_t result_arity, wasm_val_t *out) { size_t i = 0; uint32 argc = 0; @@ -2738,8 +2711,7 @@ failed: } wasm_trap_t * -wasm_func_call(const wasm_func_t *func, - const wasm_val_vec_t *params, +wasm_func_call(const wasm_func_t *func, const wasm_val_vec_t *params, wasm_val_vec_t *results) { /* parameters count as if all are uint32 */ @@ -2764,7 +2736,7 @@ wasm_func_call(const wasm_func_t *func, if (func->inst_comm_rt->module_type == Wasm_Module_AoT) { if (!(func_comm_rt = func->func_comm_rt)) { AOTModuleInstance *inst_aot = - (AOTModuleInstance *)func->inst_comm_rt; + (AOTModuleInstance *)func->inst_comm_rt; AOTModule *module_aot = (AOTModule *)inst_aot->aot_module.ptr; uint32 export_i = 0, export_func_j = 0; @@ -2773,8 +2745,8 @@ wasm_func_call(const wasm_func_t *func, if (export->kind == EXPORT_KIND_FUNC) { if (export->index == func->func_idx_rt) { func_comm_rt = - (AOTFunctionInstance *)inst_aot->export_funcs.ptr - + export_func_j; + (AOTFunctionInstance *)inst_aot->export_funcs.ptr + + export_func_j; ((wasm_func_t *)func)->func_comm_rt = func_comm_rt; break; } @@ -2872,8 +2844,7 @@ wasm_func_result_arity(const wasm_func_t *func) } wasm_global_t * -wasm_global_new(wasm_store_t *store, - const wasm_globaltype_t *global_type, +wasm_global_new(wasm_store_t *store, const wasm_globaltype_t *global_type, const wasm_val_t *init) { wasm_global_t *global = NULL; @@ -2971,18 +2942,17 @@ wasm_global_delete(wasm_global_t *global) #if WASM_ENABLE_INTERP != 0 static bool -interp_global_set(const WASMModuleInstance *inst_interp, - uint16 global_idx_rt, +interp_global_set(const WASMModuleInstance *inst_interp, uint16 global_idx_rt, const wasm_val_t *v) { const WASMGlobalInstance *global_interp = - inst_interp->globals + global_idx_rt; + inst_interp->globals + global_idx_rt; uint8 val_type_rt = global_interp->type; #if WASM_ENABLE_MULTI_MODULE != 0 uint8 *data = global_interp->import_global_inst - ? global_interp->import_module_inst->global_data - + global_interp->import_global_inst->data_offset - : inst_interp->global_data + global_interp->data_offset; + ? global_interp->import_module_inst->global_data + + global_interp->import_global_inst->data_offset + : inst_interp->global_data + global_interp->data_offset; #else uint8 *data = inst_interp->global_data + global_interp->data_offset; #endif @@ -2992,17 +2962,16 @@ interp_global_set(const WASMModuleInstance *inst_interp, } static bool -interp_global_get(const WASMModuleInstance *inst_interp, - uint16 global_idx_rt, +interp_global_get(const WASMModuleInstance *inst_interp, uint16 global_idx_rt, wasm_val_t *out) { WASMGlobalInstance *global_interp = inst_interp->globals + global_idx_rt; uint8 val_type_rt = global_interp->type; #if WASM_ENABLE_MULTI_MODULE != 0 uint8 *data = global_interp->import_global_inst - ? global_interp->import_module_inst->global_data - + global_interp->import_global_inst->data_offset - : inst_interp->global_data + global_interp->data_offset; + ? global_interp->import_module_inst->global_data + + global_interp->import_global_inst->data_offset + : inst_interp->global_data + global_interp->data_offset; #else uint8 *data = inst_interp->global_data + global_interp->data_offset; #endif @@ -3013,8 +2982,7 @@ interp_global_get(const WASMModuleInstance *inst_interp, #if WASM_ENABLE_AOT != 0 static bool -aot_global_set(const AOTModuleInstance *inst_aot, - uint16 global_idx_rt, +aot_global_set(const AOTModuleInstance *inst_aot, uint16 global_idx_rt, const wasm_val_t *v) { AOTModule *module_aot = inst_aot->aot_module.ptr; @@ -3028,21 +2996,20 @@ aot_global_set(const AOTModuleInstance *inst_aot, } else { data_offset = - module_aot->globals[global_idx_rt - module_aot->import_global_count] - .data_offset; + module_aot->globals[global_idx_rt - module_aot->import_global_count] + .data_offset; val_type_rt = - module_aot->globals[global_idx_rt - module_aot->import_global_count] - .type; + module_aot->globals[global_idx_rt - module_aot->import_global_count] + .type; } data = (void *)((uint8 *)inst_aot->global_data.ptr + data_offset); - return wasm_val_to_rt_val((WASMModuleInstanceCommon *)inst_aot, - val_type_rt, v, data); + return wasm_val_to_rt_val((WASMModuleInstanceCommon *)inst_aot, val_type_rt, + v, data); } static bool -aot_global_get(const AOTModuleInstance *inst_aot, - uint16 global_idx_rt, +aot_global_get(const AOTModuleInstance *inst_aot, uint16 global_idx_rt, wasm_val_t *out) { AOTModule *module_aot = inst_aot->aot_module.ptr; @@ -3056,11 +3023,11 @@ aot_global_get(const AOTModuleInstance *inst_aot, } else { data_offset = - module_aot->globals[global_idx_rt - module_aot->import_global_count] - .data_offset; + module_aot->globals[global_idx_rt - module_aot->import_global_count] + .data_offset; val_type_rt = - module_aot->globals[global_idx_rt - module_aot->import_global_count] - .type; + module_aot->globals[global_idx_rt - module_aot->import_global_count] + .type; } data = (uint8 *)inst_aot->global_data.ptr + data_offset; @@ -3131,8 +3098,7 @@ wasm_global_get(const wasm_global_t *global, wasm_val_t *out) } wasm_global_t * -wasm_global_new_internal(wasm_store_t *store, - uint16 global_idx_rt, +wasm_global_new_internal(wasm_store_t *store, uint16 global_idx_rt, WASMModuleInstanceCommon *inst_comm_rt) { wasm_global_t *global = NULL; @@ -3157,7 +3123,7 @@ wasm_global_new_internal(wasm_store_t *store, #if WASM_ENABLE_INTERP != 0 if (inst_comm_rt->module_type == Wasm_Module_Bytecode) { WASMGlobalInstance *global_interp = - ((WASMModuleInstance *)inst_comm_rt)->globals + global_idx_rt; + ((WASMModuleInstance *)inst_comm_rt)->globals + global_idx_rt; val_type_rt = global_interp->type; is_mutable = global_interp->is_mutable; init = true; @@ -3173,14 +3139,14 @@ wasm_global_new_internal(wasm_store_t *store, if (global_idx_rt < module_aot->import_global_count) { AOTImportGlobal *global_import_aot = - module_aot->import_globals + global_idx_rt; + module_aot->import_globals + global_idx_rt; val_type_rt = global_import_aot->type; is_mutable = global_import_aot->is_mutable; } else { AOTGlobal *global_aot = - module_aot->globals - + (global_idx_rt - module_aot->import_global_count); + module_aot->globals + + (global_idx_rt - module_aot->import_global_count); val_type_rt = global_aot->type; is_mutable = global_aot->is_mutable; } @@ -3259,8 +3225,7 @@ wasm_table_new_basic(wasm_store_t *store, const wasm_tabletype_t *type) } wasm_table_t * -wasm_table_new_internal(wasm_store_t *store, - uint16 table_idx_rt, +wasm_table_new_internal(wasm_store_t *store, uint16 table_idx_rt, WASMModuleInstanceCommon *inst_comm_rt) { wasm_table_t *table = NULL; @@ -3284,7 +3249,7 @@ wasm_table_new_internal(wasm_store_t *store, #if WASM_ENABLE_INTERP != 0 if (inst_comm_rt->module_type == Wasm_Module_Bytecode) { WASMTableInstance *table_interp = - ((WASMModuleInstance *)inst_comm_rt)->tables[table_idx_rt]; + ((WASMModuleInstance *)inst_comm_rt)->tables[table_idx_rt]; val_type_rt = table_interp->elem_type; init_size = table_interp->cur_size; max_size = table_interp->max_size; @@ -3299,15 +3264,15 @@ wasm_table_new_internal(wasm_store_t *store, if (table_idx_rt < module_aot->import_table_count) { AOTImportTable *table_aot = - module_aot->import_tables + table_idx_rt; + module_aot->import_tables + table_idx_rt; val_type_rt = VALUE_TYPE_FUNCREF; init_size = table_aot->table_init_size; max_size = table_aot->table_max_size; } else { AOTTable *table_aot = - module_aot->tables - + (table_idx_rt - module_aot->import_table_count); + module_aot->tables + + (table_idx_rt - module_aot->import_table_count); val_type_rt = VALUE_TYPE_FUNCREF; init_size = table_aot->table_init_size; max_size = table_aot->table_max_size; @@ -3325,7 +3290,7 @@ wasm_table_new_internal(wasm_store_t *store, } if (!(table->type = - wasm_tabletype_new_internal(val_type_rt, init_size, max_size))) { + wasm_tabletype_new_internal(val_type_rt, init_size, max_size))) { goto failed; } @@ -3337,8 +3302,7 @@ wasm_table_new_internal(wasm_store_t *store, /* will not actually apply this new table into the runtime */ wasm_table_t * -wasm_table_new(wasm_store_t *store, - const wasm_tabletype_t *table_type, +wasm_table_new(wasm_store_t *store, const wasm_tabletype_t *table_type, wasm_ref_t *init) { wasm_table_t *table; @@ -3406,8 +3370,8 @@ wasm_table_get(const wasm_table_t *table, wasm_table_size_t index) #if WASM_ENABLE_INTERP != 0 if (table->inst_comm_rt->module_type == Wasm_Module_Bytecode) { WASMTableInstance *table_interp = - ((WASMModuleInstance *)table->inst_comm_rt) - ->tables[table->table_idx_rt]; + ((WASMModuleInstance *)table->inst_comm_rt) + ->tables[table->table_idx_rt]; if (index >= table_interp->cur_size) { return NULL; } @@ -3419,7 +3383,7 @@ wasm_table_get(const wasm_table_t *table, wasm_table_size_t index) if (table->inst_comm_rt->module_type == Wasm_Module_AoT) { AOTModuleInstance *inst_aot = (AOTModuleInstance *)table->inst_comm_rt; AOTTableInstance *table_aot = - (AOTTableInstance *)inst_aot->tables.ptr + table->table_idx_rt; + (AOTTableInstance *)inst_aot->tables.ptr + table->table_idx_rt; if (index >= table_aot->cur_size) { return NULL; } @@ -3440,8 +3404,7 @@ wasm_table_get(const wasm_table_t *table, wasm_table_size_t index) } bool -wasm_table_set(wasm_table_t *table, - wasm_table_size_t index, +wasm_table_set(wasm_table_t *table, wasm_table_size_t index, own wasm_ref_t *func_ref) { uint32 *p_func_idx_rt = NULL; @@ -3464,8 +3427,8 @@ wasm_table_set(wasm_table_t *table, #if WASM_ENABLE_INTERP != 0 if (table->inst_comm_rt->module_type == Wasm_Module_Bytecode) { WASMTableInstance *table_interp = - ((WASMModuleInstance *)table->inst_comm_rt) - ->tables[table->table_idx_rt]; + ((WASMModuleInstance *)table->inst_comm_rt) + ->tables[table->table_idx_rt]; if (index >= table_interp->cur_size) { return false; @@ -3473,7 +3436,7 @@ wasm_table_set(wasm_table_t *table, p_func_idx_rt = ((uint32 *)table_interp->base_addr) + index; function_count = - ((WASMModuleInstance *)table->inst_comm_rt)->function_count; + ((WASMModuleInstance *)table->inst_comm_rt)->function_count; } #endif @@ -3482,7 +3445,7 @@ wasm_table_set(wasm_table_t *table, AOTModuleInstance *inst_aot = (AOTModuleInstance *)table->inst_comm_rt; AOTModule *module_aot = (AOTModule *)inst_aot->aot_module.ptr; AOTTableInstance *table_aot = - (AOTTableInstance *)inst_aot->tables.ptr + table->table_idx_rt; + (AOTTableInstance *)inst_aot->tables.ptr + table->table_idx_rt; if (index >= table_aot->cur_size) { return false; @@ -3521,8 +3484,8 @@ wasm_table_size(const wasm_table_t *table) #if WASM_ENABLE_INTERP != 0 if (table->inst_comm_rt->module_type == Wasm_Module_Bytecode) { WASMTableInstance *table_interp = - ((WASMModuleInstance *)table->inst_comm_rt) - ->tables[table->table_idx_rt]; + ((WASMModuleInstance *)table->inst_comm_rt) + ->tables[table->table_idx_rt]; return table_interp->cur_size; } #endif @@ -3534,13 +3497,13 @@ wasm_table_size(const wasm_table_t *table) if (table->table_idx_rt < module_aot->import_table_count) { AOTImportTable *table_aot = - module_aot->import_tables + table->table_idx_rt; + module_aot->import_tables + table->table_idx_rt; return table_aot->table_init_size; } else { AOTTable *table_aot = - module_aot->tables - + (table->table_idx_rt - module_aot->import_table_count); + module_aot->tables + + (table->table_idx_rt - module_aot->import_table_count); return table_aot->table_init_size; } } @@ -3554,8 +3517,7 @@ wasm_table_size(const wasm_table_t *table) } bool -wasm_table_grow(wasm_table_t *table, - wasm_table_size_t delta, +wasm_table_grow(wasm_table_t *table, wasm_table_size_t delta, own wasm_ref_t *init) { (void)table; @@ -3609,8 +3571,7 @@ wasm_memory_copy(const wasm_memory_t *src) } wasm_memory_t * -wasm_memory_new_internal(wasm_store_t *store, - uint16 memory_idx_rt, +wasm_memory_new_internal(wasm_store_t *store, uint16 memory_idx_rt, WASMModuleInstanceCommon *inst_comm_rt) { wasm_memory_t *memory = NULL; @@ -3633,7 +3594,7 @@ wasm_memory_new_internal(wasm_store_t *store, #if WASM_ENABLE_INTERP != 0 if (inst_comm_rt->module_type == Wasm_Module_Bytecode) { WASMMemoryInstance *memory_interp = - ((WASMModuleInstance *)inst_comm_rt)->memories[memory_idx_rt]; + ((WASMModuleInstance *)inst_comm_rt)->memories[memory_idx_rt]; min_pages = memory_interp->cur_page_count; max_pages = memory_interp->max_page_count; init_flag = true; @@ -3710,9 +3671,9 @@ wasm_memory_data(wasm_memory_t *memory) #if WASM_ENABLE_INTERP != 0 if (module_inst_comm->module_type == Wasm_Module_Bytecode) { WASMModuleInstance *module_inst = - (WASMModuleInstance *)module_inst_comm; + (WASMModuleInstance *)module_inst_comm; WASMMemoryInstance *memory_inst = - module_inst->memories[memory->memory_idx_rt]; + module_inst->memories[memory->memory_idx_rt]; return (byte_t *)memory_inst->memory_data; } #endif @@ -3721,8 +3682,8 @@ wasm_memory_data(wasm_memory_t *memory) if (module_inst_comm->module_type == Wasm_Module_AoT) { AOTModuleInstance *module_inst = (AOTModuleInstance *)module_inst_comm; AOTMemoryInstance *memory_inst = - ((AOTMemoryInstance **) - module_inst->memories.ptr)[memory->memory_idx_rt]; + ((AOTMemoryInstance **) + module_inst->memories.ptr)[memory->memory_idx_rt]; return (byte_t *)memory_inst->memory_data.ptr; } #endif @@ -3742,9 +3703,9 @@ wasm_memory_data_size(const wasm_memory_t *memory) #if WASM_ENABLE_INTERP != 0 if (module_inst_comm->module_type == Wasm_Module_Bytecode) { WASMModuleInstance *module_inst = - (WASMModuleInstance *)module_inst_comm; + (WASMModuleInstance *)module_inst_comm; WASMMemoryInstance *memory_inst = - module_inst->memories[memory->memory_idx_rt]; + module_inst->memories[memory->memory_idx_rt]; return memory_inst->cur_page_count * memory_inst->num_bytes_per_page; } #endif @@ -3753,8 +3714,8 @@ wasm_memory_data_size(const wasm_memory_t *memory) if (module_inst_comm->module_type == Wasm_Module_AoT) { AOTModuleInstance *module_inst = (AOTModuleInstance *)module_inst_comm; AOTMemoryInstance *memory_inst = - ((AOTMemoryInstance **) - module_inst->memories.ptr)[memory->memory_idx_rt]; + ((AOTMemoryInstance **) + module_inst->memories.ptr)[memory->memory_idx_rt]; return memory_inst->cur_page_count * memory_inst->num_bytes_per_page; } #endif @@ -3774,9 +3735,9 @@ wasm_memory_size(const wasm_memory_t *memory) #if WASM_ENABLE_INTERP != 0 if (module_inst_comm->module_type == Wasm_Module_Bytecode) { WASMModuleInstance *module_inst = - (WASMModuleInstance *)module_inst_comm; + (WASMModuleInstance *)module_inst_comm; WASMMemoryInstance *memory_inst = - module_inst->memories[memory->memory_idx_rt]; + module_inst->memories[memory->memory_idx_rt]; return memory_inst->cur_page_count; } #endif @@ -3785,8 +3746,8 @@ wasm_memory_size(const wasm_memory_t *memory) if (module_inst_comm->module_type == Wasm_Module_AoT) { AOTModuleInstance *module_inst = (AOTModuleInstance *)module_inst_comm; AOTMemoryInstance *memory_inst = - ((AOTMemoryInstance **) - module_inst->memories.ptr)[memory->memory_idx_rt]; + ((AOTMemoryInstance **) + module_inst->memories.ptr)[memory->memory_idx_rt]; return memory_inst->cur_page_count; } #endif @@ -3810,10 +3771,8 @@ wasm_memory_grow(wasm_memory_t *memory, wasm_memory_pages_t delta) #if WASM_ENABLE_INTERP != 0 static bool -interp_link_func(const wasm_instance_t *inst, - const WASMModule *module_interp, - uint16 func_idx_rt, - wasm_func_t *import) +interp_link_func(const wasm_instance_t *inst, const WASMModule *module_interp, + uint16 func_idx_rt, wasm_func_t *import) { WASMImport *imported_func_interp = NULL; wasm_func_t *cloned = NULL; @@ -3850,8 +3809,7 @@ interp_link_func(const wasm_instance_t *inst, } static bool -interp_link_global(const WASMModule *module_interp, - uint16 global_idx_rt, +interp_link_global(const WASMModule *module_interp, uint16 global_idx_rt, wasm_global_t *import) { WASMImport *imported_global_interp = NULL; @@ -3868,22 +3826,22 @@ interp_link_global(const WASMModule *module_interp, case WASM_I32: bh_assert(VALUE_TYPE_I32 == imported_global_interp->u.global.type); imported_global_interp->u.global.global_data_linked.i32 = - import->init->of.i32; + import->init->of.i32; break; case WASM_I64: bh_assert(VALUE_TYPE_I64 == imported_global_interp->u.global.type); imported_global_interp->u.global.global_data_linked.i64 = - import->init->of.i64; + import->init->of.i64; break; case WASM_F32: bh_assert(VALUE_TYPE_F32 == imported_global_interp->u.global.type); imported_global_interp->u.global.global_data_linked.f32 = - import->init->of.f32; + import->init->of.f32; break; case WASM_F64: bh_assert(VALUE_TYPE_F64 == imported_global_interp->u.global.type); imported_global_interp->u.global.global_data_linked.f64 = - import->init->of.f64; + import->init->of.f64; break; default: return false; @@ -3895,8 +3853,7 @@ interp_link_global(const WASMModule *module_interp, } static uint32 -interp_link(const wasm_instance_t *inst, - const WASMModule *module_interp, +interp_link(const wasm_instance_t *inst, const WASMModule *module_interp, wasm_extern_t *imports[]) { uint32 i = 0; @@ -3970,8 +3927,8 @@ interp_process_export(wasm_store_t *store, { wasm_func_t *func; if (!(func = wasm_func_new_internal( - store, export->index, - (WASMModuleInstanceCommon *)inst_interp))) { + store, export->index, + (WASMModuleInstanceCommon *)inst_interp))) { goto failed; } @@ -3982,8 +3939,8 @@ interp_process_export(wasm_store_t *store, { wasm_global_t *global; if (!(global = wasm_global_new_internal( - store, export->index, - (WASMModuleInstanceCommon *)inst_interp))) { + store, export->index, + (WASMModuleInstanceCommon *)inst_interp))) { goto failed; } @@ -3994,8 +3951,8 @@ interp_process_export(wasm_store_t *store, { wasm_table_t *table; if (!(table = wasm_table_new_internal( - store, export->index, - (WASMModuleInstanceCommon *)inst_interp))) { + store, export->index, + (WASMModuleInstanceCommon *)inst_interp))) { goto failed; } @@ -4006,8 +3963,8 @@ interp_process_export(wasm_store_t *store, { wasm_memory_t *memory; if (!(memory = wasm_memory_new_internal( - store, export->index, - (WASMModuleInstanceCommon *)inst_interp))) { + store, export->index, + (WASMModuleInstanceCommon *)inst_interp))) { goto failed; } @@ -4035,10 +3992,8 @@ failed: #if WASM_ENABLE_AOT != 0 static bool -aot_link_func(const wasm_instance_t *inst, - const AOTModule *module_aot, - uint32 import_func_idx_rt, - wasm_func_t *import) +aot_link_func(const wasm_instance_t *inst, const AOTModule *module_aot, + uint32 import_func_idx_rt, wasm_func_t *import) { AOTImportFunc *import_aot_func = NULL; wasm_func_t *cloned = NULL; @@ -4071,8 +4026,7 @@ aot_link_func(const wasm_instance_t *inst, } static bool -aot_link_global(const AOTModule *module_aot, - uint16 global_idx_rt, +aot_link_global(const AOTModule *module_aot, uint16 global_idx_rt, wasm_global_t *import) { AOTImportGlobal *import_aot_global = NULL; @@ -4116,8 +4070,7 @@ failed: } static uint32 -aot_link(const wasm_instance_t *inst, - const AOTModule *module_aot, +aot_link(const wasm_instance_t *inst, const AOTModule *module_aot, wasm_extern_t *imports[]) { uint32 i = 0; @@ -4169,8 +4122,7 @@ failed: } static bool -aot_process_export(wasm_store_t *store, - const AOTModuleInstance *inst_aot, +aot_process_export(wasm_store_t *store, const AOTModuleInstance *inst_aot, wasm_extern_vec_t *externals) { uint32 i; @@ -4190,8 +4142,8 @@ aot_process_export(wasm_store_t *store, { wasm_func_t *func = NULL; if (!(func = wasm_func_new_internal( - store, export->index, - (WASMModuleInstanceCommon *)inst_aot))) { + store, export->index, + (WASMModuleInstanceCommon *)inst_aot))) { goto failed; } @@ -4202,8 +4154,8 @@ aot_process_export(wasm_store_t *store, { wasm_global_t *global = NULL; if (!(global = wasm_global_new_internal( - store, export->index, - (WASMModuleInstanceCommon *)inst_aot))) { + store, export->index, + (WASMModuleInstanceCommon *)inst_aot))) { goto failed; } @@ -4214,8 +4166,8 @@ aot_process_export(wasm_store_t *store, { wasm_table_t *table; if (!(table = wasm_table_new_internal( - store, export->index, - (WASMModuleInstanceCommon *)inst_aot))) { + store, export->index, + (WASMModuleInstanceCommon *)inst_aot))) { goto failed; } @@ -4226,8 +4178,8 @@ aot_process_export(wasm_store_t *store, { wasm_memory_t *memory; if (!(memory = wasm_memory_new_internal( - store, export->index, - (WASMModuleInstanceCommon *)inst_aot))) { + store, export->index, + (WASMModuleInstanceCommon *)inst_aot))) { goto failed; } @@ -4263,21 +4215,17 @@ failed: #endif /* WASM_ENABLE_AOT */ wasm_instance_t * -wasm_instance_new(wasm_store_t *store, - const wasm_module_t *module, - const wasm_extern_vec_t *imports, - own wasm_trap_t **traps) +wasm_instance_new(wasm_store_t *store, const wasm_module_t *module, + const wasm_extern_vec_t *imports, own wasm_trap_t **traps) { return wasm_instance_new_with_args(store, module, imports, traps, KILOBYTE(32), KILOBYTE(32)); } wasm_instance_t * -wasm_instance_new_with_args(wasm_store_t *store, - const wasm_module_t *module, +wasm_instance_new_with_args(wasm_store_t *store, const wasm_module_t *module, const wasm_extern_vec_t *imports, - own wasm_trap_t **traps, - const uint32 stack_size, + own wasm_trap_t **traps, const uint32 stack_size, const uint32 heap_size) { char error_buf[128] = { 0 }; @@ -4308,8 +4256,9 @@ wasm_instance_new_with_args(wasm_store_t *store, import_count); if (import_count) { - uint32 actual_link_import_count = interp_link( - instance, MODULE_INTERP(module), (wasm_extern_t **)imports->data); + uint32 actual_link_import_count = + interp_link(instance, MODULE_INTERP(module), + (wasm_extern_t **)imports->data); /* make sure a complete import list */ if ((int32)import_count < 0 || import_count != actual_link_import_count) { @@ -4349,7 +4298,7 @@ wasm_instance_new_with_args(wasm_store_t *store, } instance->inst_comm_rt = wasm_runtime_instantiate( - *module, stack_size, heap_size, error_buf, sizeof(error_buf)); + *module, stack_size, heap_size, error_buf, sizeof(error_buf)); if (!instance->inst_comm_rt) { LOG_ERROR(error_buf); goto failed; @@ -4365,19 +4314,19 @@ wasm_instance_new_with_args(wasm_store_t *store, switch (import->kind) { case WASM_EXTERN_FUNC: wasm_extern_as_func(import)->inst_comm_rt = - instance->inst_comm_rt; + instance->inst_comm_rt; break; case WASM_EXTERN_GLOBAL: wasm_extern_as_global(import)->inst_comm_rt = - instance->inst_comm_rt; + instance->inst_comm_rt; break; case WASM_EXTERN_MEMORY: wasm_extern_as_memory(import)->inst_comm_rt = - instance->inst_comm_rt; + instance->inst_comm_rt; break; case WASM_EXTERN_TABLE: wasm_extern_as_table(import)->inst_comm_rt = - instance->inst_comm_rt; + instance->inst_comm_rt; break; default: goto failed; @@ -4387,15 +4336,15 @@ wasm_instance_new_with_args(wasm_store_t *store, /* build the exports list */ #if WASM_ENABLE_INTERP != 0 if (instance->inst_comm_rt->module_type == Wasm_Module_Bytecode) { - uint32 export_cnt = - ((WASMModuleInstance *)instance->inst_comm_rt)->module->export_count; + uint32 export_cnt = ((WASMModuleInstance *)instance->inst_comm_rt) + ->module->export_count; INIT_VEC(instance->exports, wasm_extern_vec_new_uninitialized, export_cnt); - if (!interp_process_export( - store, (WASMModuleInstance *)instance->inst_comm_rt, - instance->exports)) { + if (!interp_process_export(store, + (WASMModuleInstance *)instance->inst_comm_rt, + instance->exports)) { goto failed; } @@ -4406,10 +4355,10 @@ wasm_instance_new_with_args(wasm_store_t *store, #if WASM_ENABLE_AOT != 0 if (instance->inst_comm_rt->module_type == Wasm_Module_AoT) { uint32 export_cnt = - ((AOTModuleInstance *)instance->inst_comm_rt)->export_func_count - + ((AOTModuleInstance *)instance->inst_comm_rt)->export_global_count - + ((AOTModuleInstance *)instance->inst_comm_rt)->export_tab_count - + ((AOTModuleInstance *)instance->inst_comm_rt)->export_mem_count; + ((AOTModuleInstance *)instance->inst_comm_rt)->export_func_count + + ((AOTModuleInstance *)instance->inst_comm_rt)->export_global_count + + ((AOTModuleInstance *)instance->inst_comm_rt)->export_tab_count + + ((AOTModuleInstance *)instance->inst_comm_rt)->export_mem_count; INIT_VEC(instance->exports, wasm_extern_vec_new_uninitialized, export_cnt); @@ -4491,19 +4440,19 @@ wasm_extern_copy(const wasm_extern_t *src) switch (wasm_extern_kind(src)) { case WASM_EXTERN_FUNC: dst = wasm_func_as_extern( - wasm_func_copy(wasm_extern_as_func_const(src))); + wasm_func_copy(wasm_extern_as_func_const(src))); break; case WASM_EXTERN_GLOBAL: dst = wasm_global_as_extern( - wasm_global_copy(wasm_extern_as_global_const(src))); + wasm_global_copy(wasm_extern_as_global_const(src))); break; case WASM_EXTERN_MEMORY: dst = wasm_memory_as_extern( - wasm_memory_copy(wasm_extern_as_memory_const(src))); + wasm_memory_copy(wasm_extern_as_memory_const(src))); break; case WASM_EXTERN_TABLE: dst = wasm_table_as_extern( - wasm_table_copy(wasm_extern_as_table_const(src))); + wasm_table_copy(wasm_extern_as_table_const(src))); break; default: LOG_WARNING("%s meets unsupported kind: %d", __FUNCTION__, @@ -4576,16 +4525,16 @@ wasm_extern_type(const wasm_extern_t *external) switch (wasm_extern_kind(external)) { case WASM_EXTERN_FUNC: return wasm_functype_as_externtype( - wasm_func_type(wasm_extern_as_func_const(external))); + wasm_func_type(wasm_extern_as_func_const(external))); case WASM_EXTERN_GLOBAL: return wasm_globaltype_as_externtype( - wasm_global_type(wasm_extern_as_global_const(external))); + wasm_global_type(wasm_extern_as_global_const(external))); case WASM_EXTERN_MEMORY: return wasm_memorytype_as_externtype( - wasm_memory_type(wasm_extern_as_memory_const(external))); + wasm_memory_type(wasm_extern_as_memory_const(external))); case WASM_EXTERN_TABLE: return wasm_tabletype_as_externtype( - wasm_table_type(wasm_extern_as_table_const(external))); + wasm_table_type(wasm_extern_as_table_const(external))); default: LOG_WARNING("%s meets unsupported kind: %d", __FUNCTION__, external->kind); @@ -4594,45 +4543,45 @@ wasm_extern_type(const wasm_extern_t *external) return NULL; } -#define BASIC_FOUR_LIST(V) \ - V(func) \ - V(global) \ - V(memory) \ +#define BASIC_FOUR_LIST(V) \ + V(func) \ + V(global) \ + V(memory) \ V(table) -#define WASM_EXTERN_AS_OTHER(name) \ - wasm_##name##_t *wasm_extern_as_##name(wasm_extern_t *external) \ - { \ - return (wasm_##name##_t *)external; \ +#define WASM_EXTERN_AS_OTHER(name) \ + wasm_##name##_t *wasm_extern_as_##name(wasm_extern_t *external) \ + { \ + return (wasm_##name##_t *)external; \ } BASIC_FOUR_LIST(WASM_EXTERN_AS_OTHER) #undef WASM_EXTERN_AS_OTHER -#define WASM_OTHER_AS_EXTERN(name) \ - wasm_extern_t *wasm_##name##_as_extern(wasm_##name##_t *other) \ - { \ - return (wasm_extern_t *)other; \ +#define WASM_OTHER_AS_EXTERN(name) \ + wasm_extern_t *wasm_##name##_as_extern(wasm_##name##_t *other) \ + { \ + return (wasm_extern_t *)other; \ } BASIC_FOUR_LIST(WASM_OTHER_AS_EXTERN) #undef WASM_OTHER_AS_EXTERN -#define WASM_EXTERN_AS_OTHER_CONST(name) \ - const wasm_##name##_t *wasm_extern_as_##name##_const( \ - const wasm_extern_t *external) \ - { \ - return (const wasm_##name##_t *)external; \ +#define WASM_EXTERN_AS_OTHER_CONST(name) \ + const wasm_##name##_t *wasm_extern_as_##name##_const( \ + const wasm_extern_t *external) \ + { \ + return (const wasm_##name##_t *)external; \ } BASIC_FOUR_LIST(WASM_EXTERN_AS_OTHER_CONST) #undef WASM_EXTERN_AS_OTHER_CONST -#define WASM_OTHER_AS_EXTERN_CONST(name) \ - const wasm_extern_t *wasm_##name##_as_extern_const( \ - const wasm_##name##_t *other) \ - { \ - return (const wasm_extern_t *)other; \ +#define WASM_OTHER_AS_EXTERN_CONST(name) \ + const wasm_extern_t *wasm_##name##_as_extern_const( \ + const wasm_##name##_t *other) \ + { \ + return (const wasm_extern_t *)other; \ } BASIC_FOUR_LIST(WASM_OTHER_AS_EXTERN_CONST) diff --git a/core/iwasm/common/wasm_c_api_internal.h b/core/iwasm/common/wasm_c_api_internal.h index c77fa454..919d1524 100644 --- a/core/iwasm/common/wasm_c_api_internal.h +++ b/core/iwasm/common/wasm_c_api_internal.h @@ -213,33 +213,27 @@ struct wasm_instance_t { }; wasm_ref_t * -wasm_ref_new_internal(wasm_store_t *store, - enum wasm_reference_kind kind, +wasm_ref_new_internal(wasm_store_t *store, enum wasm_reference_kind kind, uint32 obj_idx_rt, WASMModuleInstanceCommon *inst_comm_rt); wasm_foreign_t * -wasm_foreign_new_internal(wasm_store_t *store, - uint32 foreign_idx_rt, +wasm_foreign_new_internal(wasm_store_t *store, uint32 foreign_idx_rt, WASMModuleInstanceCommon *inst_comm_rt); wasm_func_t * -wasm_func_new_internal(wasm_store_t *store, - uint16 func_idx_rt, +wasm_func_new_internal(wasm_store_t *store, uint16 func_idx_rt, WASMModuleInstanceCommon *inst_comm_rt); wasm_global_t * -wasm_global_new_internal(wasm_store_t *store, - uint16 global_idx_rt, +wasm_global_new_internal(wasm_store_t *store, uint16 global_idx_rt, WASMModuleInstanceCommon *inst_comm_rt); wasm_memory_t * -wasm_memory_new_internal(wasm_store_t *store, - uint16 memory_idx_rt, +wasm_memory_new_internal(wasm_store_t *store, uint16 memory_idx_rt, WASMModuleInstanceCommon *inst_comm_rt); wasm_table_t * -wasm_table_new_internal(wasm_store_t *store, - uint16 table_idx_rt, +wasm_table_new_internal(wasm_store_t *store, uint16 table_idx_rt, WASMModuleInstanceCommon *inst_comm_rt); #endif /* _WASM_C_API_INTERNAL_H */ diff --git a/core/iwasm/common/wasm_exec_env.c b/core/iwasm/common/wasm_exec_env.c index c9e2bf5a..685542b7 100644 --- a/core/iwasm/common/wasm_exec_env.c +++ b/core/iwasm/common/wasm_exec_env.c @@ -27,8 +27,8 @@ WASMExecEnv * wasm_exec_env_create_internal(struct WASMModuleInstanceCommon *module_inst, uint32 stack_size) { - uint64 total_size = offsetof(WASMExecEnv, wasm_stack.s.bottom) - + (uint64)stack_size; + uint64 total_size = + offsetof(WASMExecEnv, wasm_stack.s.bottom) + (uint64)stack_size; WASMExecEnv *exec_env; if (total_size >= UINT32_MAX @@ -122,22 +122,23 @@ wasm_exec_env_create(struct WASMModuleInstanceCommon *module_inst, if (!exec_env) return NULL; - /* Set the aux_stack_boundary and aux_stack_bottom */ #if WASM_ENABLE_INTERP != 0 + /* Set the aux_stack_boundary and aux_stack_bottom */ if (module_inst->module_type == Wasm_Module_Bytecode) { WASMModule *module = ((WASMModuleInstance *)module_inst)->module; exec_env->aux_stack_bottom.bottom = module->aux_stack_bottom; - exec_env->aux_stack_boundary.boundary = module->aux_stack_bottom - - module->aux_stack_size; + exec_env->aux_stack_boundary.boundary = + module->aux_stack_bottom - module->aux_stack_size; } #endif #if WASM_ENABLE_AOT != 0 + /* Set the aux_stack_boundary and aux_stack_bottom */ if (module_inst->module_type == Wasm_Module_AoT) { AOTModule *module = (AOTModule *)(((AOTModuleInstance *)module_inst)->aot_module.ptr); exec_env->aux_stack_bottom.bottom = module->aux_stack_bottom; - exec_env->aux_stack_boundary.boundary = module->aux_stack_bottom - - module->aux_stack_size; + exec_env->aux_stack_boundary.boundary = + module->aux_stack_bottom - module->aux_stack_size; } #endif @@ -150,8 +151,8 @@ wasm_exec_env_create(struct WASMModuleInstanceCommon *module_inst, #if WASM_ENABLE_DEBUG_INTERP != 0 wasm_debug_instance_create(cluster); #endif +#endif /* end of WASM_ENABLE_THREAD_MGR */ -#endif return exec_env; } @@ -162,16 +163,15 @@ wasm_exec_env_destroy(WASMExecEnv *exec_env) /* Terminate all sub-threads */ WASMCluster *cluster = wasm_exec_env_get_cluster(exec_env); if (cluster) { -#if WASM_ENABLE_THREAD_MGR != 0 #if WASM_ENABLE_DEBUG_INTERP != 0 wasm_cluster_thread_exited(exec_env); wasm_debug_instance_destroy(cluster); -#endif #endif wasm_cluster_terminate_all_except_self(cluster, exec_env); wasm_cluster_del_exec_env(cluster, exec_env); } -#endif +#endif /* end of WASM_ENABLE_THREAD_MGR */ + wasm_exec_env_destroy_internal(exec_env); } @@ -224,4 +224,3 @@ wasm_exec_env_pop_jmpbuf(WASMExecEnv *exec_env) return NULL; } #endif - diff --git a/core/iwasm/common/wasm_exec_env.h b/core/iwasm/common/wasm_exec_env.h index dc651445..ea2fafd6 100644 --- a/core/iwasm/common/wasm_exec_env.h +++ b/core/iwasm/common/wasm_exec_env.h @@ -89,7 +89,7 @@ typedef struct WASMExecEnv { void *thread_ret_value; /* Must be provided by thread library */ - void* (*thread_start_routine)(void *); + void *(*thread_start_routine)(void *); void *thread_arg; /* pointer to the cluster */ @@ -192,8 +192,8 @@ wasm_exec_env_alloc_wasm_frame(WASMExecEnv *exec_env, unsigned size) #if WASM_ENABLE_MEMORY_PROFILING != 0 { - uint32 wasm_stack_used = exec_env->wasm_stack.s.top - - exec_env->wasm_stack.s.bottom; + uint32 wasm_stack_used = + exec_env->wasm_stack.s.top - exec_env->wasm_stack.s.bottom; if (wasm_stack_used > exec_env->max_wasm_stack_used) exec_env->max_wasm_stack_used = wasm_stack_used; } @@ -215,7 +215,7 @@ wasm_exec_env_free_wasm_frame(WASMExecEnv *exec_env, void *prev_top) * * @return the current WASM stack top pointer */ -static inline void* +static inline void * wasm_exec_env_wasm_stack_top(WASMExecEnv *exec_env) { return exec_env->wasm_stack.s.top; @@ -241,7 +241,7 @@ wasm_exec_env_set_cur_frame(WASMExecEnv *exec_env, * * @return the current frame pointer */ -static inline struct WASMInterpFrame* +static inline struct WASMInterpFrame * wasm_exec_env_get_cur_frame(WASMExecEnv *exec_env) { return exec_env->cur_frame; @@ -253,7 +253,6 @@ wasm_exec_env_get_module_inst(WASMExecEnv *exec_env); void wasm_exec_env_set_thread_info(WASMExecEnv *exec_env); - #if WASM_ENABLE_THREAD_MGR != 0 void * wasm_exec_env_get_thread_arg(WASMExecEnv *exec_env); diff --git a/core/iwasm/common/wasm_memory.c b/core/iwasm/common/wasm_memory.c index 0b558cb5..42f52cac 100644 --- a/core/iwasm/common/wasm_memory.c +++ b/core/iwasm/common/wasm_memory.c @@ -39,8 +39,7 @@ wasm_memory_init_with_pool(void *mem, unsigned int bytes) } static bool -wasm_memory_init_with_allocator(void *_malloc_func, - void *_realloc_func, +wasm_memory_init_with_allocator(void *_malloc_func, void *_realloc_func, void *_free_func) { if (_malloc_func && _free_func && _malloc_func != _free_func) { @@ -50,8 +49,8 @@ wasm_memory_init_with_allocator(void *_malloc_func, free_func = _free_func; return true; } - LOG_ERROR("Init memory with allocator (%p, %p, %p) failed.\n", - _malloc_func, _realloc_func, _free_func); + LOG_ERROR("Init memory with allocator (%p, %p, %p) failed.\n", _malloc_func, + _realloc_func, _free_func); return false; } @@ -63,9 +62,10 @@ wasm_runtime_memory_init(mem_alloc_type_t mem_alloc_type, return wasm_memory_init_with_pool(alloc_option->pool.heap_buf, alloc_option->pool.heap_size); else if (mem_alloc_type == Alloc_With_Allocator) - return wasm_memory_init_with_allocator(alloc_option->allocator.malloc_func, - alloc_option->allocator.realloc_func, - alloc_option->allocator.free_func); + return wasm_memory_init_with_allocator( + alloc_option->allocator.malloc_func, + alloc_option->allocator.realloc_func, + alloc_option->allocator.free_func); else if (mem_alloc_type == Alloc_With_System_Allocator) return wasm_memory_init_with_allocator(os_malloc, os_realloc, os_free); else @@ -93,7 +93,8 @@ static inline void * wasm_runtime_malloc_internal(unsigned int size) { if (memory_mode == MEMORY_MODE_UNKNOWN) { - LOG_WARNING("wasm_runtime_malloc failed: memory hasn't been initialize.\n"); + LOG_WARNING( + "wasm_runtime_malloc failed: memory hasn't been initialize.\n"); return NULL; } else if (memory_mode == MEMORY_MODE_POOL) { @@ -108,7 +109,8 @@ static inline void * wasm_runtime_realloc_internal(void *ptr, unsigned int size) { if (memory_mode == MEMORY_MODE_UNKNOWN) { - LOG_WARNING("wasm_runtime_realloc failed: memory hasn't been initialize.\n"); + LOG_WARNING( + "wasm_runtime_realloc failed: memory hasn't been initialize.\n"); return NULL; } else if (memory_mode == MEMORY_MODE_POOL) { diff --git a/core/iwasm/common/wasm_memory.h b/core/iwasm/common/wasm_memory.h index 08157acf..8511ae64 100644 --- a/core/iwasm/common/wasm_memory.h +++ b/core/iwasm/common/wasm_memory.h @@ -25,4 +25,3 @@ wasm_runtime_memory_destroy(); #endif #endif /* end of _WASM_MEMORY_H */ - diff --git a/core/iwasm/common/wasm_native.c b/core/iwasm/common/wasm_native.c index 1522b95e..15cb0e5c 100644 --- a/core/iwasm/common/wasm_native.c +++ b/core/iwasm/common/wasm_native.c @@ -17,7 +17,7 @@ #define ENABLE_SORT_DEBUG 0 #if ENABLE_SORT_DEBUG != 0 -#include +#include #endif static NativeSymbolsList g_native_symbols_list = NULL; @@ -80,7 +80,7 @@ check_symbol_signature(const WASMType *type, const char *signature) #if WASM_ENABLE_REF_TYPES != 0 || (sig == 'i' && type->types[i] == VALUE_TYPE_EXTERNREF) #endif - ) + ) /* normal parameter */ continue; @@ -91,8 +91,7 @@ check_symbol_signature(const WASMType *type, const char *signature) if (sig == '*') { /* it is a pointer */ if (i + 1 < type->param_count - && type->types[i + 1] == VALUE_TYPE_I32 - && *p == '~') { + && type->types[i + 1] == VALUE_TYPE_I32 && *p == '~') { /* pointer length followed */ i++; p++; @@ -132,8 +131,8 @@ sort_symbol_ptr(NativeSymbol *native_symbols, uint32 n_native_symbols) for (i = 0; i < n_native_symbols - 1; i++) { for (j = i + 1; j < n_native_symbols; j++) { - if (strcmp(native_symbols[i].symbol, - native_symbols[j].symbol) > 0) { + if (strcmp(native_symbols[i].symbol, native_symbols[j].symbol) + > 0) { temp = native_symbols[i]; native_symbols[i] = native_symbols[j]; native_symbols[j] = temp; @@ -143,7 +142,7 @@ sort_symbol_ptr(NativeSymbol *native_symbols, uint32 n_native_symbols) } #else static void -swap_symbol(NativeSymbol* left, NativeSymbol* right) +swap_symbol(NativeSymbol *left, NativeSymbol *right) { NativeSymbol temp = *left; *left = *right; @@ -151,7 +150,7 @@ swap_symbol(NativeSymbol* left, NativeSymbol* right) } static void -quick_sort_symbols(NativeSymbol* native_symbols, int left, int right) +quick_sort_symbols(NativeSymbol *native_symbols, int left, int right) { NativeSymbol base_symbol; int pin_left = left; @@ -164,8 +163,8 @@ quick_sort_symbols(NativeSymbol* native_symbols, int left, int right) base_symbol = native_symbols[left]; while (left < right) { while (left < right - && strcmp(native_symbols[right].symbol, - base_symbol.symbol) > 0) { + && strcmp(native_symbols[right].symbol, base_symbol.symbol) + > 0) { right--; } @@ -175,8 +174,7 @@ quick_sort_symbols(NativeSymbol* native_symbols, int left, int right) } while (left < right - && strcmp(native_symbols[left].symbol, - base_symbol.symbol) < 0) { + && strcmp(native_symbols[left].symbol, base_symbol.symbol) < 0) { left++; } @@ -216,7 +214,7 @@ lookup_symbol(NativeSymbol *native_symbols, uint32 n_native_symbols, return NULL; } -void* +void * wasm_native_resolve_symbol(const char *module_name, const char *field_name, const WASMType *func_type, const char **p_signature, void **p_attachment, bool *p_call_conv_raw) @@ -229,15 +227,14 @@ wasm_native_resolve_symbol(const char *module_name, const char *field_name, while (node) { node_next = node->next; if (!strcmp(node->module_name, module_name)) { - if ((func_ptr = lookup_symbol(node->native_symbols, - node->n_native_symbols, - field_name, &signature, &attachment)) + if ((func_ptr = + lookup_symbol(node->native_symbols, node->n_native_symbols, + field_name, &signature, &attachment)) || (field_name[0] == '_' - && (func_ptr = lookup_symbol(node->native_symbols, - node->n_native_symbols, - field_name + 1, - &signature, &attachment)))) - break; + && (func_ptr = lookup_symbol( + node->native_symbols, node->n_native_symbols, + field_name + 1, &signature, &attachment)))) + break; } node = node_next; } @@ -246,7 +243,8 @@ wasm_native_resolve_symbol(const char *module_name, const char *field_name, if (signature && signature[0] != '\0') { /* signature is not empty, check its format */ if (!check_symbol_signature(func_type, signature)) { -#if WASM_ENABLE_WAMR_COMPILER == 0 /* Output warning except running aot compiler */ +#if WASM_ENABLE_WAMR_COMPILER == 0 + /* Output warning except running aot compiler */ LOG_WARNING("failed to check signature '%s' and resolve " "pointer params for import function (%s %s)\n", signature, module_name, field_name); @@ -270,10 +268,8 @@ wasm_native_resolve_symbol(const char *module_name, const char *field_name, } static bool -register_natives(const char *module_name, - NativeSymbol *native_symbols, - uint32 n_native_symbols, - bool call_conv_raw) +register_natives(const char *module_name, NativeSymbol *native_symbols, + uint32 n_native_symbols, bool call_conv_raw) { NativeSymbolsNode *node; #if ENABLE_SORT_DEBUG != 0 @@ -309,10 +305,10 @@ register_natives(const char *module_name, #if ENABLE_SORT_DEBUG != 0 gettimeofday(&end, NULL); - timer = 1000000 * (end.tv_sec - start.tv_sec) - + (end.tv_usec - start.tv_usec); - LOG_ERROR("module_name: %s, nums: %d, sorted used: %ld us", - module_name, n_native_symbols, timer); + timer = + 1000000 * (end.tv_sec - start.tv_sec) + (end.tv_usec - start.tv_usec); + LOG_ERROR("module_name: %s, nums: %d, sorted used: %ld us", module_name, + n_native_symbols, timer); #endif return true; } @@ -322,7 +318,8 @@ wasm_native_register_natives(const char *module_name, NativeSymbol *native_symbols, uint32 n_native_symbols) { - return register_natives(module_name, native_symbols, n_native_symbols, false); + return register_natives(module_name, native_symbols, n_native_symbols, + false); } bool @@ -330,7 +327,8 @@ wasm_native_register_natives_raw(const char *module_name, NativeSymbol *native_symbols, uint32 n_native_symbols) { - return register_natives(module_name, native_symbols, n_native_symbols, true); + return register_natives(module_name, native_symbols, n_native_symbols, + true); } bool @@ -341,41 +339,40 @@ wasm_native_init() #if WASM_ENABLE_LIBC_BUILTIN != 0 n_native_symbols = get_libc_builtin_export_apis(&native_symbols); - if (!wasm_native_register_natives("env", - native_symbols, n_native_symbols)) + if (!wasm_native_register_natives("env", native_symbols, n_native_symbols)) return false; #endif /* WASM_ENABLE_LIBC_BUILTIN */ #if WASM_ENABLE_SPEC_TEST n_native_symbols = get_spectest_export_apis(&native_symbols); - if (!wasm_native_register_natives("spectest", - native_symbols, n_native_symbols)) + if (!wasm_native_register_natives("spectest", native_symbols, + n_native_symbols)) return false; #endif /* WASM_ENABLE_SPEC_TEST */ #if WASM_ENABLE_LIBC_WASI != 0 n_native_symbols = get_libc_wasi_export_apis(&native_symbols); - if (!wasm_native_register_natives("wasi_unstable", - native_symbols, n_native_symbols)) + if (!wasm_native_register_natives("wasi_unstable", native_symbols, + n_native_symbols)) return false; - if (!wasm_native_register_natives("wasi_snapshot_preview1", - native_symbols, n_native_symbols)) + if (!wasm_native_register_natives("wasi_snapshot_preview1", native_symbols, + n_native_symbols)) return false; #endif #if WASM_ENABLE_BASE_LIB != 0 n_native_symbols = get_base_lib_export_apis(&native_symbols); if (n_native_symbols > 0 - && !wasm_native_register_natives("env", - native_symbols, n_native_symbols)) + && !wasm_native_register_natives("env", native_symbols, + n_native_symbols)) return false; #endif #if WASM_ENABLE_APP_FRAMEWORK != 0 n_native_symbols = get_ext_lib_export_apis(&native_symbols); if (n_native_symbols > 0 - && !wasm_native_register_natives("env", - native_symbols, n_native_symbols)) + && !wasm_native_register_natives("env", native_symbols, + n_native_symbols)) return false; #endif @@ -385,16 +382,16 @@ wasm_native_init() n_native_symbols = get_lib_pthread_export_apis(&native_symbols); if (n_native_symbols > 0 - && !wasm_native_register_natives("env", - native_symbols, n_native_symbols)) + && !wasm_native_register_natives("env", native_symbols, + n_native_symbols)) return false; #endif #if WASM_ENABLE_LIBC_EMCC != 0 n_native_symbols = get_libc_emcc_export_apis(&native_symbols); if (n_native_symbols > 0 - && !wasm_native_register_natives("env", - native_symbols, n_native_symbols)) + && !wasm_native_register_natives("env", native_symbols, + n_native_symbols)) return false; #endif /* WASM_ENABLE_LIBC_EMCC */ diff --git a/core/iwasm/common/wasm_native.h b/core/iwasm/common/wasm_native.h index d76d238a..2777b38b 100644 --- a/core/iwasm/common/wasm_native.h +++ b/core/iwasm/common/wasm_native.h @@ -49,7 +49,7 @@ wasm_native_lookup_libc_builtin_global(const char *module_name, * * @return the native function pointer if success, NULL otherwise */ -void* +void * wasm_native_resolve_symbol(const char *module_name, const char *field_name, const WASMType *func_type, const char **p_signature, void **p_attachment, bool *p_call_conv_raw); @@ -75,4 +75,3 @@ wasm_native_destroy(); #endif #endif /* end of _WASM_NATIVE_H */ - diff --git a/core/iwasm/common/wasm_runtime_common.c b/core/iwasm/common/wasm_runtime_common.c index e7db08f5..286c2200 100644 --- a/core/iwasm/common/wasm_runtime_common.c +++ b/core/iwasm/common/wasm_runtime_common.c @@ -30,10 +30,10 @@ #include "../common/wasm_c_api_internal.h" #if WASM_ENABLE_MULTI_MODULE != 0 -/* - * a safety insurance to prevent - * circular depencies leading a stack overflow - * try break early +/** + * A safety insurance to prevent + * circular depencies which leads stack overflow + * try to break early */ typedef struct LoadingModule { bh_list_link l; @@ -45,9 +45,9 @@ static bh_list loading_module_list_head; static bh_list *const loading_module_list = &loading_module_list_head; static korp_mutex loading_module_list_lock; -/* - * a list about all exported functions, globals, memories, tables of every - * fully loaded module +/** + * A list to store all exported functions/globals/memories/tables + * of every fully loaded module */ static bh_list registered_module_list_head; static bh_list *const registered_module_list = ®istered_module_list_head; @@ -79,15 +79,12 @@ runtime_malloc(uint64 size, WASMModuleInstanceCommon *module_inst, { void *mem; - if (size >= UINT32_MAX - || !(mem = wasm_runtime_malloc((uint32)size))) { + if (size >= UINT32_MAX || !(mem = wasm_runtime_malloc((uint32)size))) { if (module_inst != NULL) { - wasm_runtime_set_exception(module_inst, - "allocate memory failed"); + wasm_runtime_set_exception(module_inst, "allocate memory failed"); } else if (error_buf != NULL) { - set_error_buf(error_buf, error_buf_size, - "allocate memory failed"); + set_error_buf(error_buf, error_buf_size, "allocate memory failed"); } return NULL; } @@ -186,11 +183,9 @@ fail1: static bool wasm_runtime_exec_env_check(WASMExecEnv *exec_env) { - return exec_env - && exec_env->module_inst - && exec_env->wasm_stack_size > 0 - && exec_env->wasm_stack.s.top_boundary == - exec_env->wasm_stack.s.bottom + exec_env->wasm_stack_size + return exec_env && exec_env->module_inst && exec_env->wasm_stack_size > 0 + && exec_env->wasm_stack.s.top_boundary + == exec_env->wasm_stack.s.bottom + exec_env->wasm_stack_size && exec_env->wasm_stack.s.top <= exec_env->wasm_stack.s.top_boundary; } @@ -265,8 +260,8 @@ wasm_runtime_full_init(RuntimeInitArgs *init_args) #if WASM_ENABLE_DEBUG_INTERP != 0 if (strlen(init_args->ip_addr)) if (!wasm_debug_engine_init(init_args->ip_addr, - init_args->platform_port, - init_args->instance_port)) { + init_args->platform_port, + init_args->instance_port)) { wasm_runtime_destroy(); return false; } @@ -342,29 +337,29 @@ wasm_runtime_register_module_internal(const char *module_name, WASMModuleCommon *module, uint8 *orig_file_buf, uint32 orig_file_buf_size, - char *error_buf, - uint32_t error_buf_size) + char *error_buf, uint32_t error_buf_size) { WASMRegisteredModule *node = NULL; node = wasm_runtime_find_module_registered_by_reference(module); - if (node) { /* module has been registered */ + if (node) { /* module has been registered */ if (node->module_name) { /* module has name */ - if (!module_name || strcmp(node->module_name, module_name)) { - /* module has different name */ - LOG_DEBUG("module(%p) has been registered with name %s", - module, node->module_name); - set_error_buf(error_buf, error_buf_size, - "Register module failed: " - "failed to rename the module"); - return false; - } - else { - /* module has the same name */ - LOG_DEBUG("module(%p) has been registered with the same name %s", - module, node->module_name); - return true; - } + if (!module_name || strcmp(node->module_name, module_name)) { + /* module has different name */ + LOG_DEBUG("module(%p) has been registered with name %s", module, + node->module_name); + set_error_buf(error_buf, error_buf_size, + "Register module failed: " + "failed to rename the module"); + return false; + } + else { + /* module has the same name */ + LOG_DEBUG( + "module(%p) has been registered with the same name %s", + module, node->module_name); + return true; + } } else { /* module has empyt name, reset it */ @@ -420,9 +415,8 @@ wasm_runtime_register_module(const char *module_name, WASMModuleCommon *module, return false; } - return wasm_runtime_register_module_internal( - module_name, module, NULL, 0, - error_buf, error_buf_size); + return wasm_runtime_register_module_internal(module_name, module, NULL, 0, + error_buf, error_buf_size); } void @@ -453,8 +447,7 @@ wasm_runtime_find_module_registered(const char *module_name) module = bh_list_first_elem(registered_module_list); while (module) { module_next = bh_list_elem_next(module); - if (module->module_name - && !strcmp(module_name, module->module_name)) { + if (module->module_name && !strcmp(module_name, module->module_name)) { break; } module = module_next; @@ -512,13 +505,12 @@ wasm_runtime_destroy_registered_module_list() } bool -wasm_runtime_add_loading_module(const char *module_name, - char *error_buf, uint32 error_buf_size) +wasm_runtime_add_loading_module(const char *module_name, char *error_buf, + uint32 error_buf_size) { LOG_DEBUG("add %s into a loading list", module_name); LoadingModule *loadingModule = - runtime_malloc(sizeof(LoadingModule), NULL, - error_buf, error_buf_size); + runtime_malloc(sizeof(LoadingModule), NULL, error_buf, error_buf_size); if (!loadingModule) { return false; @@ -600,8 +592,7 @@ wasm_runtime_destroy_loading_module_list() bool wasm_runtime_is_built_in_module(const char *module_name) { - return (!strcmp("env", module_name) - || !strcmp("wasi_unstable", module_name) + return (!strcmp("env", module_name) || !strcmp("wasi_unstable", module_name) || !strcmp("wasi_snapshot_preview1", module_name) #if WASM_ENABLE_SPEC_TEST != 0 || !strcmp("spectest", module_name) @@ -611,11 +602,11 @@ wasm_runtime_is_built_in_module(const char *module_name) #if WASM_ENABLE_THREAD_MGR != 0 bool -wasm_exec_env_set_aux_stack(WASMExecEnv *exec_env, - uint32 start_offset, uint32 size) +wasm_exec_env_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, + uint32 size) { - WASMModuleInstanceCommon *module_inst - = wasm_exec_env_get_module_inst(exec_env); + WASMModuleInstanceCommon *module_inst = + wasm_exec_env_get_module_inst(exec_env); #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { return wasm_set_aux_stack(exec_env, start_offset, size); @@ -630,11 +621,11 @@ wasm_exec_env_set_aux_stack(WASMExecEnv *exec_env, } bool -wasm_exec_env_get_aux_stack(WASMExecEnv *exec_env, - uint32 *start_offset, uint32 *size) +wasm_exec_env_get_aux_stack(WASMExecEnv *exec_env, uint32 *start_offset, + uint32 *size) { - WASMModuleInstanceCommon *module_inst - = wasm_exec_env_get_module_inst(exec_env); + WASMModuleInstanceCommon *module_inst = + wasm_exec_env_get_module_inst(exec_env); #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { return wasm_get_aux_stack(exec_env, start_offset, size); @@ -656,15 +647,13 @@ wasm_runtime_set_max_thread_num(uint32 num) #endif /* end of WASM_ENABLE_THREAD_MGR */ static WASMModuleCommon * -register_module_with_null_name(WASMModuleCommon *module_common, - char *error_buf, uint32 error_buf_size) +register_module_with_null_name(WASMModuleCommon *module_common, char *error_buf, + uint32 error_buf_size) { #if WASM_ENABLE_MULTI_MODULE != 0 if (module_common) { - if (!wasm_runtime_register_module_internal(NULL, module_common, - NULL, 0, - error_buf, - error_buf_size)) { + if (!wasm_runtime_register_module_internal(NULL, module_common, NULL, 0, + error_buf, error_buf_size)) { wasm_runtime_unload(module_common); return NULL; } @@ -678,8 +667,8 @@ register_module_with_null_name(WASMModuleCommon *module_common, } WASMModuleCommon * -wasm_runtime_load(const uint8 *buf, uint32 size, - char *error_buf, uint32 error_buf_size) +wasm_runtime_load(const uint8 *buf, uint32 size, char *error_buf, + uint32 error_buf_size) { WASMModuleCommon *module_common = NULL; @@ -690,28 +679,28 @@ wasm_runtime_load(const uint8 *buf, uint32 size, if (!module) return NULL; - if (!(aot_module = aot_convert_wasm_module(module, - error_buf, error_buf_size))) { + if (!(aot_module = + aot_convert_wasm_module(module, error_buf, error_buf_size))) { wasm_unload(module); return NULL; } - module_common = (WASMModuleCommon*)aot_module; - return register_module_with_null_name(module_common, - error_buf, error_buf_size); + module_common = (WASMModuleCommon *)aot_module; + return register_module_with_null_name(module_common, error_buf, + error_buf_size); #elif WASM_ENABLE_INTERP != 0 - module_common = (WASMModuleCommon*) - wasm_load(buf, size, error_buf, error_buf_size); - return register_module_with_null_name(module_common, - error_buf, error_buf_size); + module_common = + (WASMModuleCommon *)wasm_load(buf, size, error_buf, error_buf_size); + return register_module_with_null_name(module_common, error_buf, + error_buf_size); #endif } else if (get_package_type(buf, size) == Wasm_Module_AoT) { #if WASM_ENABLE_AOT != 0 - module_common = (WASMModuleCommon*) - aot_load_from_aot_file(buf, size, error_buf, error_buf_size); - return register_module_with_null_name(module_common, - error_buf, error_buf_size); + module_common = (WASMModuleCommon *)aot_load_from_aot_file( + buf, size, error_buf, error_buf_size); + return register_module_with_null_name(module_common, error_buf, + error_buf_size); #endif } @@ -719,8 +708,8 @@ wasm_runtime_load(const uint8 *buf, uint32 size, set_error_buf(error_buf, error_buf_size, "WASM module load failed: unexpected end"); else - set_error_buf(error_buf, error_buf_size, - "WASM module load failed: magic header not detected"); + set_error_buf(error_buf, error_buf_size, + "WASM module load failed: magic header not detected"); return NULL; } @@ -732,20 +721,18 @@ wasm_runtime_load_from_sections(WASMSection *section_list, bool is_aot, #if WASM_ENABLE_INTERP != 0 if (!is_aot) { - module_common = (WASMModuleCommon*) - wasm_load_from_sections(section_list, - error_buf, error_buf_size); - return register_module_with_null_name(module_common, - error_buf, error_buf_size); + module_common = (WASMModuleCommon *)wasm_load_from_sections( + section_list, error_buf, error_buf_size); + return register_module_with_null_name(module_common, error_buf, + error_buf_size); } #endif #if WASM_ENABLE_AOT != 0 if (is_aot) { - module_common = (WASMModuleCommon*) - aot_load_from_sections(section_list, - error_buf, error_buf_size); - return register_module_with_null_name(module_common, - error_buf, error_buf_size); + module_common = (WASMModuleCommon *)aot_load_from_sections( + section_list, error_buf, error_buf_size); + return register_module_with_null_name(module_common, error_buf, + error_buf_size); } #endif @@ -767,14 +754,14 @@ wasm_runtime_unload(WASMModuleCommon *module) #if WASM_ENABLE_INTERP != 0 if (module->module_type == Wasm_Module_Bytecode) { - wasm_unload((WASMModule*)module); + wasm_unload((WASMModule *)module); return; } #endif #if WASM_ENABLE_AOT != 0 if (module->module_type == Wasm_Module_AoT) { - aot_unload((AOTModule*)module); + aot_unload((AOTModule *)module); return; } #endif @@ -787,17 +774,15 @@ wasm_runtime_instantiate_internal(WASMModuleCommon *module, bool is_sub_inst, { #if WASM_ENABLE_INTERP != 0 if (module->module_type == Wasm_Module_Bytecode) - return (WASMModuleInstanceCommon*) - wasm_instantiate((WASMModule*)module, is_sub_inst, - stack_size, heap_size, - error_buf, error_buf_size); + return (WASMModuleInstanceCommon *)wasm_instantiate( + (WASMModule *)module, is_sub_inst, stack_size, heap_size, error_buf, + error_buf_size); #endif #if WASM_ENABLE_AOT != 0 if (module->module_type == Wasm_Module_AoT) - return (WASMModuleInstanceCommon*) - aot_instantiate((AOTModule*)module, is_sub_inst, - stack_size, heap_size, - error_buf, error_buf_size); + return (WASMModuleInstanceCommon *)aot_instantiate( + (AOTModule *)module, is_sub_inst, stack_size, heap_size, error_buf, + error_buf_size); #endif set_error_buf(error_buf, error_buf_size, "Instantiate module failed, invalid module type"); @@ -805,13 +790,12 @@ wasm_runtime_instantiate_internal(WASMModuleCommon *module, bool is_sub_inst, } WASMModuleInstanceCommon * -wasm_runtime_instantiate(WASMModuleCommon *module, - uint32 stack_size, uint32 heap_size, - char *error_buf, uint32 error_buf_size) +wasm_runtime_instantiate(WASMModuleCommon *module, uint32 stack_size, + uint32 heap_size, char *error_buf, + uint32 error_buf_size) { - return wasm_runtime_instantiate_internal(module, false, - stack_size, heap_size, - error_buf, error_buf_size); + return wasm_runtime_instantiate_internal( + module, false, stack_size, heap_size, error_buf, error_buf_size); } void @@ -820,13 +804,13 @@ wasm_runtime_deinstantiate_internal(WASMModuleInstanceCommon *module_inst, { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { - wasm_deinstantiate((WASMModuleInstance*)module_inst, is_sub_inst); + wasm_deinstantiate((WASMModuleInstance *)module_inst, is_sub_inst); return; } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { - aot_deinstantiate((AOTModuleInstance*)module_inst, is_sub_inst); + aot_deinstantiate((AOTModuleInstance *)module_inst, is_sub_inst); return; } #endif @@ -894,12 +878,12 @@ wasm_runtime_dump_module_mem_consumption(const WASMModuleCommon *module) #if WASM_ENABLE_INTERP != 0 if (module->module_type == Wasm_Module_Bytecode) { - wasm_get_module_mem_consumption((WASMModule*)module, &mem_conspn); + wasm_get_module_mem_consumption((WASMModule *)module, &mem_conspn); } #endif #if WASM_ENABLE_AOT != 0 if (module->module_type == Wasm_Module_AoT) { - aot_get_module_mem_consumption((AOTModule*)module, &mem_conspn); + aot_get_module_mem_consumption((AOTModule *)module, &mem_conspn); } #endif @@ -922,20 +906,20 @@ wasm_runtime_dump_module_mem_consumption(const WASMModuleCommon *module) } void -wasm_runtime_dump_module_inst_mem_consumption(const WASMModuleInstanceCommon - *module_inst) +wasm_runtime_dump_module_inst_mem_consumption( + const WASMModuleInstanceCommon *module_inst) { WASMModuleInstMemConsumption mem_conspn = { 0 }; #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { - wasm_get_module_inst_mem_consumption((WASMModuleInstance*)module_inst, + wasm_get_module_inst_mem_consumption((WASMModuleInstance *)module_inst, &mem_conspn); } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { - aot_get_module_inst_mem_consumption((AOTModuleInstance*)module_inst, + aot_get_module_inst_mem_consumption((AOTModuleInstance *)module_inst, &mem_conspn); } #endif @@ -955,8 +939,8 @@ wasm_runtime_dump_module_inst_mem_consumption(const WASMModuleInstanceCommon void wasm_runtime_dump_exec_env_mem_consumption(const WASMExecEnv *exec_env) { - uint32 total_size = offsetof(WASMExecEnv, wasm_stack.s.bottom) - + exec_env->wasm_stack_size; + uint32 total_size = + offsetof(WASMExecEnv, wasm_stack.s.bottom) + exec_env->wasm_stack_size; os_printf("Exec env memory consumption, total size: %u\n", total_size); os_printf(" exec env struct size: %u\n", @@ -986,16 +970,15 @@ wasm_runtime_dump_mem_consumption(WASMExecEnv *exec_env) #if WASM_ENABLE_INTERP != 0 if (module_inst_common->module_type == Wasm_Module_Bytecode) { WASMModuleInstance *wasm_module_inst = - (WASMModuleInstance*)module_inst_common; + (WASMModuleInstance *)module_inst_common; WASMModule *wasm_module = wasm_module_inst->module; - module_common = (WASMModuleCommon*)wasm_module; + module_common = (WASMModuleCommon *)wasm_module; if (wasm_module_inst->memories) { heap_handle = wasm_module_inst->memories[0]->heap_handle; } - wasm_get_module_inst_mem_consumption - (wasm_module_inst, &module_inst_mem_consps); - wasm_get_module_mem_consumption - (wasm_module, &module_mem_consps); + wasm_get_module_inst_mem_consumption(wasm_module_inst, + &module_inst_mem_consps); + wasm_get_module_mem_consumption(wasm_module, &module_mem_consps); if (wasm_module_inst->module->aux_stack_top_global_index != (uint32)-1) max_aux_stack_used = wasm_module_inst->max_aux_stack_used; } @@ -1003,19 +986,17 @@ wasm_runtime_dump_mem_consumption(WASMExecEnv *exec_env) #if WASM_ENABLE_AOT != 0 if (module_inst_common->module_type == Wasm_Module_AoT) { AOTModuleInstance *aot_module_inst = - (AOTModuleInstance*)module_inst_common; - AOTModule *aot_module = - (AOTModule*)aot_module_inst->aot_module.ptr; - module_common = (WASMModuleCommon*)aot_module; + (AOTModuleInstance *)module_inst_common; + AOTModule *aot_module = (AOTModule *)aot_module_inst->aot_module.ptr; + module_common = (WASMModuleCommon *)aot_module; if (aot_module_inst->memories.ptr) { AOTMemoryInstance **memories = - (AOTMemoryInstance **)aot_module_inst->memories.ptr; + (AOTMemoryInstance **)aot_module_inst->memories.ptr; heap_handle = memories[0]->heap_handle.ptr; } - aot_get_module_inst_mem_consumption - (aot_module_inst, &module_inst_mem_consps); - aot_get_module_mem_consumption - (aot_module, &module_mem_consps); + aot_get_module_inst_mem_consumption(aot_module_inst, + &module_inst_mem_consps); + aot_get_module_mem_consumption(aot_module, &module_mem_consps); } #endif @@ -1026,8 +1007,7 @@ wasm_runtime_dump_mem_consumption(WASMExecEnv *exec_env) } total_size = offsetof(WASMExecEnv, wasm_stack.s.bottom) - + exec_env->wasm_stack_size - + module_mem_consps.total_size + + exec_env->wasm_stack_size + module_mem_consps.total_size + module_inst_mem_consps.total_size; os_printf("\nMemory consumption summary (bytes):\n"); @@ -1035,7 +1015,8 @@ wasm_runtime_dump_mem_consumption(WASMExecEnv *exec_env) wasm_runtime_dump_module_inst_mem_consumption(module_inst_common); wasm_runtime_dump_exec_env_mem_consumption(exec_env); os_printf("\nTotal memory consumption of module, module inst and " - "exec env: %u\n", total_size); + "exec env: %u\n", + total_size); os_printf("Total interpreter stack used: %u\n", exec_env->max_wasm_stack_used); @@ -1046,7 +1027,7 @@ wasm_runtime_dump_mem_consumption(WASMExecEnv *exec_env) os_printf("Total app heap used: %u\n", app_heap_peak_size); } -#endif /* end of (WASM_ENABLE_MEMORY_PROFILING != 0) +#endif /* end of (WASM_ENABLE_MEMORY_PROFILING != 0) \ || (WASM_ENABLE_MEMORY_TRACING != 0) */ #if WASM_ENABLE_PERF_PROFILING != 0 @@ -1055,12 +1036,12 @@ wasm_runtime_dump_perf_profiling(WASMModuleInstanceCommon *module_inst) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { - wasm_dump_perf_profiling((WASMModuleInstance*)module_inst); + wasm_dump_perf_profiling((WASMModuleInstance *)module_inst); } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { - aot_dump_perf_profiling((AOTModuleInstance*)module_inst); + aot_dump_perf_profiling((AOTModuleInstance *)module_inst); } #endif } @@ -1099,17 +1080,15 @@ wasm_runtime_get_function_type(const WASMFunctionInstanceCommon *function, #if WASM_ENABLE_INTERP != 0 if (module_type == Wasm_Module_Bytecode) { WASMFunctionInstance *wasm_func = (WASMFunctionInstance *)function; - type = wasm_func->is_import_func - ? wasm_func->u.func_import->func_type - : wasm_func->u.func->func_type; + type = wasm_func->is_import_func ? wasm_func->u.func_import->func_type + : wasm_func->u.func->func_type; } #endif #if WASM_ENABLE_AOT != 0 if (module_type == Wasm_Module_AoT) { AOTFunctionInstance *aot_func = (AOTFunctionInstance *)function; - type = aot_func->is_import_func - ? aot_func->u.func_import->func_type - : aot_func->u.func.func_type; + type = aot_func->is_import_func ? aot_func->u.func_import->func_type + : aot_func->u.func.func_type; } #endif @@ -1117,20 +1096,18 @@ wasm_runtime_get_function_type(const WASMFunctionInstanceCommon *function, } WASMFunctionInstanceCommon * -wasm_runtime_lookup_function(WASMModuleInstanceCommon * const module_inst, +wasm_runtime_lookup_function(WASMModuleInstanceCommon *const module_inst, const char *name, const char *signature) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - return (WASMFunctionInstanceCommon*) - wasm_lookup_function((const WASMModuleInstance*)module_inst, - name, signature); + return (WASMFunctionInstanceCommon *)wasm_lookup_function( + (const WASMModuleInstance *)module_inst, name, signature); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - return (WASMFunctionInstanceCommon*) - aot_lookup_function((const AOTModuleInstance*)module_inst, - name, signature); + return (WASMFunctionInstanceCommon *)aot_lookup_function( + (const AOTModuleInstance *)module_inst, name, signature); #endif return NULL; } @@ -1143,7 +1120,7 @@ wasm_runtime_reclaim_externref(WASMExecEnv *exec_env, { uint32 i = 0, cell_num = 0; WASMType *func_type = wasm_runtime_get_function_type( - function, exec_env->module_inst->module_type); + function, exec_env->module_inst->module_type); bh_assert(func_type); while (i < func_type->result_count) { @@ -1181,8 +1158,8 @@ wasm_runtime_finalize_call_function(WASMExecEnv *exec_env, bool wasm_runtime_call_wasm(WASMExecEnv *exec_env, - WASMFunctionInstanceCommon *function, - uint32 argc, uint32 argv[]) + WASMFunctionInstanceCommon *function, uint32 argc, + uint32 argv[]) { bool ret = false; @@ -1197,15 +1174,13 @@ wasm_runtime_call_wasm(WASMExecEnv *exec_env, #if WASM_ENABLE_INTERP != 0 if (exec_env->module_inst->module_type == Wasm_Module_Bytecode) - ret = wasm_call_function(exec_env, - (WASMFunctionInstance*)function, - argc, argv); + ret = wasm_call_function(exec_env, (WASMFunctionInstance *)function, + argc, argv); #endif #if WASM_ENABLE_AOT != 0 if (exec_env->module_inst->module_type == Wasm_Module_AoT) - ret = aot_call_function(exec_env, - (AOTFunctionInstance*)function, - argc, argv); + ret = aot_call_function(exec_env, (AOTFunctionInstance *)function, argc, + argv); #endif #if WASM_ENABLE_REF_TYPES != 0 @@ -1216,8 +1191,7 @@ wasm_runtime_call_wasm(WASMExecEnv *exec_env, } static uint32 -parse_args_to_uint32_array(WASMType *type, - uint32 num_args, wasm_val_t *args, +parse_args_to_uint32_array(WASMType *type, uint32 num_args, wasm_val_t *args, uint32 *out_argv) { uint32 i, p; @@ -1229,7 +1203,10 @@ parse_args_to_uint32_array(WASMType *type, break; case WASM_I64: { - union { uint64 val; uint32 parts[2]; } u; + union { + uint64 val; + uint32 parts[2]; + } u; u.val = args[i].of.i64; out_argv[p++] = u.parts[0]; out_argv[p++] = u.parts[1]; @@ -1237,14 +1214,20 @@ parse_args_to_uint32_array(WASMType *type, } case WASM_F32: { - union { float32 val; uint32 part; } u; + union { + float32 val; + uint32 part; + } u; u.val = args[i].of.f32; out_argv[p++] = u.part; break; } case WASM_F64: { - union { float64 val; uint32 parts[2]; } u; + union { + float64 val; + uint32 parts[2]; + } u; u.val = args[i].of.f64; out_argv[p++] = u.parts[0]; out_argv[p++] = u.parts[1]; @@ -1259,8 +1242,7 @@ parse_args_to_uint32_array(WASMType *type, } static uint32 -parse_uint32_array_to_results(WASMType *type, - uint32 argc, uint32 *argv, +parse_uint32_array_to_results(WASMType *type, uint32 argc, uint32 *argv, wasm_val_t *out_results) { uint32 i, p; @@ -1273,7 +1255,10 @@ parse_uint32_array_to_results(WASMType *type, break; case VALUE_TYPE_I64: { - union { uint64 val; uint32 parts[2]; } u; + union { + uint64 val; + uint32 parts[2]; + } u; u.parts[0] = argv[p++]; u.parts[1] = argv[p++]; out_results[i].kind = WASM_I64; @@ -1282,7 +1267,10 @@ parse_uint32_array_to_results(WASMType *type, } case VALUE_TYPE_F32: { - union { float32 val; uint32 part; } u; + union { + float32 val; + uint32 part; + } u; u.part = argv[p++]; out_results[i].kind = WASM_F32; out_results[i].of.f32 = u.val; @@ -1290,7 +1278,10 @@ parse_uint32_array_to_results(WASMType *type, } case VALUE_TYPE_F64: { - union { float64 val; uint32 parts[2]; } u; + union { + float64 val; + uint32 parts[2]; + } u; u.parts[0] = argv[p++]; u.parts[1] = argv[p++]; out_results[i].kind = WASM_F64; @@ -1320,7 +1311,8 @@ wasm_runtime_call_wasm_a(WASMExecEnv *exec_env, type = wasm_runtime_get_function_type(function, module_type); if (!type) { - LOG_ERROR("Function type get failed, WAMR Interpreter and AOT must be enabled at least one."); + LOG_ERROR("Function type get failed, WAMR Interpreter and AOT must be " + "enabled at least one."); goto fail1; } @@ -1328,18 +1320,22 @@ wasm_runtime_call_wasm_a(WASMExecEnv *exec_env, cell_num = (argc > type->ret_cell_num) ? argc : type->ret_cell_num; if (num_results != type->result_count) { - LOG_ERROR("The result value number does not match the function declaration."); + LOG_ERROR( + "The result value number does not match the function declaration."); goto fail1; } if (num_args != type->param_count) { - LOG_ERROR("The argument value number does not match the function declaration."); + LOG_ERROR("The argument value number does not match the function " + "declaration."); goto fail1; } total_size = sizeof(uint32) * (uint64)(cell_num > 2 ? cell_num : 2); - if (!(argv = runtime_malloc((uint32)total_size, exec_env->module_inst, NULL, 0))) { - wasm_runtime_set_exception(exec_env->module_inst, "allocate memory failed"); + if (!(argv = runtime_malloc((uint32)total_size, exec_env->module_inst, NULL, + 0))) { + wasm_runtime_set_exception(exec_env->module_inst, + "allocate memory failed"); goto fail1; } @@ -1347,7 +1343,8 @@ wasm_runtime_call_wasm_a(WASMExecEnv *exec_env, if (!(ret = wasm_runtime_call_wasm(exec_env, function, argc, argv))) goto fail2; - ret_num = parse_uint32_array_to_results(type, type->ret_cell_num, argv, results); + ret_num = + parse_uint32_array_to_results(type, type->ret_cell_num, argv, results); bh_assert(ret_num == num_results); (void)ret_num; @@ -1383,8 +1380,10 @@ wasm_runtime_call_wasm_v(WASMExecEnv *exec_env, "function declaration."); goto fail1; } - if (!(args = runtime_malloc(sizeof(wasm_val_t) * num_args, NULL, NULL, 0))) { - wasm_runtime_set_exception(exec_env->module_inst, "allocate memory failed"); + if (!(args = + runtime_malloc(sizeof(wasm_val_t) * num_args, NULL, NULL, 0))) { + wasm_runtime_set_exception(exec_env->module_inst, + "allocate memory failed"); goto fail1; } @@ -1405,7 +1404,7 @@ wasm_runtime_call_wasm_v(WASMExecEnv *exec_env, break; case VALUE_TYPE_F64: args[i].kind = WASM_F64; - args[i].of.f64 = va_arg(vargs, float64);; + args[i].of.f64 = va_arg(vargs, float64); break; default: bh_assert(0); @@ -1422,23 +1421,23 @@ fail1: } bool -wasm_runtime_create_exec_env_and_call_wasm(WASMModuleInstanceCommon *module_inst, - WASMFunctionInstanceCommon *function, - uint32 argc, uint32 argv[]) +wasm_runtime_create_exec_env_and_call_wasm( + WASMModuleInstanceCommon *module_inst, WASMFunctionInstanceCommon *function, + uint32 argc, uint32 argv[]) { bool ret = false; #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) ret = wasm_create_exec_env_and_call_function( - (WASMModuleInstance *)module_inst, (WASMFunctionInstance *)function, - argc, argv); + (WASMModuleInstance *)module_inst, (WASMFunctionInstance *)function, + argc, argv); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) ret = aot_create_exec_env_and_call_function( - (AOTModuleInstance *)module_inst, (AOTFunctionInstance *)function, - argc, argv); + (AOTModuleInstance *)module_inst, (AOTFunctionInstance *)function, + argc, argv); #endif return ret; } @@ -1448,7 +1447,8 @@ wasm_runtime_create_exec_env_singleton(WASMModuleInstanceCommon *module_inst) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - return wasm_create_exec_env_singleton((WASMModuleInstance *)module_inst); + return wasm_create_exec_env_singleton( + (WASMModuleInstance *)module_inst); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) @@ -1466,8 +1466,8 @@ wasm_runtime_get_exec_env_singleton(WASMModuleInstanceCommon *module_inst) #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - return (WASMExecEnv *) - ((AOTModuleInstance *)module_inst)->exec_env_singleton.ptr; + return (WASMExecEnv *)((AOTModuleInstance *)module_inst) + ->exec_env_singleton.ptr; #endif return NULL; } @@ -1478,29 +1478,29 @@ wasm_runtime_set_exception(WASMModuleInstanceCommon *module_inst, { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { - wasm_set_exception((WASMModuleInstance*)module_inst, exception); + wasm_set_exception((WASMModuleInstance *)module_inst, exception); return; } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { - aot_set_exception((AOTModuleInstance*)module_inst, exception); + aot_set_exception((AOTModuleInstance *)module_inst, exception); return; } #endif } -const char* +const char * wasm_runtime_get_exception(WASMModuleInstanceCommon *module_inst) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { - return wasm_get_exception((WASMModuleInstance*)module_inst); + return wasm_get_exception((WASMModuleInstance *)module_inst); } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { - return aot_get_exception((AOTModuleInstance*)module_inst); + return aot_get_exception((AOTModuleInstance *)module_inst); } #endif return NULL; @@ -1518,13 +1518,13 @@ wasm_runtime_set_custom_data_internal(WASMModuleInstanceCommon *module_inst, { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { - ((WASMModuleInstance*)module_inst)->custom_data = custom_data; + ((WASMModuleInstance *)module_inst)->custom_data = custom_data; return; } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { - ((AOTModuleInstance*)module_inst)->custom_data.ptr = custom_data; + ((AOTModuleInstance *)module_inst)->custom_data.ptr = custom_data; return; } #endif @@ -1541,16 +1541,16 @@ wasm_runtime_set_custom_data(WASMModuleInstanceCommon *module_inst, #endif } -void* +void * wasm_runtime_get_custom_data(WASMModuleInstanceCommon *module_inst) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - return ((WASMModuleInstance*)module_inst)->custom_data; + return ((WASMModuleInstance *)module_inst)->custom_data; #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - return ((AOTModuleInstance*)module_inst)->custom_data.ptr; + return ((AOTModuleInstance *)module_inst)->custom_data.ptr; #endif return NULL; } @@ -1561,12 +1561,12 @@ wasm_runtime_module_malloc(WASMModuleInstanceCommon *module_inst, uint32 size, { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - return wasm_module_malloc((WASMModuleInstance*)module_inst, size, + return wasm_module_malloc((WASMModuleInstance *)module_inst, size, p_native_addr); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - return aot_module_malloc((AOTModuleInstance*)module_inst, size, + return aot_module_malloc((AOTModuleInstance *)module_inst, size, p_native_addr); #endif return 0; @@ -1578,13 +1578,13 @@ wasm_runtime_module_realloc(WASMModuleInstanceCommon *module_inst, uint32 ptr, { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - return wasm_module_realloc((WASMModuleInstance*)module_inst, ptr, - size, p_native_addr); + return wasm_module_realloc((WASMModuleInstance *)module_inst, ptr, size, + p_native_addr); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - return aot_module_realloc((AOTModuleInstance*)module_inst, ptr, - size, p_native_addr); + return aot_module_realloc((AOTModuleInstance *)module_inst, ptr, size, + p_native_addr); #endif return 0; } @@ -1594,13 +1594,13 @@ wasm_runtime_module_free(WASMModuleInstanceCommon *module_inst, uint32 ptr) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { - wasm_module_free((WASMModuleInstance*)module_inst, ptr); + wasm_module_free((WASMModuleInstance *)module_inst, ptr); return; } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { - aot_module_free((AOTModuleInstance*)module_inst, ptr); + aot_module_free((AOTModuleInstance *)module_inst, ptr); return; } #endif @@ -1612,12 +1612,13 @@ wasm_runtime_module_dup_data(WASMModuleInstanceCommon *module_inst, { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { - return wasm_module_dup_data((WASMModuleInstance*)module_inst, src, size); + return wasm_module_dup_data((WASMModuleInstance *)module_inst, src, + size); } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { - return aot_module_dup_data((AOTModuleInstance*)module_inst, src, size); + return aot_module_dup_data((AOTModuleInstance *)module_inst, src, size); } #endif return 0; @@ -1629,12 +1630,12 @@ wasm_runtime_validate_app_addr(WASMModuleInstanceCommon *module_inst, { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - return wasm_validate_app_addr((WASMModuleInstance*)module_inst, + return wasm_validate_app_addr((WASMModuleInstance *)module_inst, app_offset, size); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - return aot_validate_app_addr((AOTModuleInstance*)module_inst, + return aot_validate_app_addr((AOTModuleInstance *)module_inst, app_offset, size); #endif return false; @@ -1647,8 +1648,8 @@ wasm_runtime_validate_app_str_addr(WASMModuleInstanceCommon *module_inst, uint32 app_end_offset; char *str, *str_end; - if (!wasm_runtime_get_app_addr_range(module_inst, app_str_offset, - NULL, &app_end_offset)) + if (!wasm_runtime_get_app_addr_range(module_inst, app_str_offset, NULL, + &app_end_offset)) goto fail; str = wasm_runtime_addr_app_to_native(module_inst, app_str_offset); @@ -1670,12 +1671,12 @@ wasm_runtime_validate_native_addr(WASMModuleInstanceCommon *module_inst, { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - return wasm_validate_native_addr((WASMModuleInstance*)module_inst, + return wasm_validate_native_addr((WASMModuleInstance *)module_inst, native_ptr, size); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - return aot_validate_native_addr((AOTModuleInstance*)module_inst, + return aot_validate_native_addr((AOTModuleInstance *)module_inst, native_ptr, size); #endif return false; @@ -1687,12 +1688,12 @@ wasm_runtime_addr_app_to_native(WASMModuleInstanceCommon *module_inst, { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - return wasm_addr_app_to_native((WASMModuleInstance*)module_inst, + return wasm_addr_app_to_native((WASMModuleInstance *)module_inst, app_offset); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - return aot_addr_app_to_native((AOTModuleInstance*)module_inst, + return aot_addr_app_to_native((AOTModuleInstance *)module_inst, app_offset); #endif return NULL; @@ -1704,12 +1705,12 @@ wasm_runtime_addr_native_to_app(WASMModuleInstanceCommon *module_inst, { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - return wasm_addr_native_to_app((WASMModuleInstance*)module_inst, + return wasm_addr_native_to_app((WASMModuleInstance *)module_inst, native_ptr); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - return aot_addr_native_to_app((AOTModuleInstance*)module_inst, + return aot_addr_native_to_app((AOTModuleInstance *)module_inst, native_ptr); #endif return 0; @@ -1717,19 +1718,18 @@ wasm_runtime_addr_native_to_app(WASMModuleInstanceCommon *module_inst, bool wasm_runtime_get_app_addr_range(WASMModuleInstanceCommon *module_inst, - uint32 app_offset, - uint32 *p_app_start_offset, + uint32 app_offset, uint32 *p_app_start_offset, uint32 *p_app_end_offset) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - return wasm_get_app_addr_range((WASMModuleInstance*)module_inst, - app_offset, p_app_start_offset, - p_app_end_offset); + return wasm_get_app_addr_range((WASMModuleInstance *)module_inst, + app_offset, p_app_start_offset, + p_app_end_offset); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - return aot_get_app_addr_range((AOTModuleInstance*)module_inst, + return aot_get_app_addr_range((AOTModuleInstance *)module_inst, app_offset, p_app_start_offset, p_app_end_offset); #endif @@ -1744,13 +1744,13 @@ wasm_runtime_get_native_addr_range(WASMModuleInstanceCommon *module_inst, { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - return wasm_get_native_addr_range((WASMModuleInstance*)module_inst, + return wasm_get_native_addr_range((WASMModuleInstance *)module_inst, native_ptr, p_native_start_addr, p_native_end_addr); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - return aot_get_native_addr_range((AOTModuleInstance*)module_inst, + return aot_get_native_addr_range((AOTModuleInstance *)module_inst, native_ptr, p_native_start_addr, p_native_end_addr); #endif @@ -1762,11 +1762,11 @@ wasm_runtime_get_temp_ret(WASMModuleInstanceCommon *module_inst) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - return ((WASMModuleInstance*)module_inst)->temp_ret; + return ((WASMModuleInstance *)module_inst)->temp_ret; #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - return ((AOTModuleInstance*)module_inst)->temp_ret; + return ((AOTModuleInstance *)module_inst)->temp_ret; #endif return 0; } @@ -1777,14 +1777,14 @@ wasm_runtime_set_temp_ret(WASMModuleInstanceCommon *module_inst, { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { - ((WASMModuleInstance*)module_inst)->temp_ret = temp_ret; + ((WASMModuleInstance *)module_inst)->temp_ret = temp_ret; return; } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { - ((AOTModuleInstance*)module_inst)->temp_ret = temp_ret; - return; + ((AOTModuleInstance *)module_inst)->temp_ret = temp_ret; + return; } #endif } @@ -1794,11 +1794,11 @@ wasm_runtime_get_llvm_stack(WASMModuleInstanceCommon *module_inst) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - return ((WASMModuleInstance*)module_inst)->llvm_stack; + return ((WASMModuleInstance *)module_inst)->llvm_stack; #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - return ((AOTModuleInstance*)module_inst)->llvm_stack; + return ((AOTModuleInstance *)module_inst)->llvm_stack; #endif return 0; } @@ -1809,14 +1809,14 @@ wasm_runtime_set_llvm_stack(WASMModuleInstanceCommon *module_inst, { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { - ((WASMModuleInstance*)module_inst)->llvm_stack = llvm_stack; + ((WASMModuleInstance *)module_inst)->llvm_stack = llvm_stack; return; } #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { - ((AOTModuleInstance*)module_inst)->llvm_stack = llvm_stack; - return; + ((AOTModuleInstance *)module_inst)->llvm_stack = llvm_stack; + return; } #endif } @@ -1827,13 +1827,12 @@ wasm_runtime_enlarge_memory(WASMModuleInstanceCommon *module, { #if WASM_ENABLE_INTERP != 0 if (module->module_type == Wasm_Module_Bytecode) - return wasm_enlarge_memory((WASMModuleInstance*)module, + return wasm_enlarge_memory((WASMModuleInstance *)module, inc_page_count); #endif #if WASM_ENABLE_AOT != 0 if (module->module_type == Wasm_Module_AoT) - return aot_enlarge_memory((AOTModuleInstance*)module, - inc_page_count); + return aot_enlarge_memory((AOTModuleInstance *)module, inc_page_count); #endif return false; } @@ -1841,22 +1840,21 @@ wasm_runtime_enlarge_memory(WASMModuleInstanceCommon *module, #if WASM_ENABLE_LIBC_WASI != 0 void -wasm_runtime_set_wasi_args_ex(WASMModuleCommon *module, - const char *dir_list[], uint32 dir_count, - const char *map_dir_list[], uint32 map_dir_count, - const char *env_list[], uint32 env_count, - char *argv[], int argc, - int stdinfd, int stdoutfd, int stderrfd) +wasm_runtime_set_wasi_args_ex(WASMModuleCommon *module, const char *dir_list[], + uint32 dir_count, const char *map_dir_list[], + uint32 map_dir_count, const char *env_list[], + uint32 env_count, char *argv[], int argc, + int stdinfd, int stdoutfd, int stderrfd) { WASIArguments *wasi_args = NULL; #if WASM_ENABLE_INTERP != 0 || WASM_ENABLE_JIT != 0 if (module->module_type == Wasm_Module_Bytecode) - wasi_args = &((WASMModule*)module)->wasi_args; + wasi_args = &((WASMModule *)module)->wasi_args; #endif #if WASM_ENABLE_AOT != 0 if (module->module_type == Wasm_Module_AoT) - wasi_args = &((AOTModule*)module)->wasi_args; + wasi_args = &((AOTModule *)module)->wasi_args; #endif if (wasi_args) { @@ -1875,18 +1873,14 @@ wasm_runtime_set_wasi_args_ex(WASMModuleCommon *module, } void -wasm_runtime_set_wasi_args(WASMModuleCommon *module, - const char *dir_list[], uint32 dir_count, - const char *map_dir_list[], uint32 map_dir_count, - const char *env_list[], uint32 env_count, - char *argv[], int argc) +wasm_runtime_set_wasi_args(WASMModuleCommon *module, const char *dir_list[], + uint32 dir_count, const char *map_dir_list[], + uint32 map_dir_count, const char *env_list[], + uint32 env_count, char *argv[], int argc) { - wasm_runtime_set_wasi_args_ex(module, - dir_list, dir_count, - map_dir_list, map_dir_count, - env_list, env_count, - argv, argc, - -1, -1, -1); + wasm_runtime_set_wasi_args_ex(module, dir_list, dir_count, map_dir_list, + map_dir_count, env_list, env_count, argv, + argc, -1, -1, -1); } #if WASM_ENABLE_UVWASI == 0 @@ -1894,9 +1888,8 @@ bool wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst, const char *dir_list[], uint32 dir_count, const char *map_dir_list[], uint32 map_dir_count, - const char *env[], uint32 env_count, - char *argv[], uint32 argc, - int stdinfd, int stdoutfd, int stderrfd, + const char *env[], uint32 env_count, char *argv[], + uint32 argc, int stdinfd, int stdoutfd, int stderrfd, char *error_buf, uint32 error_buf_size) { WASIContext *wasi_ctx; @@ -1916,8 +1909,8 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst, char *path, resolved_path[PATH_MAX]; uint32 i; - if (!(wasi_ctx = runtime_malloc(sizeof(WASIContext), NULL, - error_buf, error_buf_size))) { + if (!(wasi_ctx = runtime_malloc(sizeof(WASIContext), NULL, error_buf, + error_buf_size))) { return false; } @@ -1925,13 +1918,14 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst, #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode - && !((WASMModuleInstance*)module_inst)->default_memory) + && !((WASMModuleInstance *)module_inst)->default_memory) return true; #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT - && !((AOTModuleInstance*)module_inst)-> - global_table_data.memory_instances[0].memory_data.ptr) + && !((AOTModuleInstance *)module_inst) + ->global_table_data.memory_instances[0] + .memory_data.ptr) return true; #endif @@ -1941,11 +1935,11 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst, total_size = sizeof(char *) * (uint64)argc; if (total_size >= UINT32_MAX - || (total_size > 0 && - !(argv_list = wasm_runtime_malloc((uint32)total_size))) + || (total_size > 0 + && !(argv_list = wasm_runtime_malloc((uint32)total_size))) || argv_buf_size >= UINT32_MAX - || (argv_buf_size > 0 && - !(argv_buf = wasm_runtime_malloc((uint32)argv_buf_size)))) { + || (argv_buf_size > 0 + && !(argv_buf = wasm_runtime_malloc((uint32)argv_buf_size)))) { set_error_buf(error_buf, error_buf_size, "Init wasi environment failed: allocate memory failed"); goto fail; @@ -1983,7 +1977,7 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst, if (!(curfds = wasm_runtime_malloc(sizeof(struct fd_table))) || !(prestats = wasm_runtime_malloc(sizeof(struct fd_prestats))) || !(argv_environ = - wasm_runtime_malloc(sizeof(struct argv_environ_values)))) { + wasm_runtime_malloc(sizeof(struct argv_environ_values)))) { set_error_buf(error_buf, error_buf_size, "Init wasi environment failed: allocate memory failed"); goto fail; @@ -2005,11 +1999,8 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst, } fd_prestats_inited = true; - if (!argv_environ_init(argv_environ, - argv_buf, argv_buf_size, - argv_list, argc, - env_buf, env_buf_size, - env_list, env_count)) { + if (!argv_environ_init(argv_environ, argv_buf, argv_buf_size, argv_list, + argc, env_buf, env_buf_size, env_list, env_count)) { set_error_buf(error_buf, error_buf_size, "Init wasi environment failed: " "init argument environment failed"); @@ -2020,7 +2011,8 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst, /* Prepopulate curfds with stdin, stdout, and stderr file descriptors. */ if (!fd_table_insert_existing(curfds, 0, (stdinfd != -1) ? stdinfd : 0) || !fd_table_insert_existing(curfds, 1, (stdoutfd != -1) ? stdoutfd : 1) - || !fd_table_insert_existing(curfds, 2, (stderrfd != -1) ? stderrfd : 2)) { + || !fd_table_insert_existing(curfds, 2, + (stderrfd != -1) ? stderrfd : 2)) { set_error_buf(error_buf, error_buf_size, "Init wasi environment failed: init fd table failed"); goto fail; @@ -2083,7 +2075,7 @@ fail: wasm_runtime_free(env_list); return false; } -#else /* else of WASM_ENABLE_UVWASI == 0 */ +#else /* else of WASM_ENABLE_UVWASI == 0 */ static void * wasm_uvwasi_malloc(size_t size, void *mem_user_data) { @@ -2100,8 +2092,7 @@ wasm_uvwasi_free(void *ptr, void *mem_user_data) } static void * -wasm_uvwasi_calloc(size_t nmemb, size_t size, - void *mem_user_data) +wasm_uvwasi_calloc(size_t nmemb, size_t size, void *mem_user_data) { uint64 total_size = (uint64)nmemb * size; return runtime_malloc(total_size, NULL, NULL, 0); @@ -2109,8 +2100,7 @@ wasm_uvwasi_calloc(size_t nmemb, size_t size, } static void * -wasm_uvwasi_realloc(void *ptr, size_t size, - void *mem_user_data) +wasm_uvwasi_realloc(void *ptr, size_t size, void *mem_user_data) { if (size >= UINT32_MAX) { return NULL; @@ -2118,6 +2108,7 @@ wasm_uvwasi_realloc(void *ptr, size_t size, return wasm_runtime_realloc(ptr, (uint32)size); } +/* clang-format off */ static uvwasi_mem_t uvwasi_allocator = { .mem_user_data = 0, .malloc = wasm_uvwasi_malloc, @@ -2125,14 +2116,14 @@ static uvwasi_mem_t uvwasi_allocator = { .calloc = wasm_uvwasi_calloc, .realloc = wasm_uvwasi_realloc }; +/* clang-format on */ bool wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst, const char *dir_list[], uint32 dir_count, const char *map_dir_list[], uint32 map_dir_count, - const char *env[], uint32 env_count, - char *argv[], uint32 argc, - int stdinfd, int stdoutfd, int stderrfd, + const char *env[], uint32 env_count, char *argv[], + uint32 argc, int stdinfd, int stdoutfd, int stderrfd, char *error_buf, uint32 error_buf_size) { uvwasi_t *uvwasi = NULL; @@ -2142,8 +2133,8 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst, uint32 i; bool ret = false; - uvwasi = runtime_malloc(sizeof(uvwasi_t), module_inst, - error_buf, error_buf_size); + uvwasi = runtime_malloc(sizeof(uvwasi_t), module_inst, error_buf, + error_buf_size); if (!uvwasi) return false; @@ -2153,30 +2144,31 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst, init_options.argc = argc; init_options.argv = (const char **)argv; init_options.in = (stdinfd != -1) ? (uvwasi_fd_t)stdinfd : init_options.in; - init_options.out = (stdoutfd != -1) ? (uvwasi_fd_t)stdoutfd : init_options.out; - init_options.err = (stderrfd != -1) ? (uvwasi_fd_t)stderrfd : init_options.err; + init_options.out = + (stdoutfd != -1) ? (uvwasi_fd_t)stdoutfd : init_options.out; + init_options.err = + (stderrfd != -1) ? (uvwasi_fd_t)stderrfd : init_options.err; if (dir_count > 0) { init_options.preopenc = dir_count; total_size = sizeof(uvwasi_preopen_t) * (uint64)init_options.preopenc; - init_options.preopens = - (uvwasi_preopen_t *)runtime_malloc(total_size, module_inst, - error_buf, error_buf_size); + init_options.preopens = (uvwasi_preopen_t *)runtime_malloc( + total_size, module_inst, error_buf, error_buf_size); if (init_options.preopens == NULL) goto fail; for (i = 0; i < init_options.preopenc; i++) { init_options.preopens[i].real_path = dir_list[i]; init_options.preopens[i].mapped_path = - (i < map_dir_count) ? map_dir_list[i] : dir_list[i]; + (i < map_dir_count) ? map_dir_list[i] : dir_list[i]; } } if (env_count > 0) { total_size = sizeof(char *) * (uint64)(env_count + 1); - envp = runtime_malloc(total_size, module_inst, - error_buf, error_buf_size); + envp = + runtime_malloc(total_size, module_inst, error_buf, error_buf_size); if (envp == NULL) goto fail; @@ -2198,7 +2190,7 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst, fail: if (envp) - wasm_runtime_free((void*)envp); + wasm_runtime_free((void *)envp); if (init_options.preopens) wasm_runtime_free(init_options.preopens); @@ -2215,13 +2207,13 @@ wasm_runtime_is_wasi_mode(WASMModuleInstanceCommon *module_inst) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode - && ((WASMModuleInstance*)module_inst)->module->is_wasi_module) + && ((WASMModuleInstance *)module_inst)->module->is_wasi_module) return true; #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT - && ((AOTModule*)((AOTModuleInstance*)module_inst)->aot_module.ptr) - ->is_wasi_module) + && ((AOTModule *)((AOTModuleInstance *)module_inst)->aot_module.ptr) + ->is_wasi_module) return true; #endif return false; @@ -2234,7 +2226,7 @@ wasm_runtime_lookup_wasi_start_function(WASMModuleInstanceCommon *module_inst) #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { - WASMModuleInstance *wasm_inst = (WASMModuleInstance*)module_inst; + WASMModuleInstance *wasm_inst = (WASMModuleInstance *)module_inst; WASMFunctionInstance *func; for (i = 0; i < wasm_inst->export_func_count; i++) { if (!strcmp(wasm_inst->export_functions[i].name, "_start")) { @@ -2245,7 +2237,7 @@ wasm_runtime_lookup_wasi_start_function(WASMModuleInstanceCommon *module_inst) "invalid function type.\n"); return NULL; } - return (WASMFunctionInstanceCommon*)func; + return (WASMFunctionInstanceCommon *)func; } } return NULL; @@ -2254,9 +2246,9 @@ wasm_runtime_lookup_wasi_start_function(WASMModuleInstanceCommon *module_inst) #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) { - AOTModuleInstance *aot_inst = (AOTModuleInstance*)module_inst; - AOTFunctionInstance *export_funcs = (AOTFunctionInstance *) - aot_inst->export_funcs.ptr; + AOTModuleInstance *aot_inst = (AOTModuleInstance *)module_inst; + AOTFunctionInstance *export_funcs = + (AOTFunctionInstance *)aot_inst->export_funcs.ptr; for (i = 0; i < aot_inst->export_func_count; i++) { if (!strcmp(export_funcs[i].func_name, "_start")) { AOTFuncType *func_type = export_funcs[i].u.func.func_type; @@ -2266,7 +2258,7 @@ wasm_runtime_lookup_wasi_start_function(WASMModuleInstanceCommon *module_inst) "invalid function type.\n"); return NULL; } - return (WASMFunctionInstanceCommon*)&export_funcs[i]; + return (WASMFunctionInstanceCommon *)&export_funcs[i]; } } return NULL; @@ -2324,11 +2316,11 @@ wasm_runtime_get_wasi_ctx(WASMModuleInstanceCommon *module_inst) { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - return ((WASMModuleInstance*)module_inst)->wasi_ctx; + return ((WASMModuleInstance *)module_inst)->wasi_ctx; #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - return ((AOTModuleInstance*)module_inst)->wasi_ctx.ptr; + return ((AOTModuleInstance *)module_inst)->wasi_ctx.ptr; #endif return NULL; } @@ -2339,29 +2331,28 @@ wasm_runtime_set_wasi_ctx(WASMModuleInstanceCommon *module_inst, { #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - ((WASMModuleInstance*)module_inst)->wasi_ctx = wasi_ctx; + ((WASMModuleInstance *)module_inst)->wasi_ctx = wasi_ctx; #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - ((AOTModuleInstance*)module_inst)->wasi_ctx.ptr = wasi_ctx; + ((AOTModuleInstance *)module_inst)->wasi_ctx.ptr = wasi_ctx; #endif } #endif /* end of WASM_ENABLE_LIBC_WASI */ -WASMModuleCommon* +WASMModuleCommon * wasm_exec_env_get_module(WASMExecEnv *exec_env) { WASMModuleInstanceCommon *module_inst = wasm_runtime_get_module_inst(exec_env); #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - return (WASMModuleCommon*) - ((WASMModuleInstance*)module_inst)->module; + return (WASMModuleCommon *)((WASMModuleInstance *)module_inst)->module; #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - return (WASMModuleCommon*) - ((AOTModuleInstance*)module_inst)->aot_module.ptr; + return (WASMModuleCommon *)((AOTModuleInstance *)module_inst) + ->aot_module.ptr; #endif return NULL; } @@ -2378,8 +2369,8 @@ wasm_runtime_register_natives(const char *module_name, NativeSymbol *native_symbols, uint32 n_native_symbols) { - return wasm_native_register_natives(module_name, - native_symbols, n_native_symbols); + return wasm_native_register_natives(module_name, native_symbols, + n_native_symbols); } bool @@ -2387,18 +2378,18 @@ wasm_runtime_register_natives_raw(const char *module_name, NativeSymbol *native_symbols, uint32 n_native_symbols) { - return wasm_native_register_natives_raw(module_name, - native_symbols, n_native_symbols); + return wasm_native_register_natives_raw(module_name, native_symbols, + n_native_symbols); } bool wasm_runtime_invoke_native_raw(WASMExecEnv *exec_env, void *func_ptr, const WASMType *func_type, const char *signature, - void *attachment, - uint32 *argv, uint32 argc, uint32 *argv_ret) + void *attachment, uint32 *argv, uint32 argc, + uint32 *argv_ret) { WASMModuleInstanceCommon *module = wasm_runtime_get_module_inst(exec_env); - typedef void (*NativeRawFuncPtr)(WASMExecEnv*, uint64*); + typedef void (*NativeRawFuncPtr)(WASMExecEnv *, uint64 *); NativeRawFuncPtr invokeNativeRaw = (NativeRawFuncPtr)func_ptr; uint64 argv_buf[16] = { 0 }, *argv1 = argv_buf, *argv_dst, size; uint32 *argv_src = argv, i, argc1, ptr_len; @@ -2408,8 +2399,8 @@ wasm_runtime_invoke_native_raw(WASMExecEnv *exec_env, void *func_ptr, argc1 = func_type->param_count; if (argc1 > sizeof(argv_buf) / sizeof(uint64)) { size = sizeof(uint64) * (uint64)argc1; - if (!(argv1 = runtime_malloc((uint32)size, exec_env->module_inst, - NULL, 0))) { + if (!(argv1 = runtime_malloc((uint32)size, exec_env->module_inst, NULL, + 0))) { return false; } } @@ -2421,7 +2412,7 @@ wasm_runtime_invoke_native_raw(WASMExecEnv *exec_env, void *func_ptr, switch (func_type->types[i]) { case VALUE_TYPE_I32: { - *(uint32*)argv_dst = arg_i32 = *argv_src++; + *(uint32 *)argv_dst = arg_i32 = *argv_src++; if (signature) { if (signature[i + 1] == '*') { /* param is a pointer */ @@ -2432,35 +2423,40 @@ wasm_runtime_invoke_native_raw(WASMExecEnv *exec_env, void *func_ptr, /* pointer without length followed */ ptr_len = 1; - if (!wasm_runtime_validate_app_addr(module, arg_i32, ptr_len)) + if (!wasm_runtime_validate_app_addr(module, arg_i32, + ptr_len)) goto fail; - *(uintptr_t*)argv_dst = (uintptr_t) - wasm_runtime_addr_app_to_native(module, arg_i32); + *(uintptr_t *)argv_dst = + (uintptr_t)wasm_runtime_addr_app_to_native(module, + arg_i32); } else if (signature[i + 1] == '$') { /* param is a string */ - if (!wasm_runtime_validate_app_str_addr(module, arg_i32)) + if (!wasm_runtime_validate_app_str_addr(module, + arg_i32)) goto fail; - *(uintptr_t*)argv_dst = (uintptr_t) - wasm_runtime_addr_app_to_native(module, arg_i32); + *(uintptr_t *)argv_dst = + (uintptr_t)wasm_runtime_addr_app_to_native(module, + arg_i32); } } break; } case VALUE_TYPE_I64: case VALUE_TYPE_F64: - bh_memcpy_s(argv_dst, sizeof(uint64), argv_src, sizeof(uint32) * 2); + bh_memcpy_s(argv_dst, sizeof(uint64), argv_src, + sizeof(uint32) * 2); argv_src += 2; break; case VALUE_TYPE_F32: - *(float32*)argv_dst = *(float32*)argv_src++; + *(float32 *)argv_dst = *(float32 *)argv_src++; break; #if WASM_ENABLE_REF_TYPES != 0 case VALUE_TYPE_FUNCREF: case VALUE_TYPE_EXTERNREF: - *(uint32*)argv_dst = *argv_src++; + *(uint32 *)argv_dst = *argv_src++; break; #endif default: @@ -2480,14 +2476,15 @@ wasm_runtime_invoke_native_raw(WASMExecEnv *exec_env, void *func_ptr, case VALUE_TYPE_FUNCREF: case VALUE_TYPE_EXTERNREF: #endif - argv_ret[0] = *(uint32*)argv1; + argv_ret[0] = *(uint32 *)argv1; break; case VALUE_TYPE_F32: - *(float32*)argv_ret = *(float32*)argv1; + *(float32 *)argv_ret = *(float32 *)argv1; break; case VALUE_TYPE_I64: case VALUE_TYPE_F64: - bh_memcpy_s(argv_ret, sizeof(uint32) * 2, argv1, sizeof(uint64)); + bh_memcpy_s(argv_ret, sizeof(uint32) * 2, argv1, + sizeof(uint64)); break; default: bh_assert(0); @@ -2500,7 +2497,7 @@ wasm_runtime_invoke_native_raw(WASMExecEnv *exec_env, void *func_ptr, fail: if (argv1 != argv_buf) wasm_runtime_free(argv1); - return ret; + return ret; } /** @@ -2508,39 +2505,40 @@ fail: */ /* The invoke native implementation on ARM platform with VFP co-processor */ -#if defined(BUILD_TARGET_ARM_VFP) \ - || defined(BUILD_TARGET_THUMB_VFP) \ - || defined(BUILD_TARGET_RISCV32_ILP32D) \ - || defined(BUILD_TARGET_RISCV32_ILP32) \ - || defined(BUILD_TARGET_ARC) +#if defined(BUILD_TARGET_ARM_VFP) || defined(BUILD_TARGET_THUMB_VFP) \ + || defined(BUILD_TARGET_RISCV32_ILP32D) \ + || defined(BUILD_TARGET_RISCV32_ILP32) || defined(BUILD_TARGET_ARC) typedef void (*GenericFunctionPointer)(); -int64 invokeNative(GenericFunctionPointer f, uint32 *args, uint32 n_stacks); +int64 +invokeNative(GenericFunctionPointer f, uint32 *args, uint32 n_stacks); -typedef float64 (*Float64FuncPtr)(GenericFunctionPointer, uint32*, uint32); -typedef float32 (*Float32FuncPtr)(GenericFunctionPointer, uint32*, uint32); -typedef int64 (*Int64FuncPtr)(GenericFunctionPointer, uint32*,uint32); -typedef int32 (*Int32FuncPtr)(GenericFunctionPointer, uint32*, uint32); -typedef void (*VoidFuncPtr)(GenericFunctionPointer, uint32*, uint32); +typedef float64 (*Float64FuncPtr)(GenericFunctionPointer, uint32 *, uint32); +typedef float32 (*Float32FuncPtr)(GenericFunctionPointer, uint32 *, uint32); +typedef int64 (*Int64FuncPtr)(GenericFunctionPointer, uint32 *, uint32); +typedef int32 (*Int32FuncPtr)(GenericFunctionPointer, uint32 *, uint32); +typedef void (*VoidFuncPtr)(GenericFunctionPointer, uint32 *, uint32); -static Float64FuncPtr invokeNative_Float64 = (Float64FuncPtr)(uintptr_t)invokeNative; -static Float32FuncPtr invokeNative_Float32 = (Float32FuncPtr)(uintptr_t)invokeNative; +static Float64FuncPtr invokeNative_Float64 = + (Float64FuncPtr)(uintptr_t)invokeNative; +static Float32FuncPtr invokeNative_Float32 = + (Float32FuncPtr)(uintptr_t)invokeNative; static Int64FuncPtr invokeNative_Int64 = (Int64FuncPtr)(uintptr_t)invokeNative; static Int32FuncPtr invokeNative_Int32 = (Int32FuncPtr)(uintptr_t)invokeNative; static VoidFuncPtr invokeNative_Void = (VoidFuncPtr)(uintptr_t)invokeNative; #if defined(BUILD_TARGET_ARM_VFP) || defined(BUILD_TARGET_THUMB_VFP) -#define MAX_REG_INTS 4 +#define MAX_REG_INTS 4 #define MAX_REG_FLOATS 16 #else -#define MAX_REG_INTS 8 +#define MAX_REG_INTS 8 #define MAX_REG_FLOATS 8 #endif bool wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, const WASMType *func_type, const char *signature, - void *attachment, - uint32 *argv, uint32 argc, uint32 *argv_ret) + void *attachment, uint32 *argv, uint32 argc, + uint32 *argv_ret) { WASMModuleInstanceCommon *module = wasm_runtime_get_module_inst(exec_env); /* argv buf layout: int args(fix cnt) + float args(fix cnt) + stack args */ @@ -2582,8 +2580,8 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, #endif n_ints += 2; } -#if defined(BUILD_TARGET_RISCV32_ILP32) || defined(BUILD_TARGET_RISCV32_ILP32D) \ - || defined(BUILD_TARGET_ARC) +#if defined(BUILD_TARGET_RISCV32_ILP32) \ + || defined(BUILD_TARGET_RISCV32_ILP32D) || defined(BUILD_TARGET_ARC) /* part in register, part in stack */ else if (n_ints == MAX_REG_INTS - 1) { n_ints++; @@ -2632,7 +2630,7 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, n_stacks += 2; } break; -#else /* BUILD_TARGET_RISCV32_ILP32D */ +#else /* BUILD_TARGET_RISCV32_ILP32D */ case VALUE_TYPE_F32: case VALUE_TYPE_F64: if (n_fps < MAX_REG_FLOATS) { @@ -2651,7 +2649,8 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, ints += 2; } else { - /* 64-bit data in stack must be 8 bytes aligned in riscv32 */ + /* 64-bit data in stack must be 8 bytes aligned in riscv32 + */ if (n_stacks & 1) n_stacks++; n_stacks += 2; @@ -2681,8 +2680,8 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, if (argc1 > sizeof(argv_buf) / sizeof(uint32)) { size = sizeof(uint32) * (uint32)argc1; - if (!(argv1 = runtime_malloc((uint32)size, exec_env->module_inst, - NULL, 0))) { + if (!(argv1 = runtime_malloc((uint32)size, exec_env->module_inst, NULL, + 0))) { return false; } } @@ -2720,19 +2719,21 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, /* pointer without length followed */ ptr_len = 1; - if (!wasm_runtime_validate_app_addr(module, arg_i32, ptr_len)) + if (!wasm_runtime_validate_app_addr(module, arg_i32, + ptr_len)) goto fail; - arg_i32 = (uintptr_t) - wasm_runtime_addr_app_to_native(module, arg_i32); + arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native( + module, arg_i32); } else if (signature[i + 1] == '$') { /* param is a string */ - if (!wasm_runtime_validate_app_str_addr(module, arg_i32)) + if (!wasm_runtime_validate_app_str_addr(module, + arg_i32)) goto fail; - arg_i32 = (uintptr_t) - wasm_runtime_addr_app_to_native(module, arg_i32); + arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native( + module, arg_i32); } } @@ -2764,8 +2765,8 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, ints[n_ints++] = *argv_src++; ints[n_ints++] = *argv_src++; } -#if defined(BUILD_TARGET_RISCV32_ILP32) || defined(BUILD_TARGET_RISCV32_ILP32D) \ - || defined(BUILD_TARGET_ARC) +#if defined(BUILD_TARGET_RISCV32_ILP32) \ + || defined(BUILD_TARGET_RISCV32_ILP32D) || defined(BUILD_TARGET_ARC) else if (n_ints == MAX_REG_INTS - 1) { ints[n_ints++] = *argv_src++; stacks[n_stacks++] = *argv_src++; @@ -2787,9 +2788,9 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, case VALUE_TYPE_F32: { if (n_fps < MAX_REG_FLOATS) - *(float32*)&fps[n_fps++] = *(float32*)argv_src++; + *(float32 *)&fps[n_fps++] = *(float32 *)argv_src++; else - *(float32*)&stacks[n_stacks++] = *(float32*)argv_src++; + *(float32 *)&stacks[n_stacks++] = *(float32 *)argv_src++; break; } case VALUE_TYPE_F64: @@ -2821,19 +2822,19 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, } break; } -#else /* BUILD_TARGET_RISCV32_ILP32D */ +#else /* BUILD_TARGET_RISCV32_ILP32D */ case VALUE_TYPE_F32: case VALUE_TYPE_F64: { if (n_fps < MAX_REG_FLOATS) { if (func_type->types[i] == VALUE_TYPE_F32) { - *(float32*)&fps[n_fps * 2] = *(float32*)argv_src++; + *(float32 *)&fps[n_fps * 2] = *(float32 *)argv_src++; /* NaN boxing, the upper bits of a valid NaN-boxed value must be all 1s. */ fps[n_fps * 2 + 1] = 0xFFFFFFFF; } else { - *(float64*)&fps[n_fps * 2] = *(float64*)argv_src; + *(float64 *)&fps[n_fps * 2] = *(float64 *)argv_src; argv_src += 2; } n_fps++; @@ -2841,29 +2842,30 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, else if (func_type->types[i] == VALUE_TYPE_F32 && n_ints < MAX_REG_INTS) { /* use int reg firstly if available */ - *(float32*)&ints[n_ints++] = *(float32*)argv_src++; + *(float32 *)&ints[n_ints++] = *(float32 *)argv_src++; } else if (func_type->types[i] == VALUE_TYPE_F64 && n_ints < MAX_REG_INTS - 1) { /* use int regs firstly if available */ if (n_ints & 1) n_ints++; - *(float64*)&ints[n_ints] = *(float64*)argv_src; + *(float64 *)&ints[n_ints] = *(float64 *)argv_src; n_ints += 2; argv_src += 2; } else { - /* 64-bit data in stack must be 8 bytes aligned in riscv32 */ + /* 64-bit data in stack must be 8 bytes aligned in riscv32 + */ if (n_stacks & 1) n_stacks++; if (func_type->types[i] == VALUE_TYPE_F32) { - *(float32*)&stacks[n_stacks] = *(float32*)argv_src++; + *(float32 *)&stacks[n_stacks] = *(float32 *)argv_src++; /* NaN boxing, the upper bits of a valid NaN-boxed value must be all 1s. */ stacks[n_stacks + 1] = 0xFFFFFFFF; } else { - *(float64*)&stacks[n_stacks] = *(float64*)argv_src; + *(float64 *)&stacks[n_stacks] = *(float64 *)argv_src; argv_src += 2; } n_stacks += 2; @@ -2880,9 +2882,9 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, /* Save extra result values' address to argv1 */ for (i = 0; i < ext_ret_count; i++) { if (n_ints < MAX_REG_INTS) - ints[n_ints++] = *(uint32*)argv_src++; + ints[n_ints++] = *(uint32 *)argv_src++; else - stacks[n_stacks++] = *(uint32*)argv_src++; + stacks[n_stacks++] = *(uint32 *)argv_src++; } exec_env->attachment = attachment; @@ -2896,16 +2898,20 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, case VALUE_TYPE_FUNCREF: case VALUE_TYPE_EXTERNREF: #endif - argv_ret[0] = (uint32)invokeNative_Int32(func_ptr, argv1, n_stacks); + argv_ret[0] = + (uint32)invokeNative_Int32(func_ptr, argv1, n_stacks); break; case VALUE_TYPE_I64: - PUT_I64_TO_ADDR(argv_ret, invokeNative_Int64(func_ptr, argv1, n_stacks)); + PUT_I64_TO_ADDR(argv_ret, + invokeNative_Int64(func_ptr, argv1, n_stacks)); break; case VALUE_TYPE_F32: - *(float32*)argv_ret = invokeNative_Float32(func_ptr, argv1, n_stacks); + *(float32 *)argv_ret = + invokeNative_Float32(func_ptr, argv1, n_stacks); break; case VALUE_TYPE_F64: - PUT_F64_TO_ADDR(argv_ret, invokeNative_Float64(func_ptr, argv1, n_stacks)); + PUT_F64_TO_ADDR( + argv_ret, invokeNative_Float64(func_ptr, argv1, n_stacks)); break; default: bh_assert(0); @@ -2921,25 +2927,24 @@ fail: wasm_runtime_free(argv1); return ret; } -#endif /* end of defined(BUILD_TARGET_ARM_VFP) - || defined(BUILD_TARGET_THUMB_VFP) \ - || defined(BUILD_TARGET_RISCV32_ILP32D) - || defined(BUILD_TARGET_RISCV32_ILP32) +#endif /* end of defined(BUILD_TARGET_ARM_VFP) \ + || defined(BUILD_TARGET_THUMB_VFP) \ + || defined(BUILD_TARGET_RISCV32_ILP32D) \ + || defined(BUILD_TARGET_RISCV32_ILP32) \ || defined(BUILD_TARGET_ARC) */ -#if defined(BUILD_TARGET_X86_32) \ - || defined(BUILD_TARGET_ARM) \ - || defined(BUILD_TARGET_THUMB) \ - || defined(BUILD_TARGET_MIPS) \ +#if defined(BUILD_TARGET_X86_32) || defined(BUILD_TARGET_ARM) \ + || defined(BUILD_TARGET_THUMB) || defined(BUILD_TARGET_MIPS) \ || defined(BUILD_TARGET_XTENSA) typedef void (*GenericFunctionPointer)(); -int64 invokeNative(GenericFunctionPointer f, uint32 *args, uint32 sz); +int64 +invokeNative(GenericFunctionPointer f, uint32 *args, uint32 sz); -typedef float64 (*Float64FuncPtr)(GenericFunctionPointer f, uint32*, uint32); -typedef float32 (*Float32FuncPtr)(GenericFunctionPointer f, uint32*, uint32); -typedef int64 (*Int64FuncPtr)(GenericFunctionPointer f, uint32*, uint32); -typedef int32 (*Int32FuncPtr)(GenericFunctionPointer f, uint32*, uint32); -typedef void (*VoidFuncPtr)(GenericFunctionPointer f, uint32*, uint32); +typedef float64 (*Float64FuncPtr)(GenericFunctionPointer f, uint32 *, uint32); +typedef float32 (*Float32FuncPtr)(GenericFunctionPointer f, uint32 *, uint32); +typedef int64 (*Int64FuncPtr)(GenericFunctionPointer f, uint32 *, uint32); +typedef int32 (*Int32FuncPtr)(GenericFunctionPointer f, uint32 *, uint32); +typedef void (*VoidFuncPtr)(GenericFunctionPointer f, uint32 *, uint32); static Int64FuncPtr invokeNative_Int64 = (Int64FuncPtr)invokeNative; static Int32FuncPtr invokeNative_Int32 = (Int32FuncPtr)invokeNative; @@ -2957,8 +2962,8 @@ word_copy(uint32 *dest, uint32 *src, unsigned num) bool wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, const WASMType *func_type, const char *signature, - void *attachment, - uint32 *argv, uint32 argc, uint32 *argv_ret) + void *attachment, uint32 *argv, uint32 argc, + uint32 *argv_ret) { WASMModuleInstanceCommon *module = wasm_runtime_get_module_inst(exec_env); uint32 argv_buf[32], *argv1 = argv_buf, argc1, i, j = 0; @@ -2978,14 +2983,14 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, if (argc1 > sizeof(argv_buf) / sizeof(uint32)) { size = sizeof(uint32) * (uint64)argc1; - if (!(argv1 = runtime_malloc((uint32)size, exec_env->module_inst, - NULL, 0))) { + if (!(argv1 = runtime_malloc((uint32)size, exec_env->module_inst, NULL, + 0))) { return false; } } - for (i = 0; i < sizeof(WASMExecEnv*) / sizeof(uint32); i++) - argv1[j++] = ((uint32*)&exec_env)[i]; + for (i = 0; i < sizeof(WASMExecEnv *) / sizeof(uint32); i++) + argv1[j++] = ((uint32 *)&exec_env)[i]; for (i = 0; i < func_type->param_count; i++) { switch (func_type->types[i]) { @@ -3003,19 +3008,21 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, /* pointer without length followed */ ptr_len = 1; - if (!wasm_runtime_validate_app_addr(module, arg_i32, ptr_len)) + if (!wasm_runtime_validate_app_addr(module, arg_i32, + ptr_len)) goto fail; - arg_i32 = (uintptr_t) - wasm_runtime_addr_app_to_native(module, arg_i32); + arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native( + module, arg_i32); } else if (signature[i + 1] == '$') { /* param is a string */ - if (!wasm_runtime_validate_app_str_addr(module, arg_i32)) + if (!wasm_runtime_validate_app_str_addr(module, + arg_i32)) goto fail; - arg_i32 = (uintptr_t) - wasm_runtime_addr_app_to_native(module, arg_i32); + arg_i32 = (uintptr_t)wasm_runtime_addr_app_to_native( + module, arg_i32); } } @@ -3061,16 +3068,20 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, case VALUE_TYPE_FUNCREF: case VALUE_TYPE_EXTERNREF: #endif - argv_ret[0] = (uint32)invokeNative_Int32(func_ptr, argv1, argc1); + argv_ret[0] = + (uint32)invokeNative_Int32(func_ptr, argv1, argc1); break; case VALUE_TYPE_I64: - PUT_I64_TO_ADDR(argv_ret, invokeNative_Int64(func_ptr, argv1, argc1)); + PUT_I64_TO_ADDR(argv_ret, + invokeNative_Int64(func_ptr, argv1, argc1)); break; case VALUE_TYPE_F32: - *(float32*)argv_ret = invokeNative_Float32(func_ptr, argv1, argc1); + *(float32 *)argv_ret = + invokeNative_Float32(func_ptr, argv1, argc1); break; case VALUE_TYPE_F64: - PUT_F64_TO_ADDR(argv_ret, invokeNative_Float64(func_ptr, argv1, argc1)); + PUT_F64_TO_ADDR(argv_ret, + invokeNative_Float64(func_ptr, argv1, argc1)); break; default: bh_assert(0); @@ -3087,17 +3098,15 @@ fail: return ret; } -#endif /* end of defined(BUILD_TARGET_X86_32) \ - || defined(BUILD_TARGET_ARM) \ +#endif /* end of defined(BUILD_TARGET_X86_32) \ + || defined(BUILD_TARGET_ARM) \ || defined(BUILD_TARGET_THUMB) \ - || defined(BUILD_TARGET_MIPS) \ + || defined(BUILD_TARGET_MIPS) \ || defined(BUILD_TARGET_XTENSA) */ -#if defined(BUILD_TARGET_X86_64) \ - || defined(BUILD_TARGET_AMD_64) \ - || defined(BUILD_TARGET_AARCH64) \ - || defined(BUILD_TARGET_RISCV64_LP64D) \ - || defined(BUILD_TARGET_RISCV64_LP64) +#if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \ + || defined(BUILD_TARGET_AARCH64) || defined(BUILD_TARGET_RISCV64_LP64D) \ + || defined(BUILD_TARGET_RISCV64_LP64) #if WASM_ENABLE_SIMD != 0 #ifdef v128 @@ -3116,9 +3125,10 @@ typedef union __declspec(intrin_type) __declspec(align(8)) v128 { unsigned __int64 m128i_u64[2]; } v128; #elif defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64) \ - || defined(BUILD_TARGET_RISCV64_LP64D) || defined(BUILD_TARGET_RISCV64_LP64) -typedef long long v128 __attribute__ ((__vector_size__ (16), - __may_alias__, __aligned__ (1))); + || defined(BUILD_TARGET_RISCV64_LP64D) \ + || defined(BUILD_TARGET_RISCV64_LP64) +typedef long long v128 + __attribute__((__vector_size__(16), __may_alias__, __aligned__(1))); #elif defined(BUILD_TARGET_AARCH64) #include typedef uint32x4_t __m128i; @@ -3128,37 +3138,39 @@ typedef uint32x4_t __m128i; #endif /* end of WASM_ENABLE_SIMD != 0 */ typedef void (*GenericFunctionPointer)(); -int64 invokeNative(GenericFunctionPointer f, uint64 *args, uint64 n_stacks); +int64 +invokeNative(GenericFunctionPointer f, uint64 *args, uint64 n_stacks); -typedef float64 (*Float64FuncPtr)(GenericFunctionPointer, uint64*, uint64); -typedef float32 (*Float32FuncPtr)(GenericFunctionPointer, uint64*, uint64); -typedef int64 (*Int64FuncPtr)(GenericFunctionPointer, uint64*, uint64); -typedef int32 (*Int32FuncPtr)(GenericFunctionPointer, uint64*, uint64); -typedef void (*VoidFuncPtr)(GenericFunctionPointer, uint64*, uint64); +typedef float64 (*Float64FuncPtr)(GenericFunctionPointer, uint64 *, uint64); +typedef float32 (*Float32FuncPtr)(GenericFunctionPointer, uint64 *, uint64); +typedef int64 (*Int64FuncPtr)(GenericFunctionPointer, uint64 *, uint64); +typedef int32 (*Int32FuncPtr)(GenericFunctionPointer, uint64 *, uint64); +typedef void (*VoidFuncPtr)(GenericFunctionPointer, uint64 *, uint64); -static Float64FuncPtr invokeNative_Float64 = (Float64FuncPtr)(uintptr_t)invokeNative; -static Float32FuncPtr invokeNative_Float32 = (Float32FuncPtr)(uintptr_t)invokeNative; +static Float64FuncPtr invokeNative_Float64 = + (Float64FuncPtr)(uintptr_t)invokeNative; +static Float32FuncPtr invokeNative_Float32 = + (Float32FuncPtr)(uintptr_t)invokeNative; static Int64FuncPtr invokeNative_Int64 = (Int64FuncPtr)(uintptr_t)invokeNative; static Int32FuncPtr invokeNative_Int32 = (Int32FuncPtr)(uintptr_t)invokeNative; static VoidFuncPtr invokeNative_Void = (VoidFuncPtr)(uintptr_t)invokeNative; #if WASM_ENABLE_SIMD != 0 -typedef v128 (*V128FuncPtr)(GenericFunctionPointer, uint64*, uint64); +typedef v128 (*V128FuncPtr)(GenericFunctionPointer, uint64 *, uint64); static V128FuncPtr invokeNative_V128 = (V128FuncPtr)(uintptr_t)invokeNative; #endif #if defined(_WIN32) || defined(_WIN32_) -#define MAX_REG_FLOATS 4 -#define MAX_REG_INTS 4 +#define MAX_REG_FLOATS 4 +#define MAX_REG_INTS 4 #else /* else of defined(_WIN32) || defined(_WIN32_) */ -#define MAX_REG_FLOATS 8 -#if defined(BUILD_TARGET_AARCH64) \ - || defined(BUILD_TARGET_RISCV64_LP64D) \ +#define MAX_REG_FLOATS 8 +#if defined(BUILD_TARGET_AARCH64) || defined(BUILD_TARGET_RISCV64_LP64D) \ || defined(BUILD_TARGET_RISCV64_LP64) -#define MAX_REG_INTS 8 +#define MAX_REG_INTS 8 #else -#define MAX_REG_INTS 6 -#endif /* end of defined(BUILD_TARGET_AARCH64) \ +#define MAX_REG_INTS 6 +#endif /* end of defined(BUILD_TARGET_AARCH64) \ || defined(BUILD_TARGET_RISCV64_LP64D) \ || defined(BUILD_TARGET_RISCV64_LP64) */ #endif /* end of defined(_WIN32) || defined(_WIN32_) */ @@ -3166,8 +3178,8 @@ static V128FuncPtr invokeNative_V128 = (V128FuncPtr)(uintptr_t)invokeNative; bool wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, const WASMType *func_type, const char *signature, - void *attachment, - uint32 *argv, uint32 argc, uint32 *argv_ret) + void *attachment, uint32 *argv, uint32 argc, + uint32 *argv_ret) { WASMModuleInstanceCommon *module = wasm_runtime_get_module_inst(exec_env); uint64 argv_buf[32], *argv1 = argv_buf, *ints, *stacks, size, arg_i64; @@ -3194,16 +3206,15 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, #endif #if WASM_ENABLE_SIMD == 0 - argc1 = 1 + MAX_REG_FLOATS + (uint32)func_type->param_count - + ext_ret_count; + argc1 = 1 + MAX_REG_FLOATS + (uint32)func_type->param_count + ext_ret_count; #else argc1 = 1 + MAX_REG_FLOATS * 2 + (uint32)func_type->param_count * 2 - + ext_ret_count; + + ext_ret_count; #endif if (argc1 > sizeof(argv_buf) / sizeof(uint64)) { size = sizeof(uint64) * (uint64)argc1; - if (!(argv1 = runtime_malloc((uint32)size, exec_env->module_inst, - NULL, 0))) { + if (!(argv1 = runtime_malloc((uint32)size, exec_env->module_inst, NULL, + 0))) { return false; } } @@ -3216,7 +3227,7 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, fps = (v128 *)argv1; ints = (uint64 *)(fps + MAX_REG_FLOATS); #endif -#else /* else of BUILD_TARGET_RISCV64_LP64 */ +#else /* else of BUILD_TARGET_RISCV64_LP64 */ ints = argv1; #endif /* end of BUILD_TARGET_RISCV64_LP64 */ stacks = ints + MAX_REG_INTS; @@ -3239,19 +3250,21 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, /* pointer without length followed */ ptr_len = 1; - if (!wasm_runtime_validate_app_addr(module, arg_i32, ptr_len)) + if (!wasm_runtime_validate_app_addr(module, arg_i32, + ptr_len)) goto fail; - arg_i64 = (uintptr_t) - wasm_runtime_addr_app_to_native(module, arg_i32); + arg_i64 = (uintptr_t)wasm_runtime_addr_app_to_native( + module, arg_i32); } else if (signature[i + 1] == '$') { /* param is a string */ - if (!wasm_runtime_validate_app_str_addr(module, arg_i32)) + if (!wasm_runtime_validate_app_str_addr(module, + arg_i32)) goto fail; - arg_i64 = (uintptr_t) - wasm_runtime_addr_app_to_native(module, arg_i32); + arg_i64 = (uintptr_t)wasm_runtime_addr_app_to_native( + module, arg_i32); } } if (n_ints < MAX_REG_INTS) @@ -3262,25 +3275,25 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, } case VALUE_TYPE_I64: if (n_ints < MAX_REG_INTS) - ints[n_ints++] = *(uint64*)argv_src; + ints[n_ints++] = *(uint64 *)argv_src; else - stacks[n_stacks++] = *(uint64*)argv_src; + stacks[n_stacks++] = *(uint64 *)argv_src; argv_src += 2; break; case VALUE_TYPE_F32: if (n_fps < MAX_REG_FLOATS) { - *(float32*)&fps[n_fps++] = *(float32*)argv_src++; + *(float32 *)&fps[n_fps++] = *(float32 *)argv_src++; } else { - *(float32*)&stacks[n_stacks++] = *(float32*)argv_src++; + *(float32 *)&stacks[n_stacks++] = *(float32 *)argv_src++; } break; case VALUE_TYPE_F64: if (n_fps < MAX_REG_FLOATS) { - *(float64*)&fps[n_fps++] = *(float64*)argv_src; + *(float64 *)&fps[n_fps++] = *(float64 *)argv_src; } else { - *(float64*)&stacks[n_stacks++] = *(float64*)argv_src; + *(float64 *)&stacks[n_stacks++] = *(float64 *)argv_src; } argv_src += 2; break; @@ -3296,10 +3309,10 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, #if WASM_ENABLE_SIMD != 0 case VALUE_TYPE_V128: if (n_fps < MAX_REG_FLOATS) { - *(v128*)&fps[n_fps++] = *(v128*)argv_src; + *(v128 *)&fps[n_fps++] = *(v128 *)argv_src; } else { - *(v128*)&stacks[n_stacks++] = *(v128*)argv_src; + *(v128 *)&stacks[n_stacks++] = *(v128 *)argv_src; n_stacks++; } argv_src += 4; @@ -3314,9 +3327,9 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, /* Save extra result values' address to argv1 */ for (i = 0; i < ext_ret_count; i++) { if (n_ints < MAX_REG_INTS) - ints[n_ints++] = *(uint64*)argv_src; + ints[n_ints++] = *(uint64 *)argv_src; else - stacks[n_stacks++] = *(uint64*)argv_src; + stacks[n_stacks++] = *(uint64 *)argv_src; argv_src += 2; } @@ -3332,20 +3345,25 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, case VALUE_TYPE_FUNCREF: case VALUE_TYPE_EXTERNREF: #endif - argv_ret[0] = (uint32)invokeNative_Int32(func_ptr, argv1, n_stacks); + argv_ret[0] = + (uint32)invokeNative_Int32(func_ptr, argv1, n_stacks); break; case VALUE_TYPE_I64: - PUT_I64_TO_ADDR(argv_ret, invokeNative_Int64(func_ptr, argv1, n_stacks)); + PUT_I64_TO_ADDR(argv_ret, + invokeNative_Int64(func_ptr, argv1, n_stacks)); break; case VALUE_TYPE_F32: - *(float32*)argv_ret = invokeNative_Float32(func_ptr, argv1, n_stacks); + *(float32 *)argv_ret = + invokeNative_Float32(func_ptr, argv1, n_stacks); break; case VALUE_TYPE_F64: - PUT_F64_TO_ADDR(argv_ret, invokeNative_Float64(func_ptr, argv1, n_stacks)); + PUT_F64_TO_ADDR( + argv_ret, invokeNative_Float64(func_ptr, argv1, n_stacks)); break; #if WASM_ENABLE_SIMD != 0 case VALUE_TYPE_V128: - *(v128*)argv_ret = invokeNative_V128(func_ptr, argv1, n_stacks); + *(v128 *)argv_ret = + invokeNative_V128(func_ptr, argv1, n_stacks); break; #endif default: @@ -3363,15 +3381,14 @@ fail: return ret; } -#endif /* end of defined(BUILD_TARGET_X86_64) \ - || defined(BUILD_TARGET_AMD_64) \ - || defined(BUILD_TARGET_AARCH64) \ +#endif /* end of defined(BUILD_TARGET_X86_64) \ + || defined(BUILD_TARGET_AMD_64) \ + || defined(BUILD_TARGET_AARCH64) \ || defined(BUILD_TARGET_RISCV64_LP64D) \ || defined(BUILD_TARGET_RISCV64_LP64) */ bool -wasm_runtime_call_indirect(WASMExecEnv *exec_env, - uint32_t element_indices, +wasm_runtime_call_indirect(WASMExecEnv *exec_env, uint32_t element_indices, uint32_t argc, uint32_t argv[]) { if (!wasm_runtime_exec_env_check(exec_env)) { @@ -3427,8 +3444,8 @@ wasm_runtime_read_v128(const uint8 *bytes, uint64 *ret1, uint64 *ret2) bh_memcpy_s(&u2, 8, bytes + 8, 8); if (!is_little_endian()) { - exchange_uint64((uint8*)&u1); - exchange_uint64((uint8*)&u2); + exchange_uint64((uint8 *)&u1); + exchange_uint64((uint8 *)&u2); *ret1 = u2; *ret2 = u1; } @@ -3457,7 +3474,7 @@ wasm_runtime_destroy_spawned_exec_env(WASMExecEnv *exec_env) wasm_cluster_destroy_spawned_exec_env(exec_env); } -static void* +static void * wasm_runtime_thread_routine(void *arg) { WASMThreadArg *thread_arg = (WASMThreadArg *)arg; @@ -3550,13 +3567,11 @@ wasm_externref_map_init() if (os_mutex_init(&externref_lock) != 0) return false; - if (!(externref_map = bh_hash_map_create(32, false, - wasm_externref_hash, - wasm_externref_equal, - NULL, + if (!(externref_map = bh_hash_map_create(32, false, wasm_externref_hash, + wasm_externref_equal, NULL, wasm_runtime_free))) { - os_mutex_destroy(&externref_lock); - return false; + os_mutex_destroy(&externref_lock); + return false; } externref_global_id = 1; @@ -3581,8 +3596,8 @@ lookup_extobj_callback(void *key, void *value, void *user_data) { uint32 externref_idx = (uint32)(uintptr_t)key; ExternRefMapNode *node = (ExternRefMapNode *)value; - LookupExtObj_UserData *user_data_lookup = (LookupExtObj_UserData *) - user_data; + LookupExtObj_UserData *user_data_lookup = + (LookupExtObj_UserData *)user_data; if (node->extern_obj == user_data_lookup->node.extern_obj && node->module_inst == user_data_lookup->node.module_inst) { @@ -3592,8 +3607,8 @@ lookup_extobj_callback(void *key, void *value, void *user_data) } bool -wasm_externref_obj2ref(WASMModuleInstanceCommon *module_inst, - void *extern_obj, uint32 *p_externref_idx) +wasm_externref_obj2ref(WASMModuleInstanceCommon *module_inst, void *extern_obj, + uint32 *p_externref_idx) { LookupExtObj_UserData lookup_user_data; ExternRefMapNode *node; @@ -3607,7 +3622,7 @@ wasm_externref_obj2ref(WASMModuleInstanceCommon *module_inst, /* Lookup hashmap firstly */ bh_hash_map_traverse(externref_map, lookup_extobj_callback, - (void*)&lookup_user_data); + (void *)&lookup_user_data); if (lookup_user_data.found) { *p_externref_idx = lookup_user_data.externref_idx; os_mutex_unlock(&externref_lock); @@ -3615,8 +3630,7 @@ wasm_externref_obj2ref(WASMModuleInstanceCommon *module_inst, } /* Not found in hashmap */ - if (externref_global_id == NULL_REF - || externref_global_id == 0) { + if (externref_global_id == NULL_REF || externref_global_id == 0) { goto fail1; } @@ -3630,9 +3644,8 @@ wasm_externref_obj2ref(WASMModuleInstanceCommon *module_inst, externref_idx = externref_global_id; - if (!bh_hash_map_insert(externref_map, - (void*)(uintptr_t)externref_idx, - (void*)node)) { + if (!bh_hash_map_insert(externref_map, (void *)(uintptr_t)externref_idx, + (void *)node)) { goto fail2; } @@ -3657,8 +3670,7 @@ wasm_externref_ref2obj(uint32 externref_idx, void **p_extern_obj) } os_mutex_lock(&externref_lock); - node = bh_hash_map_find(externref_map, - (void*)(uintptr_t)externref_idx); + node = bh_hash_map_find(externref_map, (void *)(uintptr_t)externref_idx); os_mutex_unlock(&externref_lock); if (!node) @@ -3672,8 +3684,8 @@ static void reclaim_extobj_callback(void *key, void *value, void *user_data) { ExternRefMapNode *node = (ExternRefMapNode *)value; - WASMModuleInstanceCommon *module_inst = (WASMModuleInstanceCommon *) - user_data; + WASMModuleInstanceCommon *module_inst = + (WASMModuleInstanceCommon *)user_data; if (node->module_inst == module_inst) { if (!node->marked && !node->retained) { @@ -3692,8 +3704,8 @@ mark_externref(uint32 externref_idx) ExternRefMapNode *node; if (externref_idx != NULL_REF) { - node = bh_hash_map_find(externref_map, - (void*)(uintptr_t)externref_idx); + node = + bh_hash_map_find(externref_map, (void *)(uintptr_t)externref_idx); if (node) { node->marked = true; } @@ -3712,7 +3724,7 @@ interp_mark_all_externrefs(WASMModuleInstance *module_inst) global = module_inst->globals; for (i = 0; i < module_inst->global_count; i++, global++) { if (global->type == VALUE_TYPE_EXTERNREF) { - externref_idx = *(uint32*)(global_data + global->data_offset); + externref_idx = *(uint32 *)(global_data + global->data_offset); mark_externref(externref_idx); } } @@ -3739,7 +3751,7 @@ aot_mark_all_externrefs(AOTModuleInstance *module_inst) const AOTTable *table = module->tables; const AOTGlobal *global = module->globals; const AOTTableInstance *table_inst = - (AOTTableInstance *)module_inst->tables.ptr; + (AOTTableInstance *)module_inst->tables.ptr; for (i = 0; i < module->global_count; i++, global++) { if (global->type == VALUE_TYPE_EXTERNREF) { @@ -3766,15 +3778,15 @@ wasm_externref_reclaim(WASMModuleInstanceCommon *module_inst) os_mutex_lock(&externref_lock); #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) - interp_mark_all_externrefs((WASMModuleInstance*)module_inst); + interp_mark_all_externrefs((WASMModuleInstance *)module_inst); #endif #if WASM_ENABLE_AOT != 0 if (module_inst->module_type == Wasm_Module_AoT) - aot_mark_all_externrefs((AOTModuleInstance*)module_inst); + aot_mark_all_externrefs((AOTModuleInstance *)module_inst); #endif bh_hash_map_traverse(externref_map, reclaim_extobj_callback, - (void*)module_inst); + (void *)module_inst); os_mutex_unlock(&externref_lock); } @@ -3782,8 +3794,8 @@ static void cleanup_extobj_callback(void *key, void *value, void *user_data) { ExternRefMapNode *node = (ExternRefMapNode *)value; - WASMModuleInstanceCommon *module_inst = (WASMModuleInstanceCommon *) - user_data; + WASMModuleInstanceCommon *module_inst = + (WASMModuleInstanceCommon *)user_data; if (node->module_inst == module_inst) { bh_hash_map_remove(externref_map, key, NULL, NULL); @@ -3796,7 +3808,7 @@ wasm_externref_cleanup(WASMModuleInstanceCommon *module_inst) { os_mutex_lock(&externref_lock); bh_hash_map_traverse(externref_map, cleanup_extobj_callback, - (void*)module_inst); + (void *)module_inst); os_mutex_unlock(&externref_lock); } @@ -3808,8 +3820,8 @@ wasm_externref_retain(uint32 externref_idx) os_mutex_lock(&externref_lock); if (externref_idx != NULL_REF) { - node = bh_hash_map_find(externref_map, - (void*)(uintptr_t)externref_idx); + node = + bh_hash_map_find(externref_map, (void *)(uintptr_t)externref_idx); if (node) { node->retained = true; os_mutex_unlock(&externref_lock); @@ -3826,8 +3838,8 @@ wasm_externref_retain(uint32 externref_idx) void wasm_runtime_dump_call_stack(WASMExecEnv *exec_env) { - WASMModuleInstanceCommon *module_inst - = wasm_exec_env_get_module_inst(exec_env); + WASMModuleInstanceCommon *module_inst = + wasm_exec_env_get_module_inst(exec_env); #if WASM_ENABLE_INTERP != 0 if (module_inst->module_type == Wasm_Module_Bytecode) { wasm_interp_dump_call_stack(exec_env); @@ -3843,21 +3855,19 @@ wasm_runtime_dump_call_stack(WASMExecEnv *exec_env) bool wasm_runtime_get_export_func_type(const WASMModuleCommon *module_comm, - const WASMExport *export, - WASMType **out) + const WASMExport *export, WASMType **out) { #if WASM_ENABLE_INTERP != 0 if (module_comm->module_type == Wasm_Module_Bytecode) { WASMModule *module = (WASMModule *)module_comm; if (export->index < module->import_function_count) { - *out = - module->import_functions[export->index].u.function.func_type; + *out = module->import_functions[export->index].u.function.func_type; } else { *out = - module->functions[export->index - module->import_function_count] - ->func_type; + module->functions[export->index - module->import_function_count] + ->func_type; } return true; } @@ -3869,12 +3879,12 @@ wasm_runtime_get_export_func_type(const WASMModuleCommon *module_comm, if (export->index < module->import_func_count) { *out = module->func_types[module->import_funcs[export->index] - .func_type_index]; + .func_type_index]; } else { - *out = - module->func_types[module->func_type_indexes - [export->index - module->import_func_count]]; + *out = module->func_types + [module->func_type_indexes[export->index + - module->import_func_count]]; } return true; } @@ -3885,8 +3895,7 @@ wasm_runtime_get_export_func_type(const WASMModuleCommon *module_comm, bool wasm_runtime_get_export_global_type(const WASMModuleCommon *module_comm, const WASMExport *export, - uint8 *out_val_type, - bool *out_mutability) + uint8 *out_val_type, bool *out_mutability) { #if WASM_ENABLE_INTERP != 0 if (module_comm->module_type == Wasm_Module_Bytecode) { @@ -3894,13 +3903,13 @@ wasm_runtime_get_export_global_type(const WASMModuleCommon *module_comm, if (export->index < module->import_global_count) { WASMGlobalImport *import_global = - &((module->import_globals + export->index)->u.global); + &((module->import_globals + export->index)->u.global); *out_val_type = import_global->type; *out_mutability = import_global->is_mutable; } else { WASMGlobal *global = - module->globals + (export->index - module->import_global_count); + module->globals + (export->index - module->import_global_count); *out_val_type = global->type; *out_mutability = global->is_mutable; } @@ -3914,13 +3923,13 @@ wasm_runtime_get_export_global_type(const WASMModuleCommon *module_comm, if (export->index < module->import_global_count) { AOTImportGlobal *import_global = - module->import_globals + export->index; + module->import_globals + export->index; *out_val_type = import_global->type; *out_mutability = import_global->is_mutable; } else { AOTGlobal *global = - module->globals + (export->index - module->import_global_count); + module->globals + (export->index - module->import_global_count); *out_val_type = global->type; *out_mutability = global->is_mutable; } @@ -3933,8 +3942,7 @@ wasm_runtime_get_export_global_type(const WASMModuleCommon *module_comm, bool wasm_runtime_get_export_memory_type(const WASMModuleCommon *module_comm, const WASMExport *export, - uint32 *out_min_page, - uint32 *out_max_page) + uint32 *out_min_page, uint32 *out_max_page) { #if WASM_ENABLE_INTERP != 0 if (module_comm->module_type == Wasm_Module_Bytecode) { @@ -3942,13 +3950,14 @@ wasm_runtime_get_export_memory_type(const WASMModuleCommon *module_comm, if (export->index < module->import_memory_count) { WASMMemoryImport *import_memory = - &((module->import_memories + export->index)->u.memory); + &((module->import_memories + export->index)->u.memory); *out_min_page = import_memory->init_page_count; *out_max_page = import_memory->max_page_count; } else { WASMMemory *memory = - module->memories + (export->index - module->import_memory_count); + module->memories + + (export->index - module->import_memory_count); *out_min_page = memory->init_page_count; *out_max_page = memory->max_page_count; } @@ -3962,13 +3971,13 @@ wasm_runtime_get_export_memory_type(const WASMModuleCommon *module_comm, if (export->index < module->import_memory_count) { AOTImportMemory *import_memory = - module->import_memories + export->index; + module->import_memories + export->index; *out_min_page = import_memory->mem_init_page_count; *out_max_page = import_memory->mem_max_page_count; } else { - AOTMemory *memory = - module->memories + (export->index - module->import_memory_count); + AOTMemory *memory = module->memories + + (export->index - module->import_memory_count); *out_min_page = memory->mem_init_page_count; *out_max_page = memory->mem_max_page_count; } @@ -3981,8 +3990,7 @@ wasm_runtime_get_export_memory_type(const WASMModuleCommon *module_comm, bool wasm_runtime_get_export_table_type(const WASMModuleCommon *module_comm, const WASMExport *export, - uint8 *out_elem_type, - uint32 *out_min_size, + uint8 *out_elem_type, uint32 *out_min_size, uint32 *out_max_size) { #if WASM_ENABLE_INTERP != 0 @@ -3991,14 +3999,14 @@ wasm_runtime_get_export_table_type(const WASMModuleCommon *module_comm, if (export->index < module->import_table_count) { WASMTableImport *import_table = - &((module->import_tables + export->index)->u.table); + &((module->import_tables + export->index)->u.table); *out_elem_type = import_table->elem_type; *out_min_size = import_table->init_size; *out_max_size = import_table->max_size; } else { WASMTable *table = - module->tables + (export->index - module->import_table_count); + module->tables + (export->index - module->import_table_count); *out_elem_type = table->elem_type; *out_min_size = table->init_size; *out_max_size = table->max_size; @@ -4013,14 +4021,14 @@ wasm_runtime_get_export_table_type(const WASMModuleCommon *module_comm, if (export->index < module->import_table_count) { AOTImportTable *import_table = - module->import_tables + export->index; + module->import_tables + export->index; *out_elem_type = VALUE_TYPE_FUNCREF; *out_min_size = import_table->table_init_size; *out_max_size = import_table->table_max_size; } else { AOTTable *table = - module->tables + (export->index - module->import_table_count); + module->tables + (export->index - module->import_table_count); *out_elem_type = table->elem_type; *out_min_size = table->table_init_size; *out_max_size = table->table_max_size; @@ -4028,13 +4036,11 @@ wasm_runtime_get_export_table_type(const WASMModuleCommon *module_comm, return true; } #endif - return false; + return false; } static inline bool -argv_to_params(wasm_val_t *out_params, - const uint32 *argv, - WASMType *func_type) +argv_to_params(wasm_val_t *out_params, const uint32 *argv, WASMType *func_type) { wasm_val_t *param = out_params; uint32 i = 0, *u32; @@ -4087,10 +4093,8 @@ argv_to_params(wasm_val_t *out_params, } static inline bool -results_to_argv(WASMModuleInstanceCommon *module_inst, - uint32 *out_argv, - const wasm_val_t *results, - WASMType *func_type) +results_to_argv(WASMModuleInstanceCommon *module_inst, uint32 *out_argv, + const wasm_val_t *results, WASMType *func_type) { const wasm_val_t *result = results; uint32 *argv = out_argv, *u32, i; @@ -4128,8 +4132,8 @@ results_to_argv(WASMModuleInstanceCommon *module_inst, bool wasm_runtime_invoke_c_api_native(WASMModuleInstanceCommon *module_inst, void *func_ptr, WASMType *func_type, - uint32 argc, uint32 *argv, - bool with_env, void *wasm_c_api_env) + uint32 argc, uint32 *argv, bool with_env, + void *wasm_c_api_env) { wasm_val_t params_buf[16], results_buf[4]; wasm_val_t *params = params_buf, *results = results_buf; @@ -4172,7 +4176,7 @@ wasm_runtime_invoke_c_api_native(WASMModuleInstanceCommon *module_inst, } else { wasm_func_callback_with_env_t callback = - (wasm_func_callback_with_env_t)func_ptr; + (wasm_func_callback_with_env_t)func_ptr; trap = callback(wasm_c_api_env, ¶ms_vec, &results_vec); } @@ -4180,14 +4184,14 @@ wasm_runtime_invoke_c_api_native(WASMModuleInstanceCommon *module_inst, if (trap->message->data) { /* since trap->message->data does not end with '\0' */ char trap_message[128] = { 0 }; - bh_memcpy_s( - trap_message, 127, trap->message->data, - (trap->message->size < 127 ? (uint32)trap->message->size : 127)); + bh_memcpy_s(trap_message, 127, trap->message->data, + (trap->message->size < 127 ? (uint32)trap->message->size + : 127)); wasm_runtime_set_exception(module_inst, trap_message); } else { wasm_runtime_set_exception( - module_inst, "native function throw unknown exception"); + module_inst, "native function throw unknown exception"); } wasm_trap_delete(trap); goto fail; diff --git a/core/iwasm/common/wasm_runtime_common.h b/core/iwasm/common/wasm_runtime_common.h index cd13a2a0..b115a8a1 100644 --- a/core/iwasm/common/wasm_runtime_common.h +++ b/core/iwasm/common/wasm_runtime_common.h @@ -27,151 +27,187 @@ extern "C" { #if WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 -#define PUT_I64_TO_ADDR(addr, value) do { \ - *(int64*)(addr) = (int64)(value); \ - } while (0) -#define PUT_F64_TO_ADDR(addr, value) do { \ - *(float64*)(addr) = (float64)(value); \ - } while (0) +#define PUT_I64_TO_ADDR(addr, value) \ + do { \ + *(int64 *)(addr) = (int64)(value); \ + } while (0) +#define PUT_F64_TO_ADDR(addr, value) \ + do { \ + *(float64 *)(addr) = (float64)(value); \ + } while (0) -#define GET_I64_FROM_ADDR(addr) (*(int64*)(addr)) -#define GET_F64_FROM_ADDR(addr) (*(float64*)(addr)) +#define GET_I64_FROM_ADDR(addr) (*(int64 *)(addr)) +#define GET_F64_FROM_ADDR(addr) (*(float64 *)(addr)) /* For STORE opcodes */ #define STORE_I64 PUT_I64_TO_ADDR -#define STORE_U32(addr, value) do { \ - *(uint32*)(addr) = (uint32)(value); \ - } while (0) -#define STORE_U16(addr, value) do { \ - *(uint16*)(addr) = (uint16)(value); \ - } while (0) +#define STORE_U32(addr, value) \ + do { \ + *(uint32 *)(addr) = (uint32)(value); \ + } while (0) +#define STORE_U16(addr, value) \ + do { \ + *(uint16 *)(addr) = (uint16)(value); \ + } while (0) /* For LOAD opcodes */ -#define LOAD_I64(addr) (*(int64*)(addr)) -#define LOAD_F64(addr) (*(float64*)(addr)) -#define LOAD_I32(addr) (*(int32*)(addr)) -#define LOAD_U32(addr) (*(uint32*)(addr)) -#define LOAD_I16(addr) (*(int16*)(addr)) -#define LOAD_U16(addr) (*(uint16*)(addr)) +#define LOAD_I64(addr) (*(int64 *)(addr)) +#define LOAD_F64(addr) (*(float64 *)(addr)) +#define LOAD_I32(addr) (*(int32 *)(addr)) +#define LOAD_U32(addr) (*(uint32 *)(addr)) +#define LOAD_I16(addr) (*(int16 *)(addr)) +#define LOAD_U16(addr) (*(uint16 *)(addr)) -#define STORE_PTR(addr, ptr) do { \ - *(void**)addr = (void*)ptr; \ - } while (0) +#define STORE_PTR(addr, ptr) \ + do { \ + *(void **)addr = (void *)ptr; \ + } while (0) -#else /* WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 */ +#else /* WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 */ -#define PUT_I64_TO_ADDR(addr, value) do { \ - uint32 *addr_u32 = (uint32*)(addr); \ - union { int64 val; uint32 parts[2]; } u; \ - u.val = (int64)(value); \ - addr_u32[0] = u.parts[0]; \ - addr_u32[1] = u.parts[1]; \ - } while (0) -#define PUT_F64_TO_ADDR(addr, value) do { \ - uint32 *addr_u32 = (uint32*)(addr); \ - union { float64 val; uint32 parts[2]; } u; \ - u.val = (value); \ - addr_u32[0] = u.parts[0]; \ - addr_u32[1] = u.parts[1]; \ - } while (0) +#define PUT_I64_TO_ADDR(addr, value) \ + do { \ + uint32 *addr_u32 = (uint32 *)(addr); \ + union { \ + int64 val; \ + uint32 parts[2]; \ + } u; \ + u.val = (int64)(value); \ + addr_u32[0] = u.parts[0]; \ + addr_u32[1] = u.parts[1]; \ + } while (0) +#define PUT_F64_TO_ADDR(addr, value) \ + do { \ + uint32 *addr_u32 = (uint32 *)(addr); \ + union { \ + float64 val; \ + uint32 parts[2]; \ + } u; \ + u.val = (value); \ + addr_u32[0] = u.parts[0]; \ + addr_u32[1] = u.parts[1]; \ + } while (0) static inline int64 GET_I64_FROM_ADDR(uint32 *addr) { - union { int64 val; uint32 parts[2]; } u; + union { + int64 val; + uint32 parts[2]; + } u; u.parts[0] = addr[0]; u.parts[1] = addr[1]; return u.val; } static inline float64 -GET_F64_FROM_ADDR (uint32 *addr) +GET_F64_FROM_ADDR(uint32 *addr) { - union { float64 val; uint32 parts[2]; } u; + union { + float64 val; + uint32 parts[2]; + } u; u.parts[0] = addr[0]; u.parts[1] = addr[1]; return u.val; } /* For STORE opcodes */ -#define STORE_I64(addr, value) do { \ - uintptr_t addr1 = (uintptr_t)(addr); \ - union { int64 val; uint32 u32[2]; \ - uint16 u16[4]; uint8 u8[8]; } u; \ - if ((addr1 & (uintptr_t)7) == 0) \ - *(int64*)(addr) = (int64)(value); \ - else { \ - u.val = (int64)(value); \ - if ((addr1 & (uintptr_t)3) == 0) { \ - ((uint32*)(addr))[0] = u.u32[0]; \ - ((uint32*)(addr))[1] = u.u32[1]; \ - } \ - else if ((addr1 & (uintptr_t)1) == 0) { \ - ((uint16*)(addr))[0] = u.u16[0]; \ - ((uint16*)(addr))[1] = u.u16[1]; \ - ((uint16*)(addr))[2] = u.u16[2]; \ - ((uint16*)(addr))[3] = u.u16[3]; \ - } \ - else { \ - int32 t; \ - for (t = 0; t < 8; t++) \ - ((uint8*)(addr))[t] = u.u8[t]; \ - } \ - } \ - } while (0) +#define STORE_I64(addr, value) \ + do { \ + uintptr_t addr1 = (uintptr_t)(addr); \ + union { \ + int64 val; \ + uint32 u32[2]; \ + uint16 u16[4]; \ + uint8 u8[8]; \ + } u; \ + if ((addr1 & (uintptr_t)7) == 0) \ + *(int64 *)(addr) = (int64)(value); \ + else { \ + u.val = (int64)(value); \ + if ((addr1 & (uintptr_t)3) == 0) { \ + ((uint32 *)(addr))[0] = u.u32[0]; \ + ((uint32 *)(addr))[1] = u.u32[1]; \ + } \ + else if ((addr1 & (uintptr_t)1) == 0) { \ + ((uint16 *)(addr))[0] = u.u16[0]; \ + ((uint16 *)(addr))[1] = u.u16[1]; \ + ((uint16 *)(addr))[2] = u.u16[2]; \ + ((uint16 *)(addr))[3] = u.u16[3]; \ + } \ + else { \ + int32 t; \ + for (t = 0; t < 8; t++) \ + ((uint8 *)(addr))[t] = u.u8[t]; \ + } \ + } \ + } while (0) -#define STORE_U32(addr, value) do { \ - uintptr_t addr1 = (uintptr_t)(addr); \ - union { uint32 val; \ - uint16 u16[2]; uint8 u8[4]; } u; \ - if ((addr1 & (uintptr_t)3) == 0) \ - *(uint32*)(addr) = (uint32)(value); \ - else { \ - u.val = (uint32)(value); \ - if ((addr1 & (uintptr_t)1) == 0) { \ - ((uint16*)(addr))[0] = u.u16[0]; \ - ((uint16*)(addr))[1] = u.u16[1]; \ - } \ - else { \ - ((uint8*)(addr))[0] = u.u8[0]; \ - ((uint8*)(addr))[1] = u.u8[1]; \ - ((uint8*)(addr))[2] = u.u8[2]; \ - ((uint8*)(addr))[3] = u.u8[3]; \ - } \ - } \ - } while (0) +#define STORE_U32(addr, value) \ + do { \ + uintptr_t addr1 = (uintptr_t)(addr); \ + union { \ + uint32 val; \ + uint16 u16[2]; \ + uint8 u8[4]; \ + } u; \ + if ((addr1 & (uintptr_t)3) == 0) \ + *(uint32 *)(addr) = (uint32)(value); \ + else { \ + u.val = (uint32)(value); \ + if ((addr1 & (uintptr_t)1) == 0) { \ + ((uint16 *)(addr))[0] = u.u16[0]; \ + ((uint16 *)(addr))[1] = u.u16[1]; \ + } \ + else { \ + ((uint8 *)(addr))[0] = u.u8[0]; \ + ((uint8 *)(addr))[1] = u.u8[1]; \ + ((uint8 *)(addr))[2] = u.u8[2]; \ + ((uint8 *)(addr))[3] = u.u8[3]; \ + } \ + } \ + } while (0) -#define STORE_U16(addr, value) do { \ - union { uint16 val; uint8 u8[2]; } u; \ - u.val = (uint16)(value); \ - ((uint8*)(addr))[0] = u.u8[0]; \ - ((uint8*)(addr))[1] = u.u8[1]; \ - } while (0) +#define STORE_U16(addr, value) \ + do { \ + union { \ + uint16 val; \ + uint8 u8[2]; \ + } u; \ + u.val = (uint16)(value); \ + ((uint8 *)(addr))[0] = u.u8[0]; \ + ((uint8 *)(addr))[1] = u.u8[1]; \ + } while (0) /* For LOAD opcodes */ static inline int64 LOAD_I64(void *addr) { uintptr_t addr1 = (uintptr_t)addr; - union { int64 val; uint32 u32[2]; - uint16 u16[4]; uint8 u8[8]; } u; + union { + int64 val; + uint32 u32[2]; + uint16 u16[4]; + uint8 u8[8]; + } u; if ((addr1 & (uintptr_t)7) == 0) - return *(int64*)addr; + return *(int64 *)addr; if ((addr1 & (uintptr_t)3) == 0) { - u.u32[0] = ((uint32*)addr)[0]; - u.u32[1] = ((uint32*)addr)[1]; + u.u32[0] = ((uint32 *)addr)[0]; + u.u32[1] = ((uint32 *)addr)[1]; } else if ((addr1 & (uintptr_t)1) == 0) { - u.u16[0] = ((uint16*)addr)[0]; - u.u16[1] = ((uint16*)addr)[1]; - u.u16[2] = ((uint16*)addr)[2]; - u.u16[3] = ((uint16*)addr)[3]; + u.u16[0] = ((uint16 *)addr)[0]; + u.u16[1] = ((uint16 *)addr)[1]; + u.u16[2] = ((uint16 *)addr)[2]; + u.u16[3] = ((uint16 *)addr)[3]; } else { int32 t; for (t = 0; t < 8; t++) - u.u8[t] = ((uint8*)addr)[t]; + u.u8[t] = ((uint8 *)addr)[t]; } return u.val; } @@ -180,25 +216,29 @@ static inline float64 LOAD_F64(void *addr) { uintptr_t addr1 = (uintptr_t)addr; - union { float64 val; uint32 u32[2]; - uint16 u16[4]; uint8 u8[8]; } u; + union { + float64 val; + uint32 u32[2]; + uint16 u16[4]; + uint8 u8[8]; + } u; if ((addr1 & (uintptr_t)7) == 0) - return *(float64*)addr; + return *(float64 *)addr; if ((addr1 & (uintptr_t)3) == 0) { - u.u32[0] = ((uint32*)addr)[0]; - u.u32[1] = ((uint32*)addr)[1]; + u.u32[0] = ((uint32 *)addr)[0]; + u.u32[1] = ((uint32 *)addr)[1]; } else if ((addr1 & (uintptr_t)1) == 0) { - u.u16[0] = ((uint16*)addr)[0]; - u.u16[1] = ((uint16*)addr)[1]; - u.u16[2] = ((uint16*)addr)[2]; - u.u16[3] = ((uint16*)addr)[3]; + u.u16[0] = ((uint16 *)addr)[0]; + u.u16[1] = ((uint16 *)addr)[1]; + u.u16[2] = ((uint16 *)addr)[2]; + u.u16[3] = ((uint16 *)addr)[3]; } else { int32 t; for (t = 0; t < 8; t++) - u.u8[t] = ((uint8*)addr)[t]; + u.u8[t] = ((uint8 *)addr)[t]; } return u.val; } @@ -207,19 +247,23 @@ static inline int32 LOAD_I32(void *addr) { uintptr_t addr1 = (uintptr_t)addr; - union { int32 val; uint16 u16[2]; uint8 u8[4]; } u; + union { + int32 val; + uint16 u16[2]; + uint8 u8[4]; + } u; if ((addr1 & (uintptr_t)3) == 0) - return *(int32*)addr; + return *(int32 *)addr; if ((addr1 & (uintptr_t)1) == 0) { - u.u16[0] = ((uint16*)addr)[0]; - u.u16[1] = ((uint16*)addr)[1]; + u.u16[0] = ((uint16 *)addr)[0]; + u.u16[1] = ((uint16 *)addr)[1]; } else { - u.u8[0] = ((uint8*)addr)[0]; - u.u8[1] = ((uint8*)addr)[1]; - u.u8[2] = ((uint8*)addr)[2]; - u.u8[3] = ((uint8*)addr)[3]; + u.u8[0] = ((uint8 *)addr)[0]; + u.u8[1] = ((uint8 *)addr)[1]; + u.u8[2] = ((uint8 *)addr)[2]; + u.u8[3] = ((uint8 *)addr)[3]; } return u.val; } @@ -228,13 +272,16 @@ static inline int16 LOAD_I16(void *addr) { uintptr_t addr1 = (uintptr_t)addr; - union { int16 val; uint8 u8[2]; } u; + union { + int16 val; + uint8 u8[2]; + } u; if ((addr1 & (uintptr_t)1)) { - u.u8[0] = ((uint8*)addr)[0]; - u.u8[1] = ((uint8*)addr)[1]; + u.u8[0] = ((uint8 *)addr)[0]; + u.u8[1] = ((uint8 *)addr)[1]; return u.val; } - return *(int16*)addr; + return *(int16 *)addr; } #define LOAD_U32(addr) ((uint32)LOAD_I32(addr)) @@ -246,7 +293,7 @@ LOAD_I16(void *addr) #define STORE_PTR(addr, ptr) STORE_I64(addr, (uintptr_t)ptr) #endif -#endif /* WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 */ +#endif /* WASM_CPU_SUPPORTS_UNALIGNED_ADDR_ACCESS != 0 */ typedef struct WASMModuleCommon { /* Module type, for module loaded from WASM bytecode binary, @@ -361,8 +408,8 @@ get_package_type(const uint8 *buf, uint32 size); /* See wasm_export.h for description */ WASM_RUNTIME_API_EXTERN WASMModuleCommon * -wasm_runtime_load(const uint8 *buf, uint32 size, - char *error_buf, uint32 error_buf_size); +wasm_runtime_load(const uint8 *buf, uint32 size, char *error_buf, + uint32 error_buf_size); /* See wasm_export.h for description */ WASM_RUNTIME_API_EXTERN WASMModuleCommon * @@ -386,9 +433,9 @@ wasm_runtime_deinstantiate_internal(WASMModuleInstanceCommon *module_inst, /* See wasm_export.h for description */ WASM_RUNTIME_API_EXTERN WASMModuleInstanceCommon * -wasm_runtime_instantiate(WASMModuleCommon *module, - uint32 stack_size, uint32 heap_size, - char *error_buf, uint32 error_buf_size); +wasm_runtime_instantiate(WASMModuleCommon *module, uint32 stack_size, + uint32 heap_size, char *error_buf, + uint32 error_buf_size); /* See wasm_export.h for description */ WASM_RUNTIME_API_EXTERN void @@ -396,7 +443,7 @@ wasm_runtime_deinstantiate(WASMModuleInstanceCommon *module_inst); /* See wasm_export.h for description */ WASM_RUNTIME_API_EXTERN WASMFunctionInstanceCommon * -wasm_runtime_lookup_function(WASMModuleInstanceCommon * const module_inst, +wasm_runtime_lookup_function(WASMModuleInstanceCommon *const module_inst, const char *name, const char *signature); /* Internal API */ @@ -432,8 +479,8 @@ wasm_runtime_get_user_data(WASMExecEnv *exec_env); /* See wasm_export.h for description */ WASM_RUNTIME_API_EXTERN bool wasm_runtime_call_wasm(WASMExecEnv *exec_env, - WASMFunctionInstanceCommon *function, - uint32 argc, uint32 argv[]); + WASMFunctionInstanceCommon *function, uint32 argc, + uint32 argv[]); WASM_RUNTIME_API_EXTERN bool wasm_runtime_call_wasm_a(WASMExecEnv *exec_env, @@ -465,14 +512,13 @@ wasm_runtime_call_wasm_v(WASMExecEnv *exec_env, * the caller can call wasm_runtime_get_exception to get exception info. */ bool -wasm_runtime_call_indirect(WASMExecEnv *exec_env, - uint32 element_indices, +wasm_runtime_call_indirect(WASMExecEnv *exec_env, uint32 element_indices, uint32 argc, uint32 argv[]); bool -wasm_runtime_create_exec_env_and_call_wasm(WASMModuleInstanceCommon *module_inst, - WASMFunctionInstanceCommon *function, - uint32 argc, uint32 argv[]); +wasm_runtime_create_exec_env_and_call_wasm( + WASMModuleInstanceCommon *module_inst, WASMFunctionInstanceCommon *function, + uint32 argc, uint32 argv[]); bool wasm_runtime_create_exec_env_singleton(WASMModuleInstanceCommon *module_inst); @@ -482,8 +528,8 @@ wasm_runtime_get_exec_env_singleton(WASMModuleInstanceCommon *module_inst); /* See wasm_export.h for description */ WASM_RUNTIME_API_EXTERN bool -wasm_application_execute_main(WASMModuleInstanceCommon *module_inst, - int32 argc, char *argv[]); +wasm_application_execute_main(WASMModuleInstanceCommon *module_inst, int32 argc, + char *argv[]); /* See wasm_export.h for description */ WASM_RUNTIME_API_EXTERN bool @@ -559,8 +605,7 @@ wasm_runtime_addr_native_to_app(WASMModuleInstanceCommon *module_inst, /* See wasm_export.h for description */ WASM_RUNTIME_API_EXTERN bool wasm_runtime_get_app_addr_range(WASMModuleInstanceCommon *module_inst, - uint32 app_offset, - uint32 *p_app_start_offset, + uint32 app_offset, uint32 *p_app_start_offset, uint32 *p_app_end_offset); /* See wasm_export.h for description */ @@ -600,8 +645,7 @@ wasm_runtime_register_module_internal(const char *module_name, WASMModuleCommon *module, uint8 *orig_file_buf, uint32 orig_file_buf_size, - char *error_buf, - uint32 error_buf_size); + char *error_buf, uint32 error_buf_size); void wasm_runtime_unregister_module(const WASMModuleCommon *module); @@ -610,8 +654,8 @@ bool wasm_runtime_is_module_registered(const char *module_name); bool -wasm_runtime_add_loading_module(const char *module_name, - char *error_buf, uint32 error_buf_size); +wasm_runtime_add_loading_module(const char *module_name, char *error_buf, + uint32 error_buf_size); void wasm_runtime_delete_loading_module(const char *module_name); @@ -628,30 +672,28 @@ wasm_runtime_is_built_in_module(const char *module_name); #if WASM_ENABLE_THREAD_MGR != 0 bool -wasm_exec_env_get_aux_stack(WASMExecEnv *exec_env, - uint32 *start_offset, uint32 *size); +wasm_exec_env_get_aux_stack(WASMExecEnv *exec_env, uint32 *start_offset, + uint32 *size); bool -wasm_exec_env_set_aux_stack(WASMExecEnv *exec_env, - uint32 start_offset, uint32 size); +wasm_exec_env_set_aux_stack(WASMExecEnv *exec_env, uint32 start_offset, + uint32 size); #endif #if WASM_ENABLE_LIBC_WASI != 0 WASM_RUNTIME_API_EXTERN void -wasm_runtime_set_wasi_args_ex(WASMModuleCommon *module, - const char *dir_list[], uint32 dir_count, - const char *map_dir_list[], uint32 map_dir_count, - const char *env_list[], uint32 env_count, - char *argv[], int argc, - int stdinfd, int stdoutfd, int stderrfd); +wasm_runtime_set_wasi_args_ex(WASMModuleCommon *module, const char *dir_list[], + uint32 dir_count, const char *map_dir_list[], + uint32 map_dir_count, const char *env_list[], + uint32 env_count, char *argv[], int argc, + int stdinfd, int stdoutfd, int stderrfd); /* See wasm_export.h for description */ WASM_RUNTIME_API_EXTERN void -wasm_runtime_set_wasi_args(WASMModuleCommon *module, - const char *dir_list[], uint32 dir_count, - const char *map_dir_list[], uint32 map_dir_count, - const char *env_list[], uint32 env_count, - char *argv[], int argc); +wasm_runtime_set_wasi_args(WASMModuleCommon *module, const char *dir_list[], + uint32 dir_count, const char *map_dir_list[], + uint32 map_dir_count, const char *env_list[], + uint32 env_count, char *argv[], int argc); /* See wasm_export.h for description */ WASM_RUNTIME_API_EXTERN bool @@ -665,9 +707,8 @@ bool wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst, const char *dir_list[], uint32 dir_count, const char *map_dir_list[], uint32 map_dir_count, - const char *env[], uint32 env_count, - char *argv[], uint32 argc, - int stdinfd, int stdoutfd, int stderrfd, + const char *env[], uint32 env_count, char *argv[], + uint32 argc, int stdinfd, int stdoutfd, int stderrfd, char *error_buf, uint32 error_buf_size); void @@ -685,8 +726,8 @@ wasm_runtime_get_wasi_ctx(WASMModuleInstanceCommon *module_inst); #if WASM_ENABLE_REF_TYPES != 0 /* See wasm_export.h for description */ WASM_RUNTIME_API_EXTERN bool -wasm_externref_obj2ref(WASMModuleInstanceCommon *module_inst, - void *extern_obj, uint32 *p_externref_idx); +wasm_externref_obj2ref(WASMModuleInstanceCommon *module_inst, void *extern_obj, + uint32 *p_externref_idx); /* See wasm_export.h for description */ WASM_RUNTIME_API_EXTERN bool @@ -711,7 +752,7 @@ wasm_externref_cleanup(WASMModuleInstanceCommon *module_inst); #endif /* end of WASM_ENABLE_REF_TYPES */ /* Get module of the current exec_env */ -WASMModuleCommon* +WASMModuleCommon * wasm_exec_env_get_module(WASMExecEnv *exec_env); /** @@ -722,7 +763,8 @@ wasm_exec_env_get_module(WASMExecEnv *exec_env); * @return return true if enlarge successfully, false otherwise */ bool -wasm_runtime_enlarge_memory(WASMModuleInstanceCommon *module, uint32 inc_page_count); +wasm_runtime_enlarge_memory(WASMModuleInstanceCommon *module, + uint32 inc_page_count); /* See wasm_export.h for description */ WASM_RUNTIME_API_EXTERN bool @@ -739,14 +781,14 @@ wasm_runtime_register_natives_raw(const char *module_name, bool wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr, const WASMType *func_type, const char *signature, - void *attachment, - uint32 *argv, uint32 argc, uint32 *ret); + void *attachment, uint32 *argv, uint32 argc, + uint32 *ret); bool wasm_runtime_invoke_native_raw(WASMExecEnv *exec_env, void *func_ptr, const WASMType *func_type, const char *signature, - void *attachment, - uint32 *argv, uint32 argc, uint32 *ret); + void *attachment, uint32 *argv, uint32 argc, + uint32 *ret); void wasm_runtime_read_v128(const uint8 *bytes, uint64 *ret1, uint64 *ret2); @@ -755,8 +797,8 @@ void wasm_runtime_dump_module_mem_consumption(const WASMModuleCommon *module); void -wasm_runtime_dump_module_inst_mem_consumption(const WASMModuleInstanceCommon - *module_inst); +wasm_runtime_dump_module_inst_mem_consumption( + const WASMModuleInstanceCommon *module_inst); void wasm_runtime_dump_exec_env_mem_consumption(const WASMExecEnv *exec_env); @@ -773,37 +815,32 @@ wasm_runtime_finalize_call_function(WASMExecEnv *exec_env, bool wasm_runtime_get_export_func_type(const WASMModuleCommon *module_comm, - const WASMExport *export_, - WASMType **out); + const WASMExport *export_, WASMType **out); bool wasm_runtime_get_export_global_type(const WASMModuleCommon *module_comm, const WASMExport *export_, - uint8 *out_val_type, - bool *out_mutability); + uint8 *out_val_type, bool *out_mutability); bool wasm_runtime_get_export_memory_type(const WASMModuleCommon *module_comm, const WASMExport *export_, - uint32 *out_min_page, - uint32 *out_max_page); + uint32 *out_min_page, uint32 *out_max_page); bool wasm_runtime_get_export_table_type(const WASMModuleCommon *module_comm, const WASMExport *export_, - uint8 *out_elem_type, - uint32 *out_min_size, + uint8 *out_elem_type, uint32 *out_min_size, uint32 *out_max_size); bool wasm_runtime_invoke_c_api_native(WASMModuleInstanceCommon *module_inst, void *func_ptr, WASMType *func_type, - uint32 argc, uint32 *argv, - bool with_env, void *wasm_c_api_env); + uint32 argc, uint32 *argv, bool with_env, + void *wasm_c_api_env); #ifdef __cplusplus } #endif #endif /* end of _WASM_COMMON_H */ - diff --git a/core/iwasm/common/wasm_shared_memory.c b/core/iwasm/common/wasm_shared_memory.c index cef0aa36..65c98d4e 100644 --- a/core/iwasm/common/wasm_shared_memory.c +++ b/core/iwasm/common/wasm_shared_memory.c @@ -10,9 +10,12 @@ static bh_list shared_memory_list_head; static bh_list *const shared_memory_list = &shared_memory_list_head; static korp_mutex shared_memory_list_lock; +/* clang-format off */ enum { - S_WAITING, S_NOTIFIED + S_WAITING, + S_NOTIFIED }; +/* clang-format on */ typedef struct AtomicWaitInfo { korp_mutex wait_list_lock; @@ -45,11 +48,9 @@ wasm_shared_memory_init() if (os_mutex_init(&shared_memory_list_lock) != 0) return false; /* wait map not exists, create new map */ - if (!(wait_map = - bh_hash_map_create(32, true, - (HashFunc)wait_address_hash, - (KeyEqualFunc)wait_address_equal, - NULL, destroy_wait_info))) { + if (!(wait_map = bh_hash_map_create(32, true, (HashFunc)wait_address_hash, + (KeyEqualFunc)wait_address_equal, NULL, + destroy_wait_info))) { os_mutex_destroy(&shared_memory_list_lock); return false; } @@ -66,7 +67,7 @@ wasm_shared_memory_destroy() } } -static WASMSharedMemNode* +static WASMSharedMemNode * search_module(WASMModuleCommon *module) { WASMSharedMemNode *node; @@ -86,7 +87,7 @@ search_module(WASMModuleCommon *module) return NULL; } -WASMSharedMemNode* +WASMSharedMemNode * wasm_module_get_shared_memory(WASMModuleCommon *module) { return search_module(module); @@ -128,13 +129,13 @@ shared_memory_dec_reference(WASMModuleCommon *module) return -1; } -WASMMemoryInstanceCommon* +WASMMemoryInstanceCommon * shared_memory_get_memory_inst(WASMSharedMemNode *node) { return node->memory_inst; } -WASMSharedMemNode* +WASMSharedMemNode * shared_memory_set_memory_inst(WASMModuleCommon *module, WASMMemoryInstanceCommon *memory) { @@ -223,16 +224,15 @@ acquire_wait_info(void *address, bool create) AtomicWaitInfo *wait_info = NULL; bh_list_status ret; - wait_info = (AtomicWaitInfo *) - bh_hash_map_find(wait_map, address); + wait_info = (AtomicWaitInfo *)bh_hash_map_find(wait_map, address); if (!create) return wait_info; /* No wait info on this address, create new info */ if (!wait_info) { - if (!(wait_info = - (AtomicWaitInfo *)wasm_runtime_malloc(sizeof(AtomicWaitInfo)))) + if (!(wait_info = (AtomicWaitInfo *)wasm_runtime_malloc( + sizeof(AtomicWaitInfo)))) return NULL; memset(wait_info, 0, sizeof(AtomicWaitInfo)); @@ -247,8 +247,7 @@ acquire_wait_info(void *address, bool create) return NULL; } - if (!bh_hash_map_insert(wait_map, address, - (void *)wait_info)) { + if (!bh_hash_map_insert(wait_map, address, (void *)wait_info)) { os_mutex_destroy(&wait_info->wait_list_lock); wasm_runtime_free(wait_info); return NULL; @@ -283,8 +282,7 @@ destroy_wait_info(void *wait_info) } static void -release_wait_info(HashMap *wait_map, - AtomicWaitInfo *wait_info, void *address) +release_wait_info(HashMap *wait_map, AtomicWaitInfo *wait_info, void *address) { if (wait_info->wait_list->len == 0) { bh_hash_map_remove(wait_map, address, NULL, NULL); @@ -333,8 +331,8 @@ wasm_runtime_atomic_wait(WASMModuleInstanceCommon *module, void *address, os_mutex_lock(&wait_info->wait_list_lock); - if ((!wait64 && *(uint32*)address != (uint32)expect) - || (wait64 && *(uint64*)address != expect)) { + if ((!wait64 && *(uint32 *)address != (uint32)expect) + || (wait64 && *(uint64 *)address != expect)) { os_mutex_unlock(&wait_info->wait_list_lock); return 1; } @@ -375,8 +373,7 @@ wasm_runtime_atomic_wait(WASMModuleInstanceCommon *module, void *address, if (timeout < 0) timeout = BHT_WAIT_FOREVER; - os_cond_reltimedwait(&wait_node->wait_cond, - &wait_node->wait_lock, timeout); + os_cond_reltimedwait(&wait_node->wait_cond, &wait_node->wait_lock, timeout); os_mutex_unlock(&wait_node->wait_lock); @@ -400,8 +397,8 @@ wasm_runtime_atomic_wait(WASMModuleInstanceCommon *module, void *address, } uint32 -wasm_runtime_atomic_notify(WASMModuleInstanceCommon *module, - void *address, uint32 count) +wasm_runtime_atomic_notify(WASMModuleInstanceCommon *module, void *address, + uint32 count) { uint32 notify_result; AtomicWaitInfo *wait_info; diff --git a/core/iwasm/common/wasm_shared_memory.h b/core/iwasm/common/wasm_shared_memory.h index f05e5957..bc6f8945 100644 --- a/core/iwasm/common/wasm_shared_memory.h +++ b/core/iwasm/common/wasm_shared_memory.h @@ -37,7 +37,7 @@ wasm_shared_memory_init(); void wasm_shared_memory_destroy(); -WASMSharedMemNode* +WASMSharedMemNode * wasm_module_get_shared_memory(WASMModuleCommon *module); int32 @@ -46,10 +46,10 @@ shared_memory_inc_reference(WASMModuleCommon *module); int32 shared_memory_dec_reference(WASMModuleCommon *module); -WASMMemoryInstanceCommon* +WASMMemoryInstanceCommon * shared_memory_get_memory_inst(WASMSharedMemNode *node); -WASMSharedMemNode* +WASMSharedMemNode * shared_memory_set_memory_inst(WASMModuleCommon *module, WASMMemoryInstanceCommon *memory); @@ -58,8 +58,8 @@ wasm_runtime_atomic_wait(WASMModuleInstanceCommon *module, void *address, uint64 expect, int64 timeout, bool wait64); uint32 -wasm_runtime_atomic_notify(WASMModuleInstanceCommon *module, - void *address, uint32 count); +wasm_runtime_atomic_notify(WASMModuleInstanceCommon *module, void *address, + uint32 count); #ifdef __cplusplus } diff --git a/core/iwasm/include/aot_export.h b/core/iwasm/include/aot_export.h index 476e2cb3..f323a585 100644 --- a/core/iwasm/include/aot_export.h +++ b/core/iwasm/include/aot_export.h @@ -9,7 +9,6 @@ #include #include - #ifdef __cplusplus extern "C" { #endif @@ -27,9 +26,9 @@ void aot_destroy_comp_data(aot_comp_data_t comp_data); #if WASM_ENABLE_DEBUG_AOT != 0 -typedef void * dwar_extractor_handle_t; +typedef void *dwar_extractor_handle_t; dwar_extractor_handle_t -create_dwarf_extractor(aot_comp_data_t comp_data, char * file_name); +create_dwarf_extractor(aot_comp_data_t comp_data, char *file_name); #endif enum { @@ -39,7 +38,7 @@ enum { AOT_LLVMIR_OPT_FILE, }; -typedef struct AOTCompOption{ +typedef struct AOTCompOption { bool is_jit_mode; bool is_indirect_mode; char *target_arch; @@ -62,8 +61,7 @@ typedef struct AOTCompOption{ } AOTCompOption, *aot_comp_option_t; aot_comp_context_t -aot_create_comp_context(aot_comp_data_t comp_data, - aot_comp_option_t option); +aot_create_comp_context(aot_comp_data_t comp_data, aot_comp_option_t option); void aot_destroy_comp_context(aot_comp_context_t comp_ctx); @@ -78,8 +76,7 @@ bool aot_emit_object_file(aot_comp_context_t comp_ctx, const char *file_name); bool -aot_emit_aot_file(aot_comp_context_t comp_ctx, - aot_comp_data_t comp_data, +aot_emit_aot_file(aot_comp_context_t comp_ctx, aot_comp_data_t comp_data, const char *file_name); void @@ -88,16 +85,15 @@ aot_destroy_aot_file(uint8_t *aot_file); bool aot_compile_wasm_file_init(); -uint8_t* +uint8_t * aot_compile_wasm_file(const uint8_t *wasm_file_buf, uint32_t wasm_file_size, - uint32_t opt_level, uint32_t size_level, - char *error_buf, uint32_t error_buf_size, - uint32_t *p_aot_file_size); + uint32_t opt_level, uint32_t size_level, char *error_buf, + uint32_t error_buf_size, uint32_t *p_aot_file_size); void aot_compile_wasm_file_destroy(); -char* +char * aot_get_last_error(); uint32_t diff --git a/core/iwasm/include/lib_export.h b/core/iwasm/include/lib_export.h index 3a4c02d4..e4829e4f 100644 --- a/core/iwasm/include/lib_export.h +++ b/core/iwasm/include/lib_export.h @@ -21,18 +21,22 @@ typedef struct NativeSymbol { void *attachment; } NativeSymbol; -#define EXPORT_WASM_API(symbol) {#symbol, (void*)symbol, NULL, NULL} -#define EXPORT_WASM_API2(symbol) {#symbol, (void*)symbol##_wrapper, NULL, NULL} +/* clang-format off */ +#define EXPORT_WASM_API(symbol) \ + { #symbol, (void *)symbol, NULL, NULL } +#define EXPORT_WASM_API2(symbol) \ + { #symbol, (void *)symbol##_wrapper, NULL, NULL } #define EXPORT_WASM_API_WITH_SIG(symbol, signature) \ - {#symbol, (void*)symbol, signature, NULL} + { #symbol, (void *)symbol, signature, NULL } #define EXPORT_WASM_API_WITH_SIG2(symbol, signature) \ - {#symbol, (void*)symbol##_wrapper, signature, NULL} + { #symbol, (void *)symbol##_wrapper, signature, NULL } #define EXPORT_WASM_API_WITH_ATT(symbol, signature, attachment) \ - {#symbol, (void*)symbol, signature, attachment} + { #symbol, (void *)symbol, signature, attachment } #define EXPORT_WASM_API_WITH_ATT2(symbol, signature, attachment) \ - {#symbol, (void*)symbol##_wrapper, signature, attachment} + { #symbol, (void *)symbol##_wrapper, signature, attachment } +/* clang-format on */ /** * Get the exported APIs of base lib @@ -48,5 +52,4 @@ get_base_lib_export_apis(NativeSymbol **p_base_lib_apis); } #endif -#endif - +#endif /* end of _LIB_EXPORT_H_ */ diff --git a/core/iwasm/include/wasm_c_api.h b/core/iwasm/include/wasm_c_api.h index b1a9df84..6722093a 100644 --- a/core/iwasm/include/wasm_c_api.h +++ b/core/iwasm/include/wasm_c_api.h @@ -1,7 +1,7 @@ // WebAssembly C API -#ifndef WASM_H -#define WASM_H +#ifndef _WASM_C_API_H_ +#define _WASM_C_API_H_ #include #include @@ -11,11 +11,11 @@ #ifndef WASM_API_EXTERN #if defined(_MSC_BUILD) - #if defined(COMPILING_WASM_RUNTIME_API) - #define WASM_API_EXTERN __declspec(dllexport) - #else - #define WASM_API_EXTERN __declspec(dllimport) - #endif +#if defined(COMPILING_WASM_RUNTIME_API) +#define WASM_API_EXTERN __declspec(dllexport) +#else +#define WASM_API_EXTERN __declspec(dllimport) +#endif #else #define WASM_API_EXTERN #endif @@ -25,6 +25,8 @@ extern "C" { #endif +/* clang-format off */ + /////////////////////////////////////////////////////////////////////////////// // Auxiliaries @@ -776,8 +778,10 @@ static inline void* wasm_val_ptr(const wasm_val_t* val) { #undef own +/* clang-format on */ + #ifdef __cplusplus -} // extern "C" +} // extern "C" #endif -#endif // #ifdef WASM_H +#endif // #ifdef _WASM_C_API_H_ diff --git a/core/iwasm/include/wasm_export.h b/core/iwasm/include/wasm_export.h index 0a15066a..9b33f9f4 100644 --- a/core/iwasm/include/wasm_export.h +++ b/core/iwasm/include/wasm_export.h @@ -10,14 +10,13 @@ #include #include "lib_export.h" - #ifndef WASM_RUNTIME_API_EXTERN -#if defined(_MSC_BUILD ) - #if defined(COMPILING_WASM_RUNTIME_API) - #define WASM_RUNTIME_API_EXTERN __declspec(dllexport) - #else - #define WASM_RUNTIME_API_EXTERN __declspec(dllimport) - #endif +#if defined(_MSC_BUILD) +#if defined(COMPILING_WASM_RUNTIME_API) +#define WASM_RUNTIME_API_EXTERN __declspec(dllexport) +#else +#define WASM_RUNTIME_API_EXTERN __declspec(dllimport) +#endif #else #define WASM_RUNTIME_API_EXTERN #endif @@ -27,6 +26,8 @@ extern "C" { #endif +/* clang-format off */ + #define get_module_inst(exec_env) \ wasm_runtime_get_module_inst(exec_env) @@ -48,13 +49,12 @@ extern "C" { #define module_free(offset) \ wasm_runtime_module_free(module_inst, offset) -#define native_raw_return_type(type, args) type *raw_ret = (type*)(args) +#define native_raw_return_type(type, args) type *raw_ret = (type *)(args) -#define native_raw_get_arg(type, name, args) type name = *((type*)(args++)) +#define native_raw_get_arg(type, name, args) type name = *((type *)(args++)) #define native_raw_set_return(val) *raw_ret = (val) - #ifndef WASM_MODULE_T_DEFINED #define WASM_MODULE_T_DEFINED /* Uninstantiated WASM module loaded from WASM binary file @@ -158,14 +158,14 @@ enum wasm_valkind_enum { struct wasm_ref_t; typedef struct wasm_val_t { - wasm_valkind_t kind; - union { - int32_t i32; - int64_t i64; - float f32; - double f64; - struct wasm_ref_t* ref; - } of; + wasm_valkind_t kind; + union { + int32_t i32; + int64_t i64; + float f32; + double f64; + struct wasm_ref_t *ref; + } of; } wasm_val_t; #endif @@ -652,10 +652,11 @@ wasm_runtime_validate_app_addr(wasm_module_inst_t module_inst, /** * Similar to wasm_runtime_validate_app_addr(), except that the size parameter - * is not provided. This function validates the app string address, check whether it - * belongs to WASM module instance's address space, or in its heap space or - * memory space. Moreover, it checks whether it is the offset of a string that - * is end with '\0'. + * is not provided. This function validates the app string address, check + * whether it belongs to WASM module instance's address space, or in its heap + * space or memory space. Moreover, it checks whether it is the offset of a + * string that is end with '\0'. + * * @param module_inst the WASM module instance * @param app_str_offset the app address of the string to validate, which is a * relative address @@ -724,12 +725,15 @@ wasm_runtime_get_app_addr_range(wasm_module_inst_t module_inst, uint32_t *p_app_end_offset); /** - * Get the native address range (absolute address) that a native address belongs to + * Get the native address range (absolute address) that a native address + * belongs to * * @param module_inst the WASM module instance * @param native_ptr the native address to retrieve - * @param p_native_start_addr buffer to output the native start address if not NULL - * @param p_native_end_addr buffer to output the native end address if not NULL + * @param p_native_start_addr buffer to output the native start address + * if not NULL + * @param p_native_end_addr buffer to output the native end address + * if not NULL * * @return true if success, false otherwise. */ @@ -740,31 +744,31 @@ wasm_runtime_get_native_addr_range(wasm_module_inst_t module_inst, uint8_t **p_native_end_addr); /** - * Register native functions with same module name - * - * @param module_name the module name of the native functions - * @param native_symbols specifies an array of NativeSymbol structures which - * contain the names, function pointers and signatures - * Note: WASM runtime will not allocate memory to clone the data, so - * user must ensure the array can be used forever - * Meanings of letters in function signature: - * 'i': the parameter is i32 type - * 'I': the parameter is i64 type - * 'f': the parameter is f32 type - * 'F': the parameter is f64 type - * '*': the parameter is a pointer (i32 in WASM), and runtime will - * auto check its boundary before calling the native function. - * If it is followed by '~', the checked length of the pointer - * is gotten from the following parameter, if not, the checked - * length of the pointer is 1. - * '~': the parameter is the pointer's length with i32 type, and must - * follow after '*' - * '$': the parameter is a string (i32 in WASM), and runtime will - * auto check its boundary before calling the native function - * @param n_native_symbols specifies the number of native symbols in the array - * - * @return true if success, false otherwise - */ + * Register native functions with same module name + * + * @param module_name the module name of the native functions + * @param native_symbols specifies an array of NativeSymbol structures which + * contain the names, function pointers and signatures + * Note: WASM runtime will not allocate memory to clone the data, so + * user must ensure the array can be used forever + * Meanings of letters in function signature: + * 'i': the parameter is i32 type + * 'I': the parameter is i64 type + * 'f': the parameter is f32 type + * 'F': the parameter is f64 type + * '*': the parameter is a pointer (i32 in WASM), and runtime will + * auto check its boundary before calling the native function. + * If it is followed by '~', the checked length of the pointer + * is gotten from the following parameter, if not, the checked + * length of the pointer is 1. + * '~': the parameter is the pointer's length with i32 type, and must + * follow after '*' + * '$': the parameter is a string (i32 in WASM), and runtime will + * auto check its boundary before calling the native function + * @param n_native_symbols specifies the number of native symbols in the array + * + * @return true if success, false otherwise + */ WASM_RUNTIME_API_EXTERN bool wasm_runtime_register_natives(const char *module_name, NativeSymbol *native_symbols, @@ -773,7 +777,7 @@ wasm_runtime_register_natives(const char *module_name, /** * Register native functions with same module name, similar to * wasm_runtime_register_natives, the difference is that runtime passes raw - * arguments to native API, which means that the native API should be defined as: + * arguments to native API, which means that the native API should be defined as * void foo(wasm_exec_env_t exec_env, uint64 *args); * and native API should extract arguments one by one from args array with macro * native_raw_get_arg @@ -802,8 +806,7 @@ wasm_runtime_get_function_attachment(wasm_exec_env_t exec_env); * @param user_data the user data to be set */ WASM_RUNTIME_API_EXTERN void -wasm_runtime_set_user_data(wasm_exec_env_t exec_env, - void *user_data); +wasm_runtime_set_user_data(wasm_exec_env_t exec_env, void *user_data); /** * Get the user data within execution environment. * @@ -835,7 +838,7 @@ WASM_RUNTIME_API_EXTERN void wasm_runtime_dump_perf_profiling(wasm_module_inst_t module_inst); /* wasm thread callback function type */ -typedef void* (*wasm_thread_callback_t)(wasm_exec_env_t, void *); +typedef void *(*wasm_thread_callback_t)(wasm_exec_env_t, void *); /* wasm thread type */ typedef uintptr_t wasm_thread_t; @@ -938,6 +941,8 @@ wasm_externref_retain(uint32_t externref_idx); WASM_RUNTIME_API_EXTERN void wasm_runtime_dump_call_stack(wasm_exec_env_t exec_env); +/* clang-format on */ + #ifdef __cplusplus } #endif diff --git a/doc/source_debugging.md b/doc/source_debugging.md index 60b08240..4c09c3e1 100644 --- a/doc/source_debugging.md +++ b/doc/source_debugging.md @@ -36,7 +36,7 @@ iwasm -g=127.0.0.1:1234 test.wasm ``` bash cd ${WAMR_ROOT}/core/deps/llvm git apply ../../../build-scripts/lldb-wasm.patch -mkdir build_lldb && cd build_lldb +mkdir build-lldb && cd build-lldb cmake -DCMAKE_BUILD_TYPE:STRING="Release" -DLLVM_ENABLE_PROJECTS="clang;lldb" -DLLVM_TARGETS_TO_BUILD:STRING="X86;WebAssembly" -DLLVM_ENABLE_LIBXML2:BOOL=ON ../llvm make -j $(nproc) ``` @@ -87,4 +87,4 @@ wamrc -o test.aot test.wasm lldb-12 iwasm -- test.aot ``` -Then you can use lldb commands to debug both wamr runtime and your wasm application in ***current terminal*** \ No newline at end of file +Then you can use lldb commands to debug both wamr runtime and your wasm application in ***current terminal*** diff --git a/tests/wamr-test-suites/test_wamr.sh b/tests/wamr-test-suites/test_wamr.sh index 0f585955..afccb23d 100755 --- a/tests/wamr-test-suites/test_wamr.sh +++ b/tests/wamr-test-suites/test_wamr.sh @@ -278,7 +278,7 @@ function spec_test() # restore from XX_ignore_cases.patch # resotre branch git checkout -B master - git reset --hard f9770eb75117cac0c878feaa5eaf4a4d9dda61f5 + git reset --hard 397399a70565609bf142d211891724e21bffd01f git apply ../../spec-test-script/ignore_cases.patch # udpate thread cases @@ -291,7 +291,7 @@ function spec_test() # fetch spec for threads proposal git fetch threads git reset --hard HEAD - git checkout threads/master + git checkout threads/main git apply ../../spec-test-script/thread_proposal_ignore_cases.patch fi @@ -335,16 +335,16 @@ function spec_test() exit 1 ;; esac - if [ ! -f /tmp/wabt-1.0.23-${WABT_PLATFORM}.tar.gz ]; then + if [ ! -f /tmp/wabt-1.0.24-${WABT_PLATFORM}.tar.gz ]; then wget \ - https://github.com/WebAssembly/wabt/releases/download/1.0.23/wabt-1.0.23-${WABT_PLATFORM}.tar.gz \ + https://github.com/WebAssembly/wabt/releases/download/1.0.24/wabt-1.0.24-${WABT_PLATFORM}.tar.gz \ -P /tmp fi cd /tmp \ - && tar zxf wabt-1.0.23-${WABT_PLATFORM}.tar.gz \ + && tar zxf wabt-1.0.24-${WABT_PLATFORM}.tar.gz \ && mkdir -p ${WORK_DIR}/wabt/out/gcc/Release/ \ - && install wabt-1.0.23/bin/wa* ${WORK_DIR}/wabt/out/gcc/Release/ \ + && install wabt-1.0.24/bin/wa* ${WORK_DIR}/wabt/out/gcc/Release/ \ && cd - fi else @@ -356,12 +356,7 @@ function spec_test() echo "upate wabt" cd wabt git pull - if [[ ${ENABLE_SIMD} == 0 ]]; then - # Use latest version of wabt if simd cases are not tested - git reset --hard c6cd63316ac53208900cda4d1089a22618b85256 - else - git reset --hard origin/main - fi + git reset --hard origin/main cd .. make -C wabt gcc-release fi