gnh1201/wasm-micro-runtime
1
0
Fork 0
mirror of https://github.com/bytecodealliance/wasm-micro-runtime.git synced 2025-09-08 10:51:16 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Refine interp/aot string storage and emitting (#820)

Browse Source 
Currently the string in the wasm/aot file will be duplicated and stored
into const string list/set in interpreter/aot loader, which leads to extra
unnecessary memory consumption if the file buffer can be referred to
after loading. We refine the string storage by:
- if the file buffer can be referred to after loading and it is writable, we
  reuse the file buffer to store the string but not store it into the const
  string set: move string backward and append '\0'
- emit string with '\0' only for XIP mode in which the AOT file is readonly
- if the file buffer cannot be referred to, e.g. in app manager, keep the
  same behavior as before

Signed-off-by: Wenyong Huang <wenyong.huang@intel.com>
This commit is contained in:
Wenyong Huang 2021-11-08 11:27:26 +08:00 committed by GitHub
parent 9424dad56a
commit 403a7d3f4f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 345 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

207
core/iwasm/aot/aot_loader.c
View File

@ -153,16 +153,12 @@ GET_U64_FROM_ADDR(uint32 *addr)
p += len; \ p += len; \
} while (0) } while (0)
#define read_string(p, p_end, str) \ #define read_string(p, p_end, str) \
do { \ do { \
uint16 str_len; \ if (!(str = load_string((uint8 **)&p, p_end, module, \
read_uint16(p, p_end, str_len); \ is_load_from_file_buf, error_buf, \
CHECK_BUF(p, p_end, str_len); \ error_buf_size))) \
if (!(str = const_str_set_insert(p, str_len, module, error_buf, \ goto fail; \
error_buf_size))) { \
goto fail; \
} \
p += str_len; \
} while (0) } while (0)
/* Legal values for bin_type */ /* Legal values for bin_type */
@ -218,6 +214,17 @@ const_str_set_insert(const uint8 *str, int32 len, AOTModule *module,
HashMap *set = module->const_str_set; HashMap *set = module->const_str_set;
char *c_str, *value; char *c_str, *value;
/* Create const string set if it isn't created */
if (!set
&& !(set = 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");
return NULL;
}
/* Lookup const string set, use the string if found */
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; return NULL;
} }
@ -240,6 +247,64 @@ const_str_set_insert(const uint8 *str, int32 len, AOTModule *module,
return c_str; return c_str;
} }
static char *
load_string(uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
bool is_load_from_file_buf, char *error_buf, uint32 error_buf_size)
{
uint8 *p = *p_buf;
const uint8 *p_end = buf_end;
char *str;
uint16 str_len;
CHECK_BUF(p, p_end, 1);
if (*p & 0x80) {
/* The string has been adjusted */
str = (char *)++p;
/* Ensure the whole string is in range */
do {
CHECK_BUF(p, p_end, 1);
} while (*p++ != '\0');
}
else {
/* The string hasn't been adjusted */
read_uint16(p, p_end, str_len);
CHECK_BUF(p, p_end, str_len);
if (str_len == 0) {
str = "";
}
else if (p[str_len - 1] == '\0') {
/* The string is terminated with '\0', use it directly */
str = (char *)p;
}
else if (is_load_from_file_buf) {
/* As the file buffer can be referred to after loading,
we use the 2 bytes of size to adjust the string:
mark the flag with the highest bit of size[0],
move string 1 byte backward and then append '\0' */
*(p - 2) |= 0x80;
bh_memmove_s(p - 1, (uint32)(str_len + 1), p, (uint32)str_len);
p[str_len - 1] = '\0';
str = (char *)(p - 1);
}
else {
/* Load from sections, the file buffer cannot be reffered to
after loading, we must create another string and insert it
into const string set */
if (!(str = const_str_set_insert((uint8 *)p, str_len, module,
error_buf, error_buf_size))) {
goto fail;
}
}
p += str_len;
}
*p_buf = p;
return str;
fail:
return NULL;
}
static bool static bool
get_aot_file_target(AOTTargetInfo *target_info, char *target_buf, get_aot_file_target(AOTTargetInfo *target_info, char *target_buf,
uint32 target_buf_size, char *error_buf, uint32 target_buf_size, char *error_buf,
@ -398,8 +463,8 @@ get_native_symbol_by_name(const char *name)
static bool static bool
load_native_symbol_section(const uint8 *buf, const uint8 *buf_end, load_native_symbol_section(const uint8 *buf, const uint8 *buf_end,
AOTModule *module, char *error_buf, AOTModule *module, bool is_load_from_file_buf,
uint32 error_buf_size) char *error_buf, uint32 error_buf_size)
{ {
const uint8 *p = buf, *p_end = buf_end; const uint8 *p = buf, *p_end = buf_end;
uint32 cnt; uint32 cnt;
@ -436,7 +501,8 @@ fail:
static bool static bool
load_name_section(const uint8 *buf, const uint8 *buf_end, AOTModule *module, load_name_section(const uint8 *buf, const uint8 *buf_end, AOTModule *module,
char *error_buf, uint32 error_buf_size) bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size)
{ {
#if WASM_ENABLE_CUSTOM_NAME_SECTION != 0 #if WASM_ENABLE_CUSTOM_NAME_SECTION != 0
const uint8 *p = buf, *p_end = buf_end; const uint8 *p = buf, *p_end = buf_end;
@ -563,7 +629,8 @@ fail:
static bool 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) bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size)
{ {
const uint8 *p = buf, *p_end = buf_end; const uint8 *p = buf, *p_end = buf_end;
uint32 sub_section_type; uint32 sub_section_type;
@ -573,13 +640,14 @@ load_custom_section(const uint8 *buf, const uint8 *buf_end, AOTModule *module,
switch (sub_section_type) { switch (sub_section_type) {
case AOT_CUSTOM_SECTION_NATIVE_SYMBOL: case AOT_CUSTOM_SECTION_NATIVE_SYMBOL:
if (!load_native_symbol_section(buf, buf_end, module, error_buf, if (!load_native_symbol_section(buf, buf_end, module,
is_load_from_file_buf, error_buf,
error_buf_size)) error_buf_size))
goto fail; goto fail;
break; break;
case AOT_CUSTOM_SECTION_NAME: case AOT_CUSTOM_SECTION_NAME:
if (!load_name_section(buf, buf_end, module, error_buf, if (!load_name_section(buf, buf_end, module, is_load_from_file_buf,
error_buf_size)) error_buf, error_buf_size))
goto fail; goto fail;
break; break;
default: default:
@ -977,7 +1045,8 @@ destroy_import_globals(AOTImportGlobal *import_globals, bool is_jit_mode)
static bool static bool
load_import_globals(const uint8 **p_buf, const uint8 *buf_end, load_import_globals(const uint8 **p_buf, const uint8 *buf_end,
AOTModule *module, char *error_buf, uint32 error_buf_size) AOTModule *module, bool is_load_from_file_buf,
char *error_buf, uint32 error_buf_size)
{ {
const uint8 *buf = *p_buf; const uint8 *buf = *p_buf;
AOTImportGlobal *import_globals; AOTImportGlobal *import_globals;
@ -1031,8 +1100,8 @@ fail:
static bool static bool
load_import_global_info(const uint8 **p_buf, const uint8 *buf_end, load_import_global_info(const uint8 **p_buf, const uint8 *buf_end,
AOTModule *module, char *error_buf, AOTModule *module, bool is_load_from_file_buf,
uint32 error_buf_size) char *error_buf, uint32 error_buf_size)
{ {
const uint8 *buf = *p_buf; const uint8 *buf = *p_buf;
@ -1040,8 +1109,8 @@ load_import_global_info(const uint8 **p_buf, const uint8 *buf_end,
/* load import globals */ /* load import globals */
if (module->import_global_count > 0 if (module->import_global_count > 0
&& !load_import_globals(&buf, buf_end, module, error_buf, && !load_import_globals(&buf, buf_end, module, is_load_from_file_buf,
error_buf_size)) error_buf, error_buf_size))
return false; return false;
*p_buf = buf; *p_buf = buf;
@ -1141,7 +1210,8 @@ destroy_import_funcs(AOTImportFunc *import_funcs, bool is_jit_mode)
static bool 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) bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size)
{ {
const char *module_name, *field_name; const char *module_name, *field_name;
const uint8 *buf = *p_buf; const uint8 *buf = *p_buf;
@ -1190,7 +1260,8 @@ fail:
static bool static bool
load_import_func_info(const uint8 **p_buf, const uint8 *buf_end, load_import_func_info(const uint8 **p_buf, const uint8 *buf_end,
AOTModule *module, char *error_buf, uint32 error_buf_size) AOTModule *module, bool is_load_from_file_buf,
char *error_buf, uint32 error_buf_size)
{ {
const uint8 *buf = *p_buf; const uint8 *buf = *p_buf;
@ -1198,7 +1269,8 @@ load_import_func_info(const uint8 **p_buf, const uint8 *buf_end,
/* load import funcs */ /* load import funcs */
if (module->import_func_count > 0 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, is_load_from_file_buf,
error_buf, error_buf_size))
return false; return false;
*p_buf = buf; *p_buf = buf;
@ -1221,8 +1293,8 @@ destroy_object_data_sections(AOTObjectDataSection *data_sections,
static bool static bool
load_object_data_sections(const uint8 **p_buf, const uint8 *buf_end, load_object_data_sections(const uint8 **p_buf, const uint8 *buf_end,
AOTModule *module, char *error_buf, AOTModule *module, bool is_load_from_file_buf,
uint32 error_buf_size) char *error_buf, uint32 error_buf_size)
{ {
const uint8 *buf = *p_buf; const uint8 *buf = *p_buf;
AOTObjectDataSection *data_sections; AOTObjectDataSection *data_sections;
@ -1280,8 +1352,8 @@ fail:
static bool static bool
load_object_data_sections_info(const uint8 **p_buf, const uint8 *buf_end, load_object_data_sections_info(const uint8 **p_buf, const uint8 *buf_end,
AOTModule *module, char *error_buf, AOTModule *module, bool is_load_from_file_buf,
uint32 error_buf_size) char *error_buf, uint32 error_buf_size)
{ {
const uint8 *buf = *p_buf; const uint8 *buf = *p_buf;
@ -1289,7 +1361,8 @@ load_object_data_sections_info(const uint8 **p_buf, const uint8 *buf_end,
/* load object data sections */ /* load object data sections */
if (module->data_section_count > 0 if (module->data_section_count > 0
&& !load_object_data_sections(&buf, buf_end, module, error_buf, && !load_object_data_sections(&buf, buf_end, module,
is_load_from_file_buf, error_buf,
error_buf_size)) error_buf_size))
return false; return false;
@ -1301,18 +1374,19 @@ fail:
static bool static bool
load_init_data_section(const uint8 *buf, const uint8 *buf_end, load_init_data_section(const uint8 *buf, const uint8 *buf_end,
AOTModule *module, char *error_buf, AOTModule *module, bool is_load_from_file_buf,
uint32 error_buf_size) char *error_buf, uint32 error_buf_size)
{ {
const uint8 *p = buf, *p_end = buf_end; const uint8 *p = buf, *p_end = buf_end;
if (!load_memory_info(&p, p_end, module, error_buf, error_buf_size) 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_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_func_type_info(&p, p_end, module, error_buf, error_buf_size)
|| !load_import_global_info(&p, p_end, module, error_buf, || !load_import_global_info(&p, p_end, module, is_load_from_file_buf,
error_buf_size) error_buf, error_buf_size)
|| !load_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)) || !load_import_func_info(&p, p_end, module, is_load_from_file_buf,
error_buf, error_buf_size))
return false; return false;
/* load function count and start function index */ /* load function count and start function index */
@ -1336,7 +1410,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_bottom);
read_uint32(p, p_end, module->aux_stack_size); read_uint32(p, p_end, module->aux_stack_size);
if (!load_object_data_sections_info(&p, p_end, module, error_buf, if (!load_object_data_sections_info(&p, p_end, module,
is_load_from_file_buf, error_buf,
error_buf_size)) error_buf_size))
return false; return false;
@ -1526,7 +1601,7 @@ destroy_exports(AOTExport *exports, bool is_jit_mode)
static bool static bool
load_exports(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module, load_exports(const uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
char *error_buf, uint32 error_buf_size) bool is_load_from_file_buf, char *error_buf, uint32 error_buf_size)
{ {
const uint8 *buf = *p_buf; const uint8 *buf = *p_buf;
AOTExport *exports; AOTExport *exports;
@ -1563,14 +1638,16 @@ fail:
static bool 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) bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size)
{ {
const uint8 *p = buf, *p_end = buf_end; const uint8 *p = buf, *p_end = buf_end;
/* load export functions */ /* load export functions */
read_uint32(p, p_end, module->export_count); read_uint32(p, p_end, module->export_count);
if (module->export_count > 0 if (module->export_count > 0
&& !load_exports(&p, p_end, module, error_buf, error_buf_size)) && !load_exports(&p, p_end, module, is_load_from_file_buf, error_buf,
error_buf_size))
return false; return false;
if (p != p_end) { if (p != p_end) {
@ -1903,8 +1980,8 @@ fail:
static bool static bool
load_relocation_section(const uint8 *buf, const uint8 *buf_end, load_relocation_section(const uint8 *buf, const uint8 *buf_end,
AOTModule *module, char *error_buf, AOTModule *module, bool is_load_from_file_buf,
uint32 error_buf_size) char *error_buf, uint32 error_buf_size)
{ {
AOTRelocationGroup *groups = NULL, *group; AOTRelocationGroup *groups = NULL, *group;
uint32 symbol_count = 0; uint32 symbol_count = 0;
@ -2048,7 +2125,6 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
for (i = 0, group = groups; i < group_count; i++, group++) { for (i = 0, group = groups; i < group_count; i++, group++) {
AOTRelocation *relocation; AOTRelocation *relocation;
uint32 name_index; uint32 name_index;
uint16 str_len;
uint8 *name_addr; uint8 *name_addr;
/* section name address is 4 bytes aligned. */ /* section name address is 4 bytes aligned. */
@ -2062,13 +2138,7 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
} }
name_addr = symbol_buf + symbol_offsets[name_index]; name_addr = symbol_buf + symbol_offsets[name_index];
str_len = *(uint16 *)name_addr; read_string(name_addr, buf_end, group->section_name);
if (!(group->section_name = const_str_set_insert(
name_addr + sizeof(uint16), (int32)str_len, module, error_buf,
error_buf_size))) {
goto fail;
}
read_uint32(buf, buf_end, group->relocation_count); read_uint32(buf, buf_end, group->relocation_count);
@ -2083,7 +2153,6 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
/* Load each relocation */ /* Load each relocation */
for (j = 0; j < group->relocation_count; j++, relocation++) { for (j = 0; j < group->relocation_count; j++, relocation++) {
uint32 symbol_index; uint32 symbol_index;
uint16 str_len;
uint8 *symbol_addr; uint8 *symbol_addr;
if (sizeof(void *) == 8) { if (sizeof(void *) == 8) {
@ -2107,13 +2176,7 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
} }
symbol_addr = symbol_buf + symbol_offsets[symbol_index]; symbol_addr = symbol_buf + symbol_offsets[symbol_index];
str_len = *(uint16 *)symbol_addr; read_string(symbol_addr, buf_end, relocation->symbol_name);
if (!(relocation->symbol_name = const_str_set_insert(
symbol_addr + sizeof(uint16), (int32)str_len, module,
error_buf, error_buf_size))) {
goto fail;
}
} }
if (!strcmp(group->section_name, ".rel.text") if (!strcmp(group->section_name, ".rel.text")
@ -2185,7 +2248,8 @@ fail:
} }
static bool static bool
load_from_sections(AOTModule *module, AOTSection *sections, char *error_buf, load_from_sections(AOTModule *module, AOTSection *sections,
bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size) uint32 error_buf_size)
{ {
AOTSection *section = sections; AOTSection *section = sections;
@ -2216,7 +2280,8 @@ load_from_sections(AOTModule *module, AOTSection *sections, char *error_buf,
return false; return false;
break; break;
case AOT_SECTION_TYPE_INIT_DATA: case AOT_SECTION_TYPE_INIT_DATA:
if (!load_init_data_section(buf, buf_end, module, error_buf, if (!load_init_data_section(buf, buf_end, module,
is_load_from_file_buf, error_buf,
error_buf_size)) error_buf_size))
return false; return false;
break; break;
@ -2231,17 +2296,20 @@ load_from_sections(AOTModule *module, AOTSection *sections, char *error_buf,
return false; return false;
break; break;
case AOT_SECTION_TYPE_EXPORT: case AOT_SECTION_TYPE_EXPORT:
if (!load_export_section(buf, buf_end, module, error_buf, if (!load_export_section(buf, buf_end, module,
is_load_from_file_buf, error_buf,
error_buf_size)) error_buf_size))
return false; return false;
break; break;
case AOT_SECTION_TYPE_RELOCATION: case AOT_SECTION_TYPE_RELOCATION:
if (!load_relocation_section(buf, buf_end, module, error_buf, if (!load_relocation_section(buf, buf_end, module,
is_load_from_file_buf, error_buf,
error_buf_size)) error_buf_size))
return false; return false;
break; break;
case AOT_SECTION_TYPE_CUSTOM: case AOT_SECTION_TYPE_CUSTOM:
if (!load_custom_section(buf, buf_end, module, error_buf, if (!load_custom_section(buf, buf_end, module,
is_load_from_file_buf, error_buf,
error_buf_size)) error_buf_size))
return false; return false;
break; break;
@ -2379,15 +2447,6 @@ create_module(char *error_buf, uint32 error_buf_size)
module->module_type = Wasm_Module_AoT; 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))) {
set_error_buf(error_buf, error_buf_size,
"create const string set failed");
wasm_runtime_free(module);
return NULL;
}
return module; return module;
} }
@ -2400,7 +2459,8 @@ aot_load_from_sections(AOTSection *section_list, char *error_buf,
if (!module) if (!module)
return NULL; return NULL;
if (!load_from_sections(module, section_list, error_buf, error_buf_size)) { if (!load_from_sections(module, section_list, false, error_buf,
error_buf_size)) {
aot_unload(module); aot_unload(module);
return NULL; return NULL;
} }
@ -2599,7 +2659,8 @@ load(const uint8 *buf, uint32 size, AOTModule *module, char *error_buf,
error_buf_size)) error_buf_size))
return false; return false;
ret = load_from_sections(module, section_list, error_buf, error_buf_size); ret = load_from_sections(module, section_list, true, error_buf,
error_buf_size);
if (!ret) { if (!ret) {
/* If load_from_sections() fails, then aot text is destroyed /* If load_from_sections() fails, then aot text is destroyed
in destroy_sections() */ in destroy_sections() */

202
core/iwasm/compilation/aot_emit_aot_file.c
View File

@ -177,10 +177,12 @@ get_file_header_size()
} }
static uint32 static uint32
get_string_size(const char *s) get_string_size(AOTCompContext *comp_ctx, const char *s)
{ {
/* string size (2 bytes) + string content without '\0' */ /* string size (2 bytes) + string content */
return (uint32)sizeof(uint16) + (uint32)strlen(s); return (uint32)sizeof(uint16) + (uint32)strlen(s) +
/* emit string with '\0' only in XIP mode */
(comp_ctx->is_indirect_mode ? 1 : 0);
} }
static uint32 static uint32
@ -388,18 +390,19 @@ get_func_type_info_size(AOTCompData *comp_data)
} }
static uint32 static uint32
get_import_global_size(AOTImportGlobal *import_global) get_import_global_size(AOTCompContext *comp_ctx, AOTImportGlobal *import_global)
{ {
/* type (1 byte) + is_mutable (1 byte) + module_name + global_name */ /* type (1 byte) + is_mutable (1 byte) + module_name + global_name */
uint32 size = uint32 size = (uint32)sizeof(uint8) * 2
(uint32)sizeof(uint8) * 2 + get_string_size(import_global->module_name); + get_string_size(comp_ctx, import_global->module_name);
size = align_uint(size, 2); size = align_uint(size, 2);
size += get_string_size(import_global->global_name); size += get_string_size(comp_ctx, import_global->global_name);
return size; return size;
} }
static uint32 static uint32
get_import_globals_size(AOTImportGlobal *import_globals, get_import_globals_size(AOTCompContext *comp_ctx,
AOTImportGlobal *import_globals,
uint32 import_global_count) uint32 import_global_count)
{ {
AOTImportGlobal *import_global = import_globals; AOTImportGlobal *import_global = import_globals;
@ -407,17 +410,17 @@ get_import_globals_size(AOTImportGlobal *import_globals,
for (i = 0; i < import_global_count; i++, import_global++) { for (i = 0; i < import_global_count; i++, import_global++) {
size = align_uint(size, 2); size = align_uint(size, 2);
size += get_import_global_size(import_global); size += get_import_global_size(comp_ctx, import_global);
} }
return size; return size;
} }
static uint32 static uint32
get_import_global_info_size(AOTCompData *comp_data) get_import_global_info_size(AOTCompContext *comp_ctx, AOTCompData *comp_data)
{ {
/* import global count + import globals */ /* import global count + import globals */
return (uint32)sizeof(uint32) return (uint32)sizeof(uint32)
+ get_import_globals_size(comp_data->import_globals, + get_import_globals_size(comp_ctx, comp_data->import_globals,
comp_data->import_global_count); comp_data->import_global_count);
} }
@ -456,40 +459,42 @@ get_global_info_size(AOTCompData *comp_data)
} }
static uint32 static uint32
get_import_func_size(AOTImportFunc *import_func) get_import_func_size(AOTCompContext *comp_ctx, AOTImportFunc *import_func)
{ {
/* type index (2 bytes) + module_name + func_name */ /* type index (2 bytes) + module_name + func_name */
uint32 size = uint32 size = (uint32)sizeof(uint16)
(uint32)sizeof(uint16) + get_string_size(import_func->module_name); + get_string_size(comp_ctx, import_func->module_name);
size = align_uint(size, 2); size = align_uint(size, 2);
size += get_string_size(import_func->func_name); size += get_string_size(comp_ctx, import_func->func_name);
return size; return size;
} }
static uint32 static uint32
get_import_funcs_size(AOTImportFunc *import_funcs, uint32 import_func_count) get_import_funcs_size(AOTCompContext *comp_ctx, AOTImportFunc *import_funcs,
uint32 import_func_count)
{ {
AOTImportFunc *import_func = import_funcs; AOTImportFunc *import_func = import_funcs;
uint32 size = 0, i; uint32 size = 0, i;
for (i = 0; i < import_func_count; i++, import_func++) { for (i = 0; i < import_func_count; i++, import_func++) {
size = align_uint(size, 2); size = align_uint(size, 2);
size += get_import_func_size(import_func); size += get_import_func_size(comp_ctx, import_func);
} }
return size; return size;
} }
static uint32 static uint32
get_import_func_info_size(AOTCompData *comp_data) get_import_func_info_size(AOTCompContext *comp_ctx, AOTCompData *comp_data)
{ {
/* import func count + import funcs */ /* import func count + import funcs */
return (uint32)sizeof(uint32) return (uint32)sizeof(uint32)
+ get_import_funcs_size(comp_data->import_funcs, + get_import_funcs_size(comp_ctx, comp_data->import_funcs,
comp_data->import_func_count); comp_data->import_func_count);
} }
static uint32 static uint32
get_object_data_sections_size(AOTObjectDataSection *data_sections, get_object_data_sections_size(AOTCompContext *comp_ctx,
AOTObjectDataSection *data_sections,
uint32 data_sections_count) uint32 data_sections_count)
{ {
AOTObjectDataSection *data_section = data_sections; AOTObjectDataSection *data_section = data_sections;
@ -498,7 +503,7 @@ get_object_data_sections_size(AOTObjectDataSection *data_sections,
for (i = 0; i < data_sections_count; i++, data_section++) { for (i = 0; i < data_sections_count; i++, data_section++) {
/* name + size + data */ /* name + size + data */
size = align_uint(size, 2); size = align_uint(size, 2);
size += get_string_size(data_section->name); size += get_string_size(comp_ctx, data_section->name);
size = align_uint(size, 4); size = align_uint(size, 4);
size += (uint32)sizeof(uint32); size += (uint32)sizeof(uint32);
size += data_section->size; size += data_section->size;
@ -507,16 +512,18 @@ get_object_data_sections_size(AOTObjectDataSection *data_sections,
} }
static uint32 static uint32
get_object_data_section_info_size(AOTObjectData *obj_data) get_object_data_section_info_size(AOTCompContext *comp_ctx,
AOTObjectData *obj_data)
{ {
/* data sections count + data sections */ /* data sections count + data sections */
return (uint32)sizeof(uint32) return (uint32)sizeof(uint32)
+ get_object_data_sections_size(obj_data->data_sections, + get_object_data_sections_size(comp_ctx, obj_data->data_sections,
obj_data->data_sections_count); obj_data->data_sections_count);
} }
static uint32 static uint32
get_init_data_section_size(AOTCompData *comp_data, AOTObjectData *obj_data) get_init_data_section_size(AOTCompContext *comp_ctx, AOTCompData *comp_data,
AOTObjectData *obj_data)
{ {
uint32 size = 0; uint32 size = 0;
@ -529,13 +536,13 @@ get_init_data_section_size(AOTCompData *comp_data, AOTObjectData *obj_data)
size += get_func_type_info_size(comp_data); size += get_func_type_info_size(comp_data);
size = align_uint(size, 4); size = align_uint(size, 4);
size += get_import_global_info_size(comp_data); size += get_import_global_info_size(comp_ctx, comp_data);
size = align_uint(size, 4); size = align_uint(size, 4);
size += get_global_info_size(comp_data); size += get_global_info_size(comp_data);
size = align_uint(size, 4); size = align_uint(size, 4);
size += get_import_func_info_size(comp_data); size += get_import_func_info_size(comp_ctx, comp_data);
/* func count + start func index */ /* func count + start func index */
size = align_uint(size, 4); size = align_uint(size, 4);
@ -544,7 +551,7 @@ get_init_data_section_size(AOTCompData *comp_data, AOTObjectData *obj_data)
/* aux data/heap/stack data */ /* aux data/heap/stack data */
size += sizeof(uint32) * 7; size += sizeof(uint32) * 7;
size += get_object_data_section_info_size(obj_data); size += get_object_data_section_info_size(comp_ctx, obj_data);
return size; return size;
} }
@ -571,32 +578,33 @@ get_func_section_size(AOTCompData *comp_data, AOTObjectData *obj_data)
} }
static uint32 static uint32
get_export_size(AOTExport *export) get_export_size(AOTCompContext *comp_ctx, AOTExport *export)
{ {
/* export index + export kind + 1 byte padding + export name */ /* export index + export kind + 1 byte padding + export name */
return (uint32)sizeof(uint32) + sizeof(uint8) + 1 return (uint32)sizeof(uint32) + sizeof(uint8) + 1
+ get_string_size(export->name); + get_string_size(comp_ctx, export->name);
} }
static uint32 static uint32
get_exports_size(AOTExport *exports, uint32 export_count) get_exports_size(AOTCompContext *comp_ctx, AOTExport *exports,
uint32 export_count)
{ {
AOTExport *export = exports; AOTExport *export = exports;
uint32 size = 0, i; uint32 size = 0, i;
for (i = 0; i < export_count; i++, export ++) { for (i = 0; i < export_count; i++, export ++) {
size = align_uint(size, 4); size = align_uint(size, 4);
size += get_export_size(export); size += get_export_size(comp_ctx, export);
} }
return size; return size;
} }
static uint32 static uint32
get_export_section_size(AOTCompData *comp_data) get_export_section_size(AOTCompContext *comp_ctx, AOTCompData *comp_data)
{ {
/* export count + exports */ /* export count + exports */
return (uint32)sizeof(uint32) return (uint32)sizeof(uint32)
+ get_exports_size(comp_data->wasm_module->exports, + get_exports_size(comp_ctx, comp_data->wasm_module->exports,
comp_data->wasm_module->export_count); comp_data->wasm_module->export_count);
} }
@ -700,7 +708,7 @@ get_relocation_symbol_index(const char *symbol_name, bool *is_new,
} }
static uint32 static uint32
get_relocation_symbol_size(AOTRelocation *relocation, get_relocation_symbol_size(AOTCompContext *comp_ctx, AOTRelocation *relocation,
AOTSymbolList *symbol_list) AOTSymbolList *symbol_list)
{ {
uint32 size = 0, index = 0; uint32 size = 0, index = 0;
@ -711,7 +719,7 @@ get_relocation_symbol_size(AOTRelocation *relocation,
CHECK_SIZE(index); CHECK_SIZE(index);
if (is_new) { if (is_new) {
size += get_string_size(relocation->symbol_name); size += get_string_size(comp_ctx, relocation->symbol_name);
size = align_uint(size, 2); size = align_uint(size, 2);
} }
@ -720,14 +728,16 @@ get_relocation_symbol_size(AOTRelocation *relocation,
} }
static uint32 static uint32
get_relocations_symbol_size(AOTRelocation *relocations, uint32 relocation_count, get_relocations_symbol_size(AOTCompContext *comp_ctx,
AOTRelocation *relocations, uint32 relocation_count,
AOTSymbolList *symbol_list) AOTSymbolList *symbol_list)
{ {
AOTRelocation *relocation = relocations; AOTRelocation *relocation = relocations;
uint32 size = 0, curr_size, i; uint32 size = 0, curr_size, i;
for (i = 0; i < relocation_count; i++, relocation++) { for (i = 0; i < relocation_count; i++, relocation++) {
curr_size = get_relocation_symbol_size(relocation, symbol_list); curr_size =
get_relocation_symbol_size(comp_ctx, relocation, symbol_list);
CHECK_SIZE(curr_size); CHECK_SIZE(curr_size);
size += curr_size; size += curr_size;
@ -736,7 +746,8 @@ get_relocations_symbol_size(AOTRelocation *relocations, uint32 relocation_count,
} }
static uint32 static uint32
get_relocation_group_symbol_size(AOTRelocationGroup *relocation_group, get_relocation_group_symbol_size(AOTCompContext *comp_ctx,
AOTRelocationGroup *relocation_group,
AOTSymbolList *symbol_list) AOTSymbolList *symbol_list)
{ {
uint32 size = 0, index = 0, curr_size; uint32 size = 0, index = 0, curr_size;
@ -747,15 +758,15 @@ get_relocation_group_symbol_size(AOTRelocationGroup *relocation_group,
CHECK_SIZE(index); CHECK_SIZE(index);
if (is_new) { if (is_new) {
size += get_string_size(relocation_group->section_name); size += get_string_size(comp_ctx, relocation_group->section_name);
size = align_uint(size, 2); size = align_uint(size, 2);
} }
relocation_group->name_index = index; relocation_group->name_index = index;
curr_size = get_relocations_symbol_size(relocation_group->relocations, curr_size = get_relocations_symbol_size(
relocation_group->relocation_count, comp_ctx, relocation_group->relocations,
symbol_list); relocation_group->relocation_count, symbol_list);
CHECK_SIZE(curr_size); CHECK_SIZE(curr_size);
size += curr_size; size += curr_size;
@ -763,7 +774,8 @@ get_relocation_group_symbol_size(AOTRelocationGroup *relocation_group,
} }
static uint32 static uint32
get_relocation_groups_symbol_size(AOTRelocationGroup *relocation_groups, get_relocation_groups_symbol_size(AOTCompContext *comp_ctx,
AOTRelocationGroup *relocation_groups,
uint32 relocation_group_count, uint32 relocation_group_count,
AOTSymbolList *symbol_list) AOTSymbolList *symbol_list)
{ {
@ -771,8 +783,8 @@ get_relocation_groups_symbol_size(AOTRelocationGroup *relocation_groups,
uint32 size = 0, curr_size, i; uint32 size = 0, curr_size, i;
for (i = 0; i < relocation_group_count; i++, relocation_group++) { for (i = 0; i < relocation_group_count; i++, relocation_group++) {
curr_size = curr_size = get_relocation_group_symbol_size(comp_ctx, relocation_group,
get_relocation_group_symbol_size(relocation_group, symbol_list); symbol_list);
CHECK_SIZE(curr_size); CHECK_SIZE(curr_size);
size += curr_size; size += curr_size;
} }
@ -780,7 +792,8 @@ get_relocation_groups_symbol_size(AOTRelocationGroup *relocation_groups,
} }
static uint32 static uint32
get_symbol_size_from_symbol_list(AOTSymbolList *symbol_list) get_symbol_size_from_symbol_list(AOTCompContext *comp_ctx,
AOTSymbolList *symbol_list)
{ {
AOTSymbolNode *sym; AOTSymbolNode *sym;
uint32 size = 0; uint32 size = 0;
@ -788,7 +801,7 @@ get_symbol_size_from_symbol_list(AOTSymbolList *symbol_list)
sym = symbol_list->head; sym = symbol_list->head;
while (sym) { while (sym) {
/* (uint16)str_len + str */ /* (uint16)str_len + str */
size += get_string_size(sym->symbol); size += get_string_size(comp_ctx, sym->symbol);
size = align_uint(size, 2); size = align_uint(size, 2);
sym = sym->next; sym = sym->next;
} }
@ -797,7 +810,8 @@ get_symbol_size_from_symbol_list(AOTSymbolList *symbol_list)
} }
static uint32 static uint32
get_relocation_section_symbol_size(AOTObjectData *obj_data) get_relocation_section_symbol_size(AOTCompContext *comp_ctx,
AOTObjectData *obj_data)
{ {
AOTRelocationGroup *relocation_groups = obj_data->relocation_groups; AOTRelocationGroup *relocation_groups = obj_data->relocation_groups;
uint32 relocation_group_count = obj_data->relocation_group_count; uint32 relocation_group_count = obj_data->relocation_group_count;
@ -807,11 +821,12 @@ get_relocation_section_symbol_size(AOTObjectData *obj_data)
get symbol size from symbol list directly in the second calculation */ get symbol size from symbol list directly in the second calculation */
if (obj_data->symbol_list.len > 0) { if (obj_data->symbol_list.len > 0) {
symbol_table_size = symbol_table_size =
get_symbol_size_from_symbol_list(&obj_data->symbol_list); get_symbol_size_from_symbol_list(comp_ctx, &obj_data->symbol_list);
} }
else { else {
symbol_table_size = get_relocation_groups_symbol_size( symbol_table_size = get_relocation_groups_symbol_size(
relocation_groups, relocation_group_count, &obj_data->symbol_list); comp_ctx, relocation_groups, relocation_group_count,
&obj_data->symbol_list);
} }
CHECK_SIZE(symbol_table_size); CHECK_SIZE(symbol_table_size);
string_count = obj_data->symbol_list.len; string_count = obj_data->symbol_list.len;
@ -823,13 +838,13 @@ get_relocation_section_symbol_size(AOTObjectData *obj_data)
} }
static uint32 static uint32
get_relocation_section_size(AOTObjectData *obj_data) get_relocation_section_size(AOTCompContext *comp_ctx, AOTObjectData *obj_data)
{ {
AOTRelocationGroup *relocation_groups = obj_data->relocation_groups; AOTRelocationGroup *relocation_groups = obj_data->relocation_groups;
uint32 relocation_group_count = obj_data->relocation_group_count; uint32 relocation_group_count = obj_data->relocation_group_count;
uint32 symbol_table_size = 0; uint32 symbol_table_size = 0;
symbol_table_size = get_relocation_section_symbol_size(obj_data); symbol_table_size = get_relocation_section_symbol_size(comp_ctx, obj_data);
CHECK_SIZE(symbol_table_size); CHECK_SIZE(symbol_table_size);
symbol_table_size = align_uint(symbol_table_size, 4); symbol_table_size = align_uint(symbol_table_size, 4);
@ -850,7 +865,7 @@ get_native_symbol_list_size(AOTCompContext *comp_ctx)
while (sym) { while (sym) {
len = align_uint(len, 2); len = align_uint(len, 2);
len += get_string_size(sym->symbol); len += get_string_size(comp_ctx, sym->symbol);
sym = bh_list_elem_next(sym); sym = bh_list_elem_next(sym);
} }
@ -879,7 +894,7 @@ get_aot_file_size(AOTCompContext *comp_ctx, AOTCompData *comp_data,
size = align_uint(size, 4); size = align_uint(size, 4);
/* section id + section size */ /* section id + section size */
size += (uint32)sizeof(uint32) * 2; size += (uint32)sizeof(uint32) * 2;
size += get_init_data_section_size(comp_data, obj_data); size += get_init_data_section_size(comp_ctx, comp_data, obj_data);
/* text section */ /* text section */
size = align_uint(size, 4); size = align_uint(size, 4);
@ -897,13 +912,13 @@ get_aot_file_size(AOTCompContext *comp_ctx, AOTCompData *comp_data,
size = align_uint(size, 4); size = align_uint(size, 4);
/* section id + section size */ /* section id + section size */
size += (uint32)sizeof(uint32) * 2; size += (uint32)sizeof(uint32) * 2;
size += get_export_section_size(comp_data); size += get_export_section_size(comp_ctx, comp_data);
/* relocation section */ /* relocation section */
size = align_uint(size, 4); size = align_uint(size, 4);
/* section id + section size */ /* section id + section size */
size += (uint32)sizeof(uint32) * 2; size += (uint32)sizeof(uint32) * 2;
size += get_relocation_section_size(obj_data); size += get_relocation_section_size(comp_ctx, obj_data);
if (get_native_symbol_list_size(comp_ctx) > 0) { if (get_native_symbol_list_size(comp_ctx) > 0) {
/* emit only when there are native symbols */ /* emit only when there are native symbols */
@ -1043,11 +1058,19 @@ static union {
offset += len; \ offset += len; \
} while (0) } while (0)
#define EMIT_STR(s) \ #define EMIT_STR(s) \
do { \ do { \
uint32 str_len = (uint32)strlen(s); \ uint32 str_len = (uint32)strlen(s); \
EMIT_U16(str_len); \ if (str_len > INT16_MAX) { \
EMIT_BUF(s, str_len); \ aot_set_last_error("emit string failed: " \
"string too long"); \
return false; \
} \
if (comp_ctx->is_indirect_mode) \
/* emit '\0' only in XIP mode */ \
str_len++; \
EMIT_U16(str_len); \
EMIT_BUF(s, str_len); \
} while (0) } while (0)
static bool static bool
@ -1359,7 +1382,8 @@ aot_emit_mem_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
static bool static bool
aot_emit_table_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset, aot_emit_table_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
AOTCompData *comp_data, AOTObjectData *obj_data) AOTCompContext *comp_ctx, AOTCompData *comp_data,
AOTObjectData *obj_data)
{ {
uint32 offset = *p_offset, i, j; uint32 offset = *p_offset, i, j;
AOTTableInitData **init_datas = comp_data->table_init_data_list; AOTTableInitData **init_datas = comp_data->table_init_data_list;
@ -1446,7 +1470,8 @@ aot_emit_func_type_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
static bool static bool
aot_emit_import_global_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset, aot_emit_import_global_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
AOTCompData *comp_data, AOTObjectData *obj_data) AOTCompContext *comp_ctx, AOTCompData *comp_data,
AOTObjectData *obj_data)
{ {
uint32 offset = *p_offset, i; uint32 offset = *p_offset, i;
AOTImportGlobal *import_global = comp_data->import_globals; AOTImportGlobal *import_global = comp_data->import_globals;
@ -1464,7 +1489,8 @@ aot_emit_import_global_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
EMIT_STR(import_global->global_name); EMIT_STR(import_global->global_name);
} }
if (offset - *p_offset != get_import_global_info_size(comp_data)) { if (offset - *p_offset
!= get_import_global_info_size(comp_ctx, comp_data)) {
aot_set_last_error("emit import global info failed."); aot_set_last_error("emit import global info failed.");
return false; return false;
} }
@ -1508,7 +1534,8 @@ aot_emit_global_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
static bool static bool
aot_emit_import_func_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset, aot_emit_import_func_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
AOTCompData *comp_data, AOTObjectData *obj_data) AOTCompContext *comp_ctx, AOTCompData *comp_data,
AOTObjectData *obj_data)
{ {
uint32 offset = *p_offset, i; uint32 offset = *p_offset, i;
AOTImportFunc *import_func = comp_data->import_funcs; AOTImportFunc *import_func = comp_data->import_funcs;
@ -1525,7 +1552,7 @@ aot_emit_import_func_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
EMIT_STR(import_func->func_name); EMIT_STR(import_func->func_name);
} }
if (offset - *p_offset != get_import_func_info_size(comp_data)) { if (offset - *p_offset != get_import_func_info_size(comp_ctx, comp_data)) {
aot_set_last_error("emit import function info failed."); aot_set_last_error("emit import function info failed.");
return false; return false;
} }
@ -1537,6 +1564,7 @@ aot_emit_import_func_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
static bool static bool
aot_emit_object_data_section_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset, aot_emit_object_data_section_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
AOTCompContext *comp_ctx,
AOTObjectData *obj_data) AOTObjectData *obj_data)
{ {
uint32 offset = *p_offset, i; uint32 offset = *p_offset, i;
@ -1554,7 +1582,8 @@ aot_emit_object_data_section_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
EMIT_BUF(data_section->data, data_section->size); EMIT_BUF(data_section->data, data_section->size);
} }
if (offset - *p_offset != get_object_data_section_info_size(obj_data)) { if (offset - *p_offset
!= get_object_data_section_info_size(comp_ctx, obj_data)) {
aot_set_last_error("emit object data section info failed."); aot_set_last_error("emit object data section info failed.");
return false; return false;
} }
@ -1569,7 +1598,8 @@ aot_emit_init_data_section(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
AOTCompContext *comp_ctx, AOTCompData *comp_data, AOTCompContext *comp_ctx, AOTCompData *comp_data,
AOTObjectData *obj_data) AOTObjectData *obj_data)
{ {
uint32 section_size = get_init_data_section_size(comp_data, obj_data); uint32 section_size =
get_init_data_section_size(comp_ctx, comp_data, obj_data);
uint32 offset = *p_offset; uint32 offset = *p_offset;
*p_offset = offset = align_uint(offset, 4); *p_offset = offset = align_uint(offset, 4);
@ -1578,13 +1608,14 @@ aot_emit_init_data_section(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
EMIT_U32(section_size); EMIT_U32(section_size);
if (!aot_emit_mem_info(buf, buf_end, &offset, comp_ctx, comp_data, obj_data) if (!aot_emit_mem_info(buf, buf_end, &offset, comp_ctx, comp_data, obj_data)
|| !aot_emit_table_info(buf, buf_end, &offset, comp_data, obj_data) || !aot_emit_table_info(buf, buf_end, &offset, comp_ctx, comp_data,
obj_data)
|| !aot_emit_func_type_info(buf, buf_end, &offset, comp_data, obj_data) || !aot_emit_func_type_info(buf, buf_end, &offset, comp_data, obj_data)
|| !aot_emit_import_global_info(buf, buf_end, &offset, comp_data, || !aot_emit_import_global_info(buf, buf_end, &offset, comp_ctx,
obj_data) comp_data, obj_data)
|| !aot_emit_global_info(buf, buf_end, &offset, comp_data, obj_data) || !aot_emit_global_info(buf, buf_end, &offset, comp_data, obj_data)
|| !aot_emit_import_func_info(buf, buf_end, &offset, comp_data, || !aot_emit_import_func_info(buf, buf_end, &offset, comp_ctx,
obj_data)) comp_data, obj_data))
return false; return false;
offset = align_uint(offset, 4); offset = align_uint(offset, 4);
@ -1599,7 +1630,8 @@ aot_emit_init_data_section(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
EMIT_U32(comp_data->aux_stack_bottom); EMIT_U32(comp_data->aux_stack_bottom);
EMIT_U32(comp_data->aux_stack_size); EMIT_U32(comp_data->aux_stack_size);
if (!aot_emit_object_data_section_info(buf, buf_end, &offset, obj_data)) if (!aot_emit_object_data_section_info(buf, buf_end, &offset, comp_ctx,
obj_data))
return false; return false;
if (offset - *p_offset != section_size + sizeof(uint32) * 2) { if (offset - *p_offset != section_size + sizeof(uint32) * 2) {
@ -1678,9 +1710,10 @@ aot_emit_func_section(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
static bool static bool
aot_emit_export_section(uint8 *buf, uint8 *buf_end, uint32 *p_offset, aot_emit_export_section(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
AOTCompData *comp_data, AOTObjectData *obj_data) AOTCompContext *comp_ctx, AOTCompData *comp_data,
AOTObjectData *obj_data)
{ {
uint32 section_size = get_export_section_size(comp_data); uint32 section_size = get_export_section_size(comp_ctx, comp_data);
AOTExport *export = comp_data->wasm_module->exports; AOTExport *export = comp_data->wasm_module->exports;
uint32 export_count = comp_data->wasm_module->export_count; uint32 export_count = comp_data->wasm_module->export_count;
uint32 i, offset = *p_offset; uint32 i, offset = *p_offset;
@ -1711,6 +1744,7 @@ aot_emit_export_section(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
static bool static bool
aot_emit_relocation_symbol_table(uint8 *buf, uint8 *buf_end, uint32 *p_offset, aot_emit_relocation_symbol_table(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
AOTCompContext *comp_ctx,
AOTCompData *comp_data, AOTCompData *comp_data,
AOTObjectData *obj_data) AOTObjectData *obj_data)
{ {
@ -1725,7 +1759,7 @@ aot_emit_relocation_symbol_table(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
while (sym) { while (sym) {
EMIT_U32(symbol_offset); EMIT_U32(symbol_offset);
/* string_len + str[0 .. string_len - 1] */ /* string_len + str[0 .. string_len - 1] */
symbol_offset += get_string_size(sym->symbol); symbol_offset += get_string_size(comp_ctx, sym->symbol);
symbol_offset = align_uint(symbol_offset, 2); symbol_offset = align_uint(symbol_offset, 2);
sym = sym->next; sym = sym->next;
} }
@ -1748,9 +1782,10 @@ aot_emit_relocation_symbol_table(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
static bool static bool
aot_emit_relocation_section(uint8 *buf, uint8 *buf_end, uint32 *p_offset, aot_emit_relocation_section(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
AOTCompData *comp_data, AOTObjectData *obj_data) AOTCompContext *comp_ctx, AOTCompData *comp_data,
AOTObjectData *obj_data)
{ {
uint32 section_size = get_relocation_section_size(obj_data); uint32 section_size = get_relocation_section_size(comp_ctx, obj_data);
uint32 i, offset = *p_offset; uint32 i, offset = *p_offset;
AOTRelocationGroup *relocation_group = obj_data->relocation_groups; AOTRelocationGroup *relocation_group = obj_data->relocation_groups;
@ -1762,7 +1797,7 @@ aot_emit_relocation_section(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
EMIT_U32(AOT_SECTION_TYPE_RELOCATION); EMIT_U32(AOT_SECTION_TYPE_RELOCATION);
EMIT_U32(section_size); EMIT_U32(section_size);
aot_emit_relocation_symbol_table(buf, buf_end, &offset, comp_data, aot_emit_relocation_symbol_table(buf, buf_end, &offset, comp_ctx, comp_data,
obj_data); obj_data);
offset = align_uint(offset, 4); offset = align_uint(offset, 4);
@ -2679,9 +2714,10 @@ aot_emit_aot_file_buf(AOTCompContext *comp_ctx, AOTCompData *comp_data,
comp_data, obj_data) comp_data, obj_data)
|| !aot_emit_text_section(buf, buf_end, &offset, comp_data, obj_data) || !aot_emit_text_section(buf, buf_end, &offset, comp_data, obj_data)
|| !aot_emit_func_section(buf, buf_end, &offset, comp_data, obj_data) || !aot_emit_func_section(buf, buf_end, &offset, comp_data, obj_data)
|| !aot_emit_export_section(buf, buf_end, &offset, comp_data, obj_data) || !aot_emit_export_section(buf, buf_end, &offset, comp_ctx, comp_data,
|| !aot_emit_relocation_section(buf, buf_end, &offset, comp_data, obj_data)
obj_data) || !aot_emit_relocation_section(buf, buf_end, &offset, comp_ctx,
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)) || !aot_emit_name_section(buf, buf_end, &offset, comp_data, comp_ctx))
goto fail2; goto fail2;

74
core/iwasm/interpreter/wasm_loader.c
View File

@ -351,7 +351,8 @@ check_utf8_str(const uint8 *str, uint32 len)
static char * static char *
const_str_list_insert(const uint8 *str, uint32 len, WASMModule *module, const_str_list_insert(const uint8 *str, uint32 len, WASMModule *module,
char *error_buf, uint32 error_buf_size) bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size)
{ {
StringNode *node, *node_next; StringNode *node, *node_next;
@ -360,6 +361,19 @@ const_str_list_insert(const uint8 *str, uint32 len, WASMModule *module,
return NULL; return NULL;
} }
if (len == 0) {
return "";
}
else if (is_load_from_file_buf) {
/* As the file buffer can be referred to after loading, we use
the previous byte of leb encoded size to adjust the string:
move string 1 byte backward and then append '\0' */
char *c_str = (char *)str - 1;
bh_memmove_s(c_str, len + 1, c_str + 1, len);
c_str[len] = '\0';
return c_str;
}
/* Search const str list */ /* Search const str list */
node = module->const_str_list; node = module->const_str_list;
while (node) { while (node) {
@ -1540,7 +1554,8 @@ fail:
static bool static bool
load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size) bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size)
{ {
const uint8 *p = buf, *p_end = buf_end, *p_old; const uint8 *p = buf, *p_end = buf_end, *p_old;
uint32 import_count, name_len, type_index, i, u32, flags; uint32 import_count, name_len, type_index, i, u32, flags;
@ -1551,16 +1566,6 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *sub_module_name, *field_name; char *sub_module_name, *field_name;
uint8 u8, kind; uint8 u8, kind;
/* insert builtin module names into const str list */
if (!const_str_list_insert((uint8 *)"env", 3, module, error_buf,
error_buf_size)
|| !const_str_list_insert((uint8 *)"wasi_unstable", 13, module,
error_buf, error_buf_size)
|| !const_str_list_insert((uint8 *)"wasi_snapshot_preview1", 22, module,
error_buf, error_buf_size)) {
return false;
}
read_leb_uint32(p, p_end, import_count); read_leb_uint32(p, p_end, import_count);
if (import_count) { if (import_count) {
@ -1665,7 +1670,8 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
read_leb_uint32(p, p_end, name_len); read_leb_uint32(p, p_end, name_len);
CHECK_BUF(p, p_end, name_len); CHECK_BUF(p, p_end, name_len);
if (!(sub_module_name = const_str_list_insert( if (!(sub_module_name = const_str_list_insert(
p, name_len, module, error_buf, error_buf_size))) { p, name_len, module, is_load_from_file_buf, error_buf,
error_buf_size))) {
return false; return false;
} }
p += name_len; p += name_len;
@ -1674,7 +1680,8 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
read_leb_uint32(p, p_end, name_len); read_leb_uint32(p, p_end, name_len);
CHECK_BUF(p, p_end, name_len); CHECK_BUF(p, p_end, name_len);
if (!(field_name = const_str_list_insert( if (!(field_name = const_str_list_insert(
p, name_len, module, error_buf, error_buf_size))) { p, name_len, module, is_load_from_file_buf, error_buf,
error_buf_size))) {
return false; return false;
} }
p += name_len; p += name_len;
@ -2142,7 +2149,8 @@ fail:
static bool static bool
load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size) bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size)
{ {
const uint8 *p = buf, *p_end = buf_end; const uint8 *p = buf, *p_end = buf_end;
uint32 export_count, i, j, index; uint32 export_count, i, j, index;
@ -2176,7 +2184,8 @@ load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
} }
if (!(export->name = const_str_list_insert( if (!(export->name = const_str_list_insert(
p, str_len, module, error_buf, error_buf_size))) { p, str_len, module, is_load_from_file_buf, error_buf,
error_buf_size))) {
return false; return false;
} }
@ -2722,7 +2731,8 @@ fail:
#if WASM_ENABLE_CUSTOM_NAME_SECTION != 0 #if WASM_ENABLE_CUSTOM_NAME_SECTION != 0
static bool static bool
handle_name_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, handle_name_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size) bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size)
{ {
const uint8 *p = buf, *p_end = buf_end; const uint8 *p = buf, *p_end = buf_end;
uint32 name_type, subsection_size; uint32 name_type, subsection_size;
@ -2786,9 +2796,10 @@ handle_name_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
return false; return false;
} }
if (!(module->functions[func_index]->field_name = if (!(module->functions[func_index]->field_name =
const_str_list_insert(p, func_name_len, const_str_list_insert(
module, error_buf, p, func_name_len, module,
error_buf_size))) { is_load_from_file_buf, error_buf,
error_buf_size))) {
return false; return false;
} }
} }
@ -2814,7 +2825,8 @@ fail:
static bool static bool
load_user_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, load_user_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size) bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size)
{ {
const uint8 *p = buf, *p_end = buf_end; const uint8 *p = buf, *p_end = buf_end;
uint32 name_len; uint32 name_len;
@ -2841,7 +2853,8 @@ load_user_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
module->name_section_buf = buf; module->name_section_buf = buf;
module->name_section_buf_end = buf_end; module->name_section_buf_end = buf_end;
p += name_len; p += name_len;
handle_name_section(p, p_end, module, error_buf, error_buf_size); handle_name_section(p, p_end, module, is_load_from_file_buf, error_buf,
error_buf_size);
} }
#endif #endif
LOG_VERBOSE("Load custom section success.\n"); LOG_VERBOSE("Load custom section success.\n");
@ -2863,7 +2876,8 @@ static void **handle_table;
#endif #endif
static bool static bool
load_from_sections(WASMModule *module, WASMSection *sections, char *error_buf, load_from_sections(WASMModule *module, WASMSection *sections,
bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size) uint32 error_buf_size)
{ {
WASMExport *export; WASMExport *export;
@ -2902,7 +2916,8 @@ load_from_sections(WASMModule *module, WASMSection *sections, char *error_buf,
switch (section->section_type) { switch (section->section_type) {
case SECTION_TYPE_USER: case SECTION_TYPE_USER:
/* unsupported user section, ignore it. */ /* unsupported user section, ignore it. */
if (!load_user_section(buf, buf_end, module, error_buf, if (!load_user_section(buf, buf_end, module,
is_load_from_file_buf, error_buf,
error_buf_size)) error_buf_size))
return false; return false;
break; break;
@ -2912,7 +2927,8 @@ load_from_sections(WASMModule *module, WASMSection *sections, char *error_buf,
return false; return false;
break; break;
case SECTION_TYPE_IMPORT: case SECTION_TYPE_IMPORT:
if (!load_import_section(buf, buf_end, module, error_buf, if (!load_import_section(buf, buf_end, module,
is_load_from_file_buf, error_buf,
error_buf_size)) error_buf_size))
return false; return false;
break; break;
@ -2937,7 +2953,8 @@ load_from_sections(WASMModule *module, WASMSection *sections, char *error_buf,
return false; return false;
break; break;
case SECTION_TYPE_EXPORT: case SECTION_TYPE_EXPORT:
if (!load_export_section(buf, buf_end, module, error_buf, if (!load_export_section(buf, buf_end, module,
is_load_from_file_buf, error_buf,
error_buf_size)) error_buf_size))
return false; return false;
break; break;
@ -3273,7 +3290,8 @@ wasm_loader_load_from_sections(WASMSection *section_list, char *error_buf,
if (!module) if (!module)
return NULL; return NULL;
if (!load_from_sections(module, section_list, error_buf, error_buf_size)) { if (!load_from_sections(module, section_list, false, error_buf,
error_buf_size)) {
wasm_loader_unload(module); wasm_loader_unload(module);
return NULL; return NULL;
} }
@ -3437,7 +3455,7 @@ load(const uint8 *buf, uint32 size, WASMModule *module, char *error_buf,
} }
if (!create_sections(buf, size, &section_list, error_buf, error_buf_size) if (!create_sections(buf, size, &section_list, error_buf, error_buf_size)
|| !load_from_sections(module, section_list, error_buf, || !load_from_sections(module, section_list, true, error_buf,
error_buf_size)) { error_buf_size)) {
destroy_sections(section_list); destroy_sections(section_list);
return false; return false;

76
core/iwasm/interpreter/wasm_mini_loader.c
View File

@ -170,10 +170,24 @@ loader_malloc(uint64 size, char *error_buf, uint32 error_buf_size)
static char * static char *
const_str_list_insert(const uint8 *str, uint32 len, WASMModule *module, const_str_list_insert(const uint8 *str, uint32 len, WASMModule *module,
char *error_buf, uint32 error_buf_size) bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size)
{ {
StringNode *node, *node_next; StringNode *node, *node_next;
if (len == 0) {
return "";
}
else if (is_load_from_file_buf) {
/* As the file buffer can be referred to after loading, we use
the previous byte of leb encoded size to adjust the string:
move string 1 byte backward and then append '\0' */
char *c_str = (char *)str - 1;
bh_memmove_s(c_str, len + 1, c_str + 1, len);
c_str[len] = '\0';
return c_str;
}
/* Search const str list */ /* Search const str list */
node = module->const_str_list; node = module->const_str_list;
while (node) { while (node) {
@ -640,7 +654,8 @@ load_memory(const uint8 **p_buf, const uint8 *buf_end, WASMMemory *memory,
static bool static bool
load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size) bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size)
{ {
const uint8 *p = buf, *p_end = buf_end, *p_old; const uint8 *p = buf, *p_end = buf_end, *p_old;
uint32 import_count, name_len, type_index, i, u32, flags; uint32 import_count, name_len, type_index, i, u32, flags;
@ -651,16 +666,6 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *sub_module_name, *field_name; char *sub_module_name, *field_name;
uint8 u8, kind; uint8 u8, kind;
/* insert builtin module names into const str list */
if (!const_str_list_insert((uint8 *)"env", 3, module, error_buf,
error_buf_size)
|| !const_str_list_insert((uint8 *)"wasi_unstable", 13, module,
error_buf, error_buf_size)
|| !const_str_list_insert((uint8 *)"wasi_snapshot_preview1", 22, module,
error_buf, error_buf_size)) {
return false;
}
read_leb_uint32(p, p_end, import_count); read_leb_uint32(p, p_end, import_count);
if (import_count) { if (import_count) {
@ -757,7 +762,8 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
read_leb_uint32(p, p_end, name_len); read_leb_uint32(p, p_end, name_len);
CHECK_BUF(p, p_end, name_len); CHECK_BUF(p, p_end, name_len);
if (!(sub_module_name = const_str_list_insert( if (!(sub_module_name = const_str_list_insert(
p, name_len, module, error_buf, error_buf_size))) { p, name_len, module, is_load_from_file_buf, error_buf,
error_buf_size))) {
return false; return false;
} }
p += name_len; p += name_len;
@ -766,7 +772,8 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
read_leb_uint32(p, p_end, name_len); read_leb_uint32(p, p_end, name_len);
CHECK_BUF(p, p_end, name_len); CHECK_BUF(p, p_end, name_len);
if (!(field_name = const_str_list_insert( if (!(field_name = const_str_list_insert(
p, name_len, module, error_buf, error_buf_size))) { p, name_len, module, is_load_from_file_buf, error_buf,
error_buf_size))) {
return false; return false;
} }
p += name_len; p += name_len;
@ -1146,7 +1153,8 @@ load_global_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
static bool static bool
load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size) bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size)
{ {
const uint8 *p = buf, *p_end = buf_end; const uint8 *p = buf, *p_end = buf_end;
uint32 export_count, i, j, index; uint32 export_count, i, j, index;
@ -1177,7 +1185,8 @@ load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
} }
if (!(export->name = const_str_list_insert( if (!(export->name = const_str_list_insert(
p, str_len, module, error_buf, error_buf_size))) { p, str_len, module, is_load_from_file_buf, error_buf,
error_buf_size))) {
return false; return false;
} }
@ -1648,7 +1657,8 @@ load_start_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
#if WASM_ENABLE_CUSTOM_NAME_SECTION != 0 #if WASM_ENABLE_CUSTOM_NAME_SECTION != 0
static bool static bool
handle_name_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, handle_name_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size) bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size)
{ {
const uint8 *p = buf, *p_end = buf_end; const uint8 *p = buf, *p_end = buf_end;
uint32 name_type, subsection_size; uint32 name_type, subsection_size;
@ -1686,9 +1696,10 @@ handle_name_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
func_index -= module->import_count; func_index -= module->import_count;
bh_assert(func_index < module->function_count); bh_assert(func_index < module->function_count);
if (!(module->functions[func_index]->field_name = if (!(module->functions[func_index]->field_name =
const_str_list_insert(p, func_name_len, const_str_list_insert(
module, error_buf, p, func_name_len, module,
error_buf_size))) { is_load_from_file_buf, error_buf,
error_buf_size))) {
return false; return false;
} }
} }
@ -1707,14 +1718,13 @@ handle_name_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
} }
return true; return true;
fail:
return false;
} }
#endif #endif
static bool static bool
load_user_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module, load_user_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size) bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size)
{ {
const uint8 *p = buf, *p_end = buf_end; const uint8 *p = buf, *p_end = buf_end;
uint32 name_len; uint32 name_len;
@ -1728,7 +1738,8 @@ load_user_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
#if WASM_ENABLE_CUSTOM_NAME_SECTION != 0 #if WASM_ENABLE_CUSTOM_NAME_SECTION != 0
if (memcmp(p, "name", 4) == 0) { if (memcmp(p, "name", 4) == 0) {
p += name_len; p += name_len;
handle_name_section(p, p_end, module, error_buf, error_buf_size); handle_name_section(p, p_end, module, is_load_from_file_buf, error_buf,
error_buf_size);
} }
#endif #endif
LOG_VERBOSE("Load custom section success.\n"); LOG_VERBOSE("Load custom section success.\n");
@ -1785,7 +1796,8 @@ static void **handle_table;
#endif #endif
static bool static bool
load_from_sections(WASMModule *module, WASMSection *sections, char *error_buf, load_from_sections(WASMModule *module, WASMSection *sections,
bool is_load_from_file_buf, char *error_buf,
uint32 error_buf_size) uint32 error_buf_size)
{ {
WASMExport *export; WASMExport *export;
@ -1821,7 +1833,8 @@ load_from_sections(WASMModule *module, WASMSection *sections, char *error_buf,
switch (section->section_type) { switch (section->section_type) {
case SECTION_TYPE_USER: case SECTION_TYPE_USER:
/* unsupported user section, ignore it. */ /* unsupported user section, ignore it. */
if (!load_user_section(buf, buf_end, module, error_buf, if (!load_user_section(buf, buf_end, module,
is_load_from_file_buf, error_buf,
error_buf_size)) error_buf_size))
return false; return false;
break; break;
@ -1831,7 +1844,8 @@ load_from_sections(WASMModule *module, WASMSection *sections, char *error_buf,
return false; return false;
break; break;
case SECTION_TYPE_IMPORT: case SECTION_TYPE_IMPORT:
if (!load_import_section(buf, buf_end, module, error_buf, if (!load_import_section(buf, buf_end, module,
is_load_from_file_buf, error_buf,
error_buf_size)) error_buf_size))
return false; return false;
break; break;
@ -1856,7 +1870,8 @@ load_from_sections(WASMModule *module, WASMSection *sections, char *error_buf,
return false; return false;
break; break;
case SECTION_TYPE_EXPORT: case SECTION_TYPE_EXPORT:
if (!load_export_section(buf, buf_end, module, error_buf, if (!load_export_section(buf, buf_end, module,
is_load_from_file_buf, error_buf,
error_buf_size)) error_buf_size))
return false; return false;
break; break;
@ -2174,7 +2189,8 @@ wasm_loader_load_from_sections(WASMSection *section_list, char *error_buf,
if (!module) if (!module)
return NULL; return NULL;
if (!load_from_sections(module, section_list, error_buf, error_buf_size)) { if (!load_from_sections(module, section_list, false, error_buf,
error_buf_size)) {
wasm_loader_unload(module); wasm_loader_unload(module);
return NULL; return NULL;
} }
@ -2329,7 +2345,7 @@ load(const uint8 *buf, uint32 size, WASMModule *module, char *error_buf,
} }
if (!create_sections(buf, size, &section_list, error_buf, error_buf_size) if (!create_sections(buf, size, &section_list, error_buf, error_buf_size)
|| !load_from_sections(module, section_list, error_buf, || !load_from_sections(module, section_list, true, error_buf,
error_buf_size)) { error_buf_size)) {
destroy_sections(section_list); destroy_sections(section_list);
return false; return false;