From 788e14ed6ca53b5462146486fbfd755e46512171 Mon Sep 17 00:00:00 2001 From: Javan Date: Tue, 26 Oct 2021 16:32:52 +0800 Subject: [PATCH] Enable emitting custom name section to aot file (#794) Enable emitting custom name section to aot file when adding `--enable-dump-call-stack` or `--enable-dump-call-stack` to wamrc and there is custom name section in wasm file, which can be generated by wasi-sdk/emcc "-g" option. So aot runtime can also get the function name from the custom name section instead of export section, to which developer should use `--export-all` for wasi-sdk/emcc to generate export function names. --- .gitignore | 2 + core/iwasm/aot/aot_loader.c | 149 ++++++++- core/iwasm/aot/aot_runtime.c | 29 ++ core/iwasm/aot/aot_runtime.h | 12 +- core/iwasm/aot/arch/aot_reloc_aarch64.c | 6 +- core/iwasm/compilation/aot.c | 9 + core/iwasm/compilation/aot.h | 6 + core/iwasm/compilation/aot_emit_aot_file.c | 311 ++++++++++++++++++- core/iwasm/interpreter/wasm.h | 5 + core/iwasm/interpreter/wasm_interp_classic.c | 2 +- core/iwasm/interpreter/wasm_interp_fast.c | 2 +- core/iwasm/interpreter/wasm_loader.c | 2 + doc/wamr_api.md | 2 +- 13 files changed, 519 insertions(+), 18 deletions(-) diff --git a/.gitignore b/.gitignore index 36b2b6756..57d60419d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,8 @@ .vs .vscode +/.idea +**/cmake-build-*/ **/*build/ core/deps/** core/shared/mem-alloc/tlsf diff --git a/core/iwasm/aot/aot_loader.c b/core/iwasm/aot/aot_loader.c index 1923a6a2d..5d192b535 100644 --- a/core/iwasm/aot/aot_loader.c +++ b/core/iwasm/aot/aot_loader.c @@ -434,6 +434,133 @@ fail: return false; } +static bool +load_name_section(const uint8 *buf, const uint8 *buf_end, AOTModule *module, + char *error_buf, uint32 error_buf_size) +{ +#if WASM_ENABLE_CUSTOM_NAME_SECTION != 0 + const uint8 *p = buf, *p_end = buf_end; + uint32 *aux_func_indexes; + const char **aux_func_names; + uint32 name_type, subsection_size; + uint32 previous_name_type = 0; + uint32 num_func_name; + uint32 func_index; + uint32 previous_func_index = ~0U; + uint32 name_index; + int i = 0; + uint32 name_len; + uint64 size; + + if (p >= p_end) { + set_error_buf(error_buf, error_buf_size, "unexpected end"); + return false; + } + + read_uint32(p, p_end, name_len); + + if (name_len != 4 || p + name_len > p_end) { + set_error_buf(error_buf, error_buf_size, "unexpected end"); + return false; + } + + if (memcmp(p, "name", 4) != 0) { + set_error_buf(error_buf, error_buf_size, "invalid custom name section"); + return false; + } + p += name_len; + + while (p < p_end) { + read_uint32(p, p_end, name_type); + if (i != 0) { + if (name_type == previous_name_type) { + set_error_buf(error_buf, error_buf_size, + "duplicate sub-section"); + return false; + } + if (name_type < previous_name_type) { + set_error_buf(error_buf, error_buf_size, + "out-of-order sub-section"); + return false; + } + } + previous_name_type = name_type; + read_uint32(p, p_end, subsection_size); + CHECK_BUF(p, p_end, subsection_size); + switch (name_type) { + case SUB_SECTION_TYPE_FUNC: + if (subsection_size) { + read_uint32(p, p_end, num_func_name); + if (num_func_name + > module->import_func_count + module->func_count) { + set_error_buf(error_buf, error_buf_size, + "function name count out of bounds"); + return false; + } + module->aux_func_name_count = num_func_name; + + /* Allocate memory */ + size = sizeof(uint32) * (uint64)module->aux_func_name_count; + if (!(aux_func_indexes = module->aux_func_indexes = + loader_malloc(size, error_buf, error_buf_size))) { + return false; + } + size = + sizeof(char **) * (uint64)module->aux_func_name_count; + if (!(aux_func_names = module->aux_func_names = + loader_malloc(size, error_buf, error_buf_size))) { + return false; + } + + for (name_index = 0; name_index < num_func_name; + name_index++) { + read_uint32(p, p_end, func_index); + if (name_index != 0 + && func_index == previous_func_index) { + set_error_buf(error_buf, error_buf_size, + "duplicate function name"); + return false; + } + if (name_index != 0 + && func_index < previous_func_index) { + set_error_buf(error_buf, error_buf_size, + "out-of-order function index "); + return false; + } + if (func_index + >= module->import_func_count + module->func_count) { + set_error_buf(error_buf, error_buf_size, + "function index out of bounds"); + return false; + } + previous_func_index = func_index; + *(aux_func_indexes + name_index) = func_index; + read_string(p, p_end, *(aux_func_names + name_index)); +#if 0 + LOG_DEBUG("func_index %u -> aux_func_name = %s\n", + func_index, *(aux_func_names + name_index)); +#endif + } + } + break; + case SUB_SECTION_TYPE_MODULE: /* TODO: Parse for module subsection + */ + case SUB_SECTION_TYPE_LOCAL: /* TODO: Parse for local subsection */ + default: + p = p + subsection_size; + break; + } + i++; + } + + return true; +fail: + return false; +#else + return true; +#endif /* WASM_ENABLE_CUSTOM_NAME_SECTION != 0 */ +} + static bool load_custom_section(const uint8 *buf, const uint8 *buf_end, AOTModule *module, char *error_buf, uint32 error_buf_size) @@ -450,6 +577,11 @@ load_custom_section(const uint8 *buf, const uint8 *buf_end, AOTModule *module, error_buf_size)) goto fail; break; + case AOT_CUSTOM_SECTION_NAME: + if (!load_name_section(buf, buf_end, module, error_buf, + error_buf_size)) + goto fail; + break; default: break; } @@ -1233,7 +1365,7 @@ load_text_section(const uint8 *buf, const uint8 *buf_end, AOTModule *module, /* The layout is: literal size + literal + code (with plt table) */ read_uint32(buf, buf_end, module->literal_size); - /* literal data is at begining of the text section */ + /* literal data is at beginning of the text section */ module->literal = (uint8 *)buf; module->code = (void *)(buf + module->literal_size); module->code_size = (uint32)(buf_end - (uint8 *)module->code); @@ -2336,7 +2468,7 @@ create_sections(AOTModule *module, const uint8 *buf, uint32 size, { AOTSection *section_list = NULL, *section_list_end = NULL, *section; const uint8 *p = buf, *p_end = buf + size; - bool destory_aot_text = false; + bool destroy_aot_text = false; uint32 native_symbol_count = 0; uint32 section_type; uint32 section_size; @@ -2403,7 +2535,7 @@ create_sections(AOTModule *module, const uint8 *buf, uint32 size, bh_memcpy_s(aot_text, (uint32)total_size, section->section_body, (uint32)section_size); section->section_body = aot_text; - destory_aot_text = true; + destroy_aot_text = true; if ((uint32)total_size > section->section_body_size) { memset(aot_text + (uint32)section_size, 0, @@ -2437,7 +2569,7 @@ create_sections(AOTModule *module, const uint8 *buf, uint32 size, return true; fail: if (section_list) - destroy_sections(section_list, destory_aot_text); + destroy_sections(section_list, destroy_aot_text); return false; } @@ -2868,6 +3000,15 @@ aot_unload(AOTModule *module) jit_code_entry_destroy(module->elf_hdr); #endif +#if WASM_ENABLE_CUSTOM_NAME_SECTION != 0 + if (module->aux_func_indexes) { + wasm_runtime_free(module->aux_func_indexes); + } + if (module->aux_func_names) { + wasm_runtime_free(module->aux_func_names); + } +#endif + wasm_runtime_free(module); } diff --git a/core/iwasm/aot/aot_runtime.c b/core/iwasm/aot/aot_runtime.c index 81120db9c..fb2463c06 100644 --- a/core/iwasm/aot/aot_runtime.c +++ b/core/iwasm/aot/aot_runtime.c @@ -2815,6 +2815,27 @@ aot_table_grow(AOTModuleInstance *module_inst, uint32 tbl_idx, #endif /* WASM_ENABLE_REF_TYPES != 0 */ #if (WASM_ENABLE_DUMP_CALL_STACK != 0) || (WASM_ENABLE_PERF_PROFILING != 0) +static const char * +lookup_func_name(const char **func_names, uint32 *func_indexes, + uint32 func_index_count, uint32 func_index) +{ + int64 low = 0, mid; + int64 high = func_index_count - 1; + + while (low <= high) { + mid = (low + high) / 2; + if (func_index == func_indexes[mid]) { + return func_names[mid]; + } + else if (func_index < func_indexes[mid]) + high = mid - 1; + else + low = mid + 1; + } + + return NULL; +} + static const char * get_func_name_from_index(const AOTModuleInstance *module_inst, uint32 func_index) @@ -2822,6 +2843,14 @@ get_func_name_from_index(const AOTModuleInstance *module_inst, const char *func_name = NULL; AOTModule *module = module_inst->aot_module.ptr; +#if WASM_ENABLE_CUSTOM_NAME_SECTION != 0 + if ((func_name = + lookup_func_name(module->aux_func_names, module->aux_func_indexes, + module->aux_func_name_count, func_index))) { + return func_name; + } +#endif + if (func_index < module->import_func_count) { func_name = module->import_funcs[func_index].func_name; } diff --git a/core/iwasm/aot/aot_runtime.h b/core/iwasm/aot/aot_runtime.h index 4fe9889ee..97d6bd27e 100644 --- a/core/iwasm/aot/aot_runtime.h +++ b/core/iwasm/aot/aot_runtime.h @@ -52,6 +52,7 @@ typedef enum AOTSectionType { typedef enum AOTCustomSectionType { AOT_CUSTOM_SECTION_NATIVE_SYMBOL = 1, AOT_CUSTOM_SECTION_ACCESS_CONTROL = 2, + AOT_CUSTOM_SECTION_NAME = 3, } AOTCustomSectionType; typedef struct AOTObjectDataSection { @@ -133,7 +134,7 @@ typedef struct AOTModule { uint32 mem_init_data_count; AOTMemInitData **mem_init_data_list; - /* native symobl */ + /* native symbol */ uint32 native_symbol_count; void **native_symbol_list; @@ -153,7 +154,7 @@ typedef struct AOTModule { uint32 func_type_count; AOTFuncType **func_types; - /* import global varaible info */ + /* import global variable info */ uint32 import_global_count; AOTImportGlobal *import_globals; @@ -260,6 +261,11 @@ typedef struct AOTModule { void *elf_hdr; uint32 elf_size; #endif +#if WASM_ENABLE_CUSTOM_NAME_SECTION != 0 + const char **aux_func_names; + uint32 *aux_func_indexes; + uint32 aux_func_name_count; +#endif } AOTModule; typedef union { @@ -335,7 +341,7 @@ typedef struct AOTModuleInstance { /* points to AOTTableInstance[] */ AOTPointer tables; - /* funciton pointer array */ + /* function pointer array */ AOTPointer func_ptrs; /* function type indexes */ AOTPointer func_type_indexes; diff --git a/core/iwasm/aot/arch/aot_reloc_aarch64.c b/core/iwasm/aot/arch/aot_reloc_aarch64.c index 0ca22b84b..734ea8d5c 100644 --- a/core/iwasm/aot/arch/aot_reloc_aarch64.c +++ b/core/iwasm/aot/arch/aot_reloc_aarch64.c @@ -224,7 +224,7 @@ apply_relocation(AOTModule *module, uint8 *target_section_addr, /* S + A */ X = (int64)S + A; - /* No need to check overflow for this reloction type */ + /* No need to check overflow for this relocation type */ switch (reloc_type) { case R_AARCH64_MOVW_UABS_G0: if (X < 0 || X >= (1LL << 16)) @@ -324,7 +324,7 @@ apply_relocation(AOTModule *module, uint8 *target_section_addr, /* S + A */ X = (int64)S + A; - /* No need to check overflow for this reloction type */ + /* No need to check overflow for this relocation type */ /* write the imm12 back to instruction */ *(int32 *)P = (insn & 0xFFC003FF) | ((int32)((X & 0xFFF) << 10)); @@ -354,7 +354,7 @@ apply_relocation(AOTModule *module, uint8 *target_section_addr, /* S + A */ X = (int64)S + A; - /* No need to check overflow for this reloction type */ + /* No need to check overflow for this relocation type */ /* write the imm12 back to instruction */ switch (reloc_type) { diff --git a/core/iwasm/compilation/aot.c b/core/iwasm/compilation/aot.c index d26a943af..e836df28f 100644 --- a/core/iwasm/compilation/aot.c +++ b/core/iwasm/compilation/aot.c @@ -515,6 +515,12 @@ aot_create_comp_data(WASMModule *module) if (comp_data->func_count && !(comp_data->funcs = aot_create_funcs(module))) goto fail; +#if WASM_ENABLE_CUSTOM_NAME_SECTION != 0 + /* Create custom name section */ + comp_data->name_section_buf = module->name_section_buf; + comp_data->name_section_buf_end = module->name_section_buf_end; +#endif + /* Create aux data/heap/stack information */ comp_data->aux_data_end_global_index = module->aux_data_end_global_index; comp_data->aux_data_end = module->aux_data_end; @@ -581,5 +587,8 @@ aot_destroy_comp_data(AOTCompData *comp_data) if (comp_data->funcs) aot_destroy_funcs(comp_data->funcs, comp_data->func_count); + if (comp_data->aot_name_section_buf) + wasm_runtime_free(comp_data->aot_name_section_buf); + wasm_runtime_free(comp_data); } diff --git a/core/iwasm/compilation/aot.h b/core/iwasm/compilation/aot.h index 599d48321..bff207916 100644 --- a/core/iwasm/compilation/aot.h +++ b/core/iwasm/compilation/aot.h @@ -239,6 +239,12 @@ typedef struct AOTCompData { uint32 func_count; AOTFunc **funcs; + /* Custom name sections */ + const uint8 *name_section_buf; + const uint8 *name_section_buf_end; + uint8 *aot_name_section_buf; + uint32 aot_name_section_size; + uint32 global_data_size; uint32 start_func_index; diff --git a/core/iwasm/compilation/aot_emit_aot_file.c b/core/iwasm/compilation/aot_emit_aot_file.c index 8e68ccae2..0cfdae832 100644 --- a/core/iwasm/compilation/aot_emit_aot_file.c +++ b/core/iwasm/compilation/aot_emit_aot_file.c @@ -25,6 +25,71 @@ } \ } while (0) +static bool +check_utf8_str(const uint8 *str, uint32 len) +{ + /* The valid ranges are taken from page 125, below link + https://www.unicode.org/versions/Unicode9.0.0/ch03.pdf */ + const uint8 *p = str, *p_end = str + len; + uint8 chr; + + while (p < p_end) { + chr = *p; + if (chr < 0x80) { + p++; + } + else if (chr >= 0xC2 && chr <= 0xDF && p + 1 < p_end) { + if (p[1] < 0x80 || p[1] > 0xBF) { + return false; + } + p += 2; + } + else if (chr >= 0xE0 && chr <= 0xEF && p + 2 < p_end) { + if (chr == 0xE0) { + if (p[1] < 0xA0 || p[1] > 0xBF || p[2] < 0x80 || p[2] > 0xBF) { + return false; + } + } + else if (chr == 0xED) { + if (p[1] < 0x80 || p[1] > 0x9F || p[2] < 0x80 || p[2] > 0xBF) { + return false; + } + } + else if (chr >= 0xE1 && chr <= 0xEF) { + if (p[1] < 0x80 || p[1] > 0xBF || p[2] < 0x80 || p[2] > 0xBF) { + return false; + } + } + p += 3; + } + else if (chr >= 0xF0 && chr <= 0xF4 && p + 3 < p_end) { + if (chr == 0xF0) { + if (p[1] < 0x90 || p[1] > 0xBF || p[2] < 0x80 || p[2] > 0xBF + || p[3] < 0x80 || p[3] > 0xBF) { + return false; + } + } + else if (chr >= 0xF1 && chr <= 0xF3) { + if (p[1] < 0x80 || p[1] > 0xBF || p[2] < 0x80 || p[2] > 0xBF + || p[3] < 0x80 || p[3] > 0xBF) { + return false; + } + } + else if (chr == 0xF4) { + if (p[1] < 0x80 || p[1] > 0x8F || p[2] < 0x80 || p[2] > 0xBF + || p[3] < 0x80 || p[3] > 0xBF) { + return false; + } + } + p += 4; + } + else { + return false; + } + } + return (p == p_end); +} + /* Internal function in object file */ typedef struct AOTObjectFunc { char *func_name; @@ -794,6 +859,9 @@ get_native_symbol_list_size(AOTCompContext *comp_ctx) return len; } +static uint32 +get_name_section_size(AOTCompData *comp_data); + static uint32 get_aot_file_size(AOTCompContext *comp_ctx, AOTCompData *comp_data, AOTObjectData *obj_data) @@ -840,13 +908,22 @@ get_aot_file_size(AOTCompContext *comp_ctx, AOTCompData *comp_data, size += get_relocation_section_size(obj_data); if (get_native_symbol_list_size(comp_ctx) > 0) { - /* emit only when threre are native symbols */ + /* emit only when there are native symbols */ size = align_uint(size, 4); /* section id + section size + sub section id + symbol count */ size += (uint32)sizeof(uint32) * 4; size += get_native_symbol_list_size(comp_ctx); } + if (comp_ctx->enable_aux_stack_frame) { + /* custom name section */ + size = align_uint(size, 4); + /* section id + section size + sub section id */ + size += (uint32)sizeof(uint32) * 3; + size += (comp_data->aot_name_section_size = + get_name_section_size(comp_data)); + } + return size; } @@ -975,6 +1052,205 @@ static union { EMIT_BUF(s, str_len); \ } while (0) +static bool +read_leb(uint8 **p_buf, const uint8 *buf_end, uint32 maxbits, bool sign, + uint64 *p_result) +{ + const uint8 *buf = *p_buf; + uint64 result = 0; + uint32 shift = 0; + uint32 offset = 0, bcnt = 0; + uint64 byte; + + while (true) { + /* uN or SN must not exceed ceil(N/7) bytes */ + if (bcnt + 1 > (maxbits + 6) / 7) { + aot_set_last_error("integer representation too long"); + return false; + } + + if (buf + offset + 1 > buf_end) { + aot_set_last_error("unexpected end of section or function"); + return false; + } + byte = buf[offset]; + offset += 1; + result |= ((byte & 0x7f) << shift); + shift += 7; + bcnt += 1; + if ((byte & 0x80) == 0) { + break; + } + } + + if (!sign && maxbits == 32 && shift >= maxbits) { + /* The top bits set represent values > 32 bits */ + if (((uint8)byte) & 0xf0) + goto fail_integer_too_large; + } + else if (sign && maxbits == 32) { + if (shift < maxbits) { + /* Sign extend, second highest bit is the sign bit */ + if ((uint8)byte & 0x40) + result |= (~((uint64)0)) << shift; + } + else { + /* The top bits should be a sign-extension of the sign bit */ + bool sign_bit_set = ((uint8)byte) & 0x8; + int top_bits = ((uint8)byte) & 0xf0; + if ((sign_bit_set && top_bits != 0x70) + || (!sign_bit_set && top_bits != 0)) + goto fail_integer_too_large; + } + } + else if (sign && maxbits == 64) { + if (shift < maxbits) { + /* Sign extend, second highest bit is the sign bit */ + if ((uint8)byte & 0x40) + result |= (~((uint64)0)) << shift; + } + else { + /* The top bits should be a sign-extension of the sign bit */ + bool sign_bit_set = ((uint8)byte) & 0x1; + int top_bits = ((uint8)byte) & 0xfe; + + if ((sign_bit_set && top_bits != 0x7e) + || (!sign_bit_set && top_bits != 0)) + goto fail_integer_too_large; + } + } + + *p_buf += offset; + *p_result = result; + return true; + +fail_integer_too_large: + aot_set_last_error("integer too large"); + return false; +} + +#define read_leb_uint32(p, p_end, res) \ + do { \ + uint64 res64; \ + if (!read_leb((uint8 **)&p, p_end, 32, false, &res64)) \ + goto fail; \ + res = (uint32)res64; \ + } while (0) + +static uint32 +get_name_section_size(AOTCompData *comp_data) +{ + const uint8 *p = comp_data->name_section_buf, + *p_end = comp_data->name_section_buf_end; + uint8 *buf, *buf_end; + uint32 name_type, subsection_size; + uint32 previous_name_type = 0; + uint32 num_func_name; + uint32 func_index; + uint32 previous_func_index = ~0U; + uint32 func_name_len; + uint32 name_index; + int i = 0; + uint32 name_len; + uint32 offset = 0; + uint32 max_aot_buf_size = 0; + + if (p >= p_end) { + aot_set_last_error("unexpected end"); + return 0; + } + + max_aot_buf_size = 4 * (p_end - p); + if (!(buf = comp_data->aot_name_section_buf = + wasm_runtime_malloc(max_aot_buf_size))) { + aot_set_last_error("allocate memory for custom name section failed."); + return 0; + } + buf_end = buf + max_aot_buf_size; + + read_leb_uint32(p, p_end, name_len); + offset = align_uint(offset, 4); + EMIT_U32(name_len); + + if (name_len == 0 || p + name_len > p_end) { + aot_set_last_error("unexpected end"); + return 0; + } + + if (!check_utf8_str(p, name_len)) { + aot_set_last_error("invalid UTF-8 encoding"); + return 0; + } + + if (memcmp(p, "name", 4) != 0) { + aot_set_last_error("invalid custom name section"); + return 0; + } + EMIT_BUF(p, name_len); + p += name_len; + + while (p < p_end) { + read_leb_uint32(p, p_end, name_type); + if (i != 0) { + if (name_type == previous_name_type) { + aot_set_last_error("duplicate sub-section"); + return 0; + } + if (name_type < previous_name_type) { + aot_set_last_error("out-of-order sub-section"); + return 0; + } + } + previous_name_type = name_type; + read_leb_uint32(p, p_end, subsection_size); + switch (name_type) { + case SUB_SECTION_TYPE_FUNC: + if (subsection_size) { + offset = align_uint(offset, 4); + EMIT_U32(name_type); + EMIT_U32(subsection_size); + + read_leb_uint32(p, p_end, num_func_name); + EMIT_U32(num_func_name); + + for (name_index = 0; name_index < num_func_name; + name_index++) { + read_leb_uint32(p, p_end, func_index); + offset = align_uint(offset, 4); + EMIT_U32(func_index); + if (func_index == previous_func_index) { + aot_set_last_error("duplicate function name"); + return 0; + } + if (func_index < previous_func_index + && previous_func_index != ~0U) { + aot_set_last_error("out-of-order function index "); + return 0; + } + previous_func_index = func_index; + read_leb_uint32(p, p_end, func_name_len); + offset = align_uint(offset, 2); + EMIT_U16(func_name_len); + EMIT_BUF(p, func_name_len); + p += func_name_len; + } + } + break; + case SUB_SECTION_TYPE_MODULE: /* TODO: Parse for module subsection + */ + case SUB_SECTION_TYPE_LOCAL: /* TODO: Parse for local subsection */ + default: + p = p + subsection_size; + break; + } + i++; + } + + return offset; +fail: + return 0; +} + static bool aot_emit_file_header(uint8 *buf, uint8 *buf_end, uint32 *p_offset, AOTCompData *comp_data, AOTObjectData *obj_data) @@ -1537,7 +1813,7 @@ aot_emit_native_symbol(uint8 *buf, uint8 *buf_end, uint32 *p_offset, AOTNativeSymbol *sym = NULL; if (bh_list_length(&comp_ctx->native_symbols) == 0) - /* emit only when threre are native symbols */ + /* emit only when there are native symbols */ return true; *p_offset = offset = align_uint(offset, 4); @@ -1561,6 +1837,30 @@ aot_emit_native_symbol(uint8 *buf, uint8 *buf_end, uint32 *p_offset, return true; } +static bool +aot_emit_name_section(uint8 *buf, uint8 *buf_end, uint32 *p_offset, + AOTCompData *comp_data, AOTCompContext *comp_ctx) +{ + if (comp_ctx->enable_aux_stack_frame) { + uint32 offset = *p_offset; + + *p_offset = offset = align_uint(offset, 4); + + EMIT_U32(AOT_SECTION_TYPE_CUSTOM); + /* sub section id + name section size */ + EMIT_U32(sizeof(uint32) * 1 + comp_data->aot_name_section_size); + EMIT_U32(AOT_CUSTOM_SECTION_NAME); + bh_memcpy_s((uint8 *)(buf + offset), buf_end - buf, + comp_data->aot_name_section_buf, + comp_data->aot_name_section_size); + offset += comp_data->aot_name_section_size; + + *p_offset = offset; + } + + return true; +} + typedef uint32 U32; typedef int32 I32; typedef uint16 U16; @@ -1970,7 +2270,7 @@ aot_resolve_object_relocation_group(AOTObjectData *obj_data, bool has_addend = str_starts_with(group->section_name, ".rela"); uint8 *rela_content = NULL; - /* calculate relocations count and allcate memory */ + /* calculate relocations count and allocate memory */ if (!get_relocations_count(rel_sec, &group->relocation_count)) return false; if (group->relocation_count == 0) { @@ -2146,7 +2446,7 @@ aot_resolve_object_relocation_groups(AOTObjectData *obj_data) char *name; uint32 size; - /* calculate relocation groups count and allcate memory */ + /* calculate relocation groups count and allocate memory */ if (!get_relocation_groups_count(obj_data, &group_count)) return false; @@ -2384,7 +2684,8 @@ aot_emit_aot_file_buf(AOTCompContext *comp_ctx, AOTCompData *comp_data, || !aot_emit_export_section(buf, buf_end, &offset, comp_data, obj_data) || !aot_emit_relocation_section(buf, buf_end, &offset, comp_data, obj_data) - || !aot_emit_native_symbol(buf, buf_end, &offset, comp_ctx)) + || !aot_emit_native_symbol(buf, buf_end, &offset, comp_ctx) + || !aot_emit_name_section(buf, buf_end, &offset, comp_data, comp_ctx)) goto fail2; #if 0 diff --git a/core/iwasm/interpreter/wasm.h b/core/iwasm/interpreter/wasm.h index 4402b92e4..f3e3e5b6f 100644 --- a/core/iwasm/interpreter/wasm.h +++ b/core/iwasm/interpreter/wasm.h @@ -418,6 +418,11 @@ struct WASMModule { uint64 load_size; uint64 buf_code_size; #endif + +#if WASM_ENABLE_CUSTOM_NAME_SECTION != 0 + const uint8 *name_section_buf; + const uint8 *name_section_buf_end; +#endif }; typedef struct BlockType { diff --git a/core/iwasm/interpreter/wasm_interp_classic.c b/core/iwasm/interpreter/wasm_interp_classic.c index a4e48510a..347da3fe0 100644 --- a/core/iwasm/interpreter/wasm_interp_classic.c +++ b/core/iwasm/interpreter/wasm_interp_classic.c @@ -3643,7 +3643,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module, frame->csp_boundary = frame->csp_bottom + cur_wasm_func->max_block_num; - /* Initialize the local varialbes */ + /* Initialize the local variables */ memset(frame_lp + cur_func->param_cell_num, 0, (uint32)(cur_func->local_cell_num * 4)); diff --git a/core/iwasm/interpreter/wasm_interp_fast.c b/core/iwasm/interpreter/wasm_interp_fast.c index b0e29e456..ad2c6a69e 100644 --- a/core/iwasm/interpreter/wasm_interp_fast.c +++ b/core/iwasm/interpreter/wasm_interp_fast.c @@ -3658,7 +3658,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module, word_copy(frame->operand, (uint32 *)cur_wasm_func->consts, cur_wasm_func->const_cell_num); - /* Initialize the local varialbes */ + /* Initialize the local variables */ memset(frame_lp + cur_func->param_cell_num, 0, (uint32)(cur_func->local_cell_num * 4)); diff --git a/core/iwasm/interpreter/wasm_loader.c b/core/iwasm/interpreter/wasm_loader.c index 979ab0be2..619b219f3 100644 --- a/core/iwasm/interpreter/wasm_loader.c +++ b/core/iwasm/interpreter/wasm_loader.c @@ -2838,6 +2838,8 @@ load_user_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, #if WASM_ENABLE_CUSTOM_NAME_SECTION != 0 if (memcmp(p, "name", 4) == 0) { + module->name_section_buf = buf; + module->name_section_buf_end = buf_end; p += name_len; handle_name_section(p, p_end, module, error_buf, error_buf_size); } diff --git a/doc/wamr_api.md b/doc/wamr_api.md index b3cc45b8a..88a847c93 100644 --- a/doc/wamr_api.md +++ b/doc/wamr_api.md @@ -283,7 +283,7 @@ void on_destroy() ## GUI API -The API's is listed in header file ```core/app-framework/wgl/app/wa-inc/wgl.h``` which is implemented based on open soure 2D graphic library [LittlevGL](https://docs.littlevgl.com/en/html/index.html). +The API's is listed in header file ```core/app-framework/wgl/app/wa-inc/wgl.h``` which is implemented based on open source 2D graphic library [LittlevGL](https://docs.littlevgl.com/en/html/index.html). ``` C static void btn_event_cb(wgl_obj_t btn, wgl_event_t event);