CloudEdge/wasm-micro-runtime
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
This repository has been archived on 2023-11-05. You can view files and clone it, but cannot push or open issues or pull requests.
ee315e4049
wasm-micro-runtime/core/iwasm/interpreter/wasm_mini_loader.c

4958 lines
172 KiB
C
Raw Normal View History

Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "wasm_loader.h"
#include "bh_common.h"
#include "bh_log.h"
#include "wasm.h"
#include "wasm_opcode.h"
#include "wasm_runtime.h"
#include "../common/wasm_native.h"
/* Read a value of given type from the address pointed to by the given
pointer and increase the pointer to the position just after the
value being read. */
#define TEMPLATE_READ_VALUE(Type, p) \
(p += sizeof(Type), *(Type *)(p - sizeof(Type)))
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, "%s", string);
}
#define CHECK_BUF(buf, buf_end, length) do { \
bh_assert(buf + length <= buf_end); \
} while (0)
#define CHECK_BUF1(buf, buf_end, length) do { \
bh_assert(buf + length <= buf_end); \
} while (0)
static void
skip_leb(const uint8 **p_buf, const uint8 *buf_end, uint32 maxbits,
char* error_buf, uint32 error_buf_size)
{
const uint8 *buf = *p_buf;
uint32 offset = 0, bcnt = 0;
uint64 byte;
while (true) {
bh_assert(bcnt + 1 <= (maxbits + 6) / 7);
CHECK_BUF(buf, buf_end, offset + 1);
byte = buf[offset];
offset += 1;
bcnt += 1;
if ((byte & 0x80) == 0) {
break;
}
}
*p_buf += offset;
}
#define skip_leb_int64(p, p_end) do { \
skip_leb(&p, p_end, 64, \
error_buf, error_buf_size); \
} while (0)
#define skip_leb_uint32(p, p_end) do { \
skip_leb(&p, p_end, 32, \
error_buf, error_buf_size); \
} while (0)
#define skip_leb_int32(p, p_end) do { \
skip_leb(&p, p_end, 32, \
error_buf, error_buf_size); \
} while (0)
static void
read_leb(uint8 **p_buf, const uint8 *buf_end,
uint32 maxbits, bool sign, uint64 *p_result,
char* error_buf, uint32 error_buf_size)
{
const uint8 *buf = *p_buf;
uint64 result = 0;
uint32 shift = 0;
uint32 offset = 0, bcnt = 0;
uint64 byte;
while (true) {
bh_assert(bcnt + 1 <= (maxbits + 6) / 7);
CHECK_BUF(buf, buf_end, offset + 1);
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 */
bh_assert(!(((uint8)byte) & 0xf0));
}
else if (sign && maxbits == 32) {
if (shift < maxbits) {
/* Sign extend */
result = (((int32)result) << (maxbits - shift))
>> (maxbits - 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;
bh_assert(!((sign_bit_set && top_bits != 0x70)
|| (!sign_bit_set && top_bits != 0)));
(void)top_bits;
(void)sign_bit_set;
}
}
else if (sign && maxbits == 64) {
if (shift < maxbits) {
/* Sign extend */
result = (((int64)result) << (maxbits - shift))
>> (maxbits - 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;
bh_assert(!((sign_bit_set && top_bits != 0x7e)
|| (!sign_bit_set && top_bits != 0)));
(void)top_bits;
(void)sign_bit_set;
}
}
*p_buf += offset;
*p_result = result;
}
#define read_uint8(p) TEMPLATE_READ_VALUE(uint8, p)
#define read_uint32(p) TEMPLATE_READ_VALUE(uint32, p)
#define read_bool(p) TEMPLATE_READ_VALUE(bool, p)
#define read_leb_int64(p, p_end, res) do { \
uint64 res64; \
read_leb((uint8**)&p, p_end, 64, true, &res64, \
error_buf, error_buf_size); \
res = (int64)res64; \
} while (0)
#define read_leb_uint32(p, p_end, res) do { \
uint64 res64; \
read_leb((uint8**)&p, p_end, 32, false, &res64, \
error_buf, error_buf_size); \
res = (uint32)res64; \
} while (0)
#define read_leb_int32(p, p_end, res) do { \
uint64 res64; \
read_leb((uint8**)&p, p_end, 32, true, &res64, \
error_buf, error_buf_size); \
res = (int32)res64; \
} while (0)
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,
"WASM module load failed: "
"allocate memory failed.");
return NULL;
}
memset(mem, 0, (uint32)size);
return mem;
}
static char *
const_str_list_insert(const uint8 *str, uint32 len, WASMModule *module,
char *error_buf, uint32 error_buf_size)
{
StringNode *node, *node_next;
/* Search const str list */
node = module->const_str_list;
while (node) {
node_next = node->next;
if (strlen(node->str) == len
&& !memcmp(node->str, str, len))
break;
node = node_next;
}
if (node) {
LOG_DEBUG("reuse %s", node->str);
return node->str;
}
if (!(node = loader_malloc(sizeof(StringNode) + len + 1,
error_buf, error_buf_size))) {
return NULL;
}
node->str = ((char*)node) + sizeof(StringNode);
bh_memcpy_s(node->str, len + 1, str, len);
node->str[len] = '\0';
if (!module->const_str_list) {
/* set as head */
module->const_str_list = node;
node->next = NULL;
}
else {
/* insert it */
node->next = module->const_str_list;
module->const_str_list = node;
}
return node->str;
}
static bool
load_init_expr(const uint8 **p_buf, const uint8 *buf_end,
InitializerExpression *init_expr, uint8 type,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = *p_buf, *p_end = buf_end;
uint8 flag, end_byte, *p_float;
uint32 i;
CHECK_BUF(p, p_end, 1);
init_expr->init_expr_type = read_uint8(p);
flag = init_expr->init_expr_type;
switch (flag) {
/* i32.const */
case INIT_EXPR_TYPE_I32_CONST:
bh_assert(type == VALUE_TYPE_I32);
read_leb_int32(p, p_end, init_expr->u.i32);
break;
/* i64.const */
case INIT_EXPR_TYPE_I64_CONST:
bh_assert(type == VALUE_TYPE_I64);
read_leb_int64(p, p_end, init_expr->u.i64);
break;
/* f32.const */
case INIT_EXPR_TYPE_F32_CONST:
bh_assert(type == VALUE_TYPE_F32);
CHECK_BUF(p, p_end, 4);
p_float = (uint8*)&init_expr->u.f32;
for (i = 0; i < sizeof(float32); i++)
*p_float++ = *p++;
break;
/* f64.const */
case INIT_EXPR_TYPE_F64_CONST:
bh_assert(type == VALUE_TYPE_F64);
CHECK_BUF(p, p_end, 8);
p_float = (uint8*)&init_expr->u.f64;
for (i = 0; i < sizeof(float64); i++)
*p_float++ = *p++;
break;
/* get_global */
case INIT_EXPR_TYPE_GET_GLOBAL:
read_leb_uint32(p, p_end, init_expr->u.global_index);
break;
default:
bh_assert(0);
break;
}
CHECK_BUF(p, p_end, 1);
end_byte = read_uint8(p);
bh_assert(end_byte == 0x0b);
*p_buf = p;
(void)end_byte;
return true;
}
static bool
load_type_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = buf, *p_end = buf_end, *p_org;
uint32 type_count, param_count, result_count, i, j;
uint64 total_size;
uint8 flag;
WASMType *type;
read_leb_uint32(p, p_end, type_count);
if (type_count) {
module->type_count = type_count;
total_size = sizeof(WASMType*) * (uint64)type_count;
if (!(module->types = loader_malloc
(total_size, error_buf, error_buf_size))) {
return false;
}
for (i = 0; i < type_count; i++) {
CHECK_BUF(p, p_end, 1);
flag = read_uint8(p);
bh_assert(flag == 0x60);
read_leb_uint32(p, p_end, param_count);
/* Resolve param count and result count firstly */
p_org = p;
CHECK_BUF(p, p_end, param_count);
p += param_count;
read_leb_uint32(p, p_end, result_count);
bh_assert(result_count <= 1);
CHECK_BUF(p, p_end, result_count);
p = p_org;
total_size = offsetof(WASMType, types) +
sizeof(uint8) * (uint64)(param_count + result_count);
if (!(type = module->types[i] =
loader_malloc(total_size, error_buf, error_buf_size))) {
return false;
}
/* Resolve param types and result types */
type->param_count = param_count;
type->result_count = result_count;
for (j = 0; j < param_count; j++) {
CHECK_BUF(p, p_end, 1);
type->types[j] = read_uint8(p);
}
read_leb_uint32(p, p_end, result_count);
for (j = 0; j < result_count; j++) {
CHECK_BUF(p, p_end, 1);
type->types[param_count + j] = read_uint8(p);
}
}
}
bh_assert(p == p_end);
LOG_VERBOSE("Load type section success.\n");
(void)flag;
return true;
}
static bool
load_function_import(const WASMModule *parent_module, WASMModule *sub_module,
char *sub_module_name, char *function_name,
const uint8 **p_buf, const uint8 *buf_end,
WASMFunctionImport *function,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = *p_buf, *p_end = buf_end;
uint32 declare_type_index = 0;
WASMType *declare_func_type = NULL;
WASMFunction *linked_func = NULL;
const char *linked_signature = NULL;
void *linked_attachment = NULL;
bool linked_call_conv_raw = false;
bool is_built_in_module = false;
CHECK_BUF(p, p_end, 1);
read_leb_uint32(p, p_end, declare_type_index);
*p_buf = p;
bh_assert(declare_type_index < parent_module->type_count);
declare_func_type = parent_module->types[declare_type_index];
is_built_in_module = wasm_runtime_is_built_in_module(sub_module_name);
if (is_built_in_module) {
LOG_DEBUG("%s is a function of a built-in module %s",
function_name,
sub_module_name);
/* check built-in modules */
linked_func = wasm_native_resolve_symbol(sub_module_name,
function_name,
declare_func_type,
&linked_signature,
&linked_attachment,
&linked_call_conv_raw);
}
if (!linked_func) {
#if WASM_ENABLE_SPEC_TEST != 0
set_error_buf(error_buf,
error_buf_size,
"unknown import or incompatible import type");
return false;
#else
#if WASM_ENABLE_WAMR_COMPILER == 0
LOG_WARNING(
"warning: fail to link import function (%s, %s)",
sub_module_name, function_name);
#endif
#endif
}
function->module_name = sub_module_name;
function->field_name = function_name;
function->func_type = declare_func_type;
/* func_ptr_linked is for built-in functions */
function->func_ptr_linked = is_built_in_module ? linked_func : NULL;
function->signature = linked_signature;
function->attachment = linked_attachment;
function->call_conv_raw = linked_call_conv_raw;
return true;
}
static bool
load_table_import(WASMModule *sub_module, const char *sub_module_name,
const char *table_name, const uint8 **p_buf,
const uint8 *buf_end, WASMTableImport *table,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = *p_buf, *p_end = buf_end;
uint32 declare_elem_type = 0;
uint32 declare_max_size_flag = 0;
uint32 declare_init_size = 0;
uint32 declare_max_size = 0;
CHECK_BUF(p, p_end, 1);
/* 0x70 */
declare_elem_type = read_uint8(p);
bh_assert(TABLE_ELEM_TYPE_ANY_FUNC == declare_elem_type);
read_leb_uint32(p, p_end, declare_max_size_flag);
read_leb_uint32(p, p_end, declare_init_size);
if (declare_max_size_flag & 1) {
read_leb_uint32(p, p_end, declare_max_size);
bh_assert(table->init_size <= table->max_size);
} else {
declare_max_size = 0x10000;
}
*p_buf = p;
bh_assert(!((declare_max_size_flag & 1)
&& declare_init_size > declare_max_size));
/* now we believe all declaration are ok */
table->elem_type = declare_elem_type;
table->init_size = declare_init_size;
table->flags = declare_max_size_flag;
table->max_size = declare_max_size;
return true;
}
unsigned
wasm_runtime_memory_pool_size();
static bool
load_memory_import(WASMModule *sub_module, const char *sub_module_name,
const char *memory_name, const uint8 **p_buf,
const uint8 *buf_end, WASMMemoryImport *memory,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = *p_buf, *p_end = buf_end;
uint32 pool_size = wasm_runtime_memory_pool_size();
#if WASM_ENABLE_APP_FRAMEWORK != 0
uint32 max_page_count = pool_size * APP_MEMORY_MAX_GLOBAL_HEAP_PERCENT
/ DEFAULT_NUM_BYTES_PER_PAGE;
#else
uint32 max_page_count = pool_size / DEFAULT_NUM_BYTES_PER_PAGE;
#endif /* WASM_ENABLE_APP_FRAMEWORK */
uint32 declare_max_page_count_flag = 0;
uint32 declare_init_page_count = 0;
uint32 declare_max_page_count = 0;
read_leb_uint32(p, p_end, declare_max_page_count_flag);
read_leb_uint32(p, p_end, declare_init_page_count);
bh_assert(declare_init_page_count <= 65536);
if (declare_max_page_count_flag & 1) {
read_leb_uint32(p, p_end, declare_max_page_count);
bh_assert(declare_init_page_count <= declare_max_page_count);
bh_assert(declare_max_page_count <= 65536);
if (declare_max_page_count > max_page_count) {
declare_max_page_count = max_page_count;
}
}
else {
/* Limit the maximum memory size to max_page_count */
declare_max_page_count = max_page_count;
}
/* now we believe all declaration are ok */
memory->flags = declare_max_page_count_flag;
memory->init_page_count = declare_init_page_count;
memory->max_page_count = declare_max_page_count;
memory->num_bytes_per_page = DEFAULT_NUM_BYTES_PER_PAGE;
*p_buf = p;
return true;
}
static bool
load_global_import(const WASMModule *parent_module,
WASMModule *sub_module,
char *sub_module_name, char *global_name,
const uint8 **p_buf, const uint8 *buf_end,
WASMGlobalImport *global,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = *p_buf, *p_end = buf_end;
uint8 declare_type = 0;
uint8 declare_mutable = 0;
bool is_mutable = false;
bool ret = false;
CHECK_BUF(p, p_end, 2);
declare_type = read_uint8(p);
declare_mutable = read_uint8(p);
*p_buf = p;
bh_assert(declare_mutable < 2);
is_mutable = declare_mutable & 1 ? true : false;
#if WASM_ENABLE_LIBC_BUILTIN != 0
ret = wasm_runtime_is_built_in_module(sub_module_name);
if (ret) {
/* check built-in modules */
ret = wasm_native_lookup_libc_builtin_global(sub_module_name,
global_name, global);
if (ret) {
LOG_DEBUG("(%s, %s) is a global of a built-in module",
sub_module_name, global_name);
}
}
#endif /* WASM_ENABLE_LIBC_BUILTIN */
if (!ret) {
set_error_buf_v(error_buf, error_buf_size,
"unknown import or incompatible import type");
return false;
}
global->module_name = sub_module_name;
global->field_name = global_name;
global->type = declare_type;
global->is_mutable = is_mutable;
(void)p_end;
return true;
}
static bool
load_table(const uint8 **p_buf, const uint8 *buf_end, WASMTable *table,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = *p_buf, *p_end = buf_end;
CHECK_BUF(p, p_end, 1);
/* 0x70 */
table->elem_type = read_uint8(p);
bh_assert(TABLE_ELEM_TYPE_ANY_FUNC == table->elem_type);
read_leb_uint32(p, p_end, table->flags);
read_leb_uint32(p, p_end, table->init_size);
if (table->flags & 1) {
read_leb_uint32(p, p_end, table->max_size);
bh_assert(table->init_size <= table->max_size);
}
else
table->max_size = 0x10000;
bh_assert(!((table->flags & 1)
&& table->init_size > table->max_size));
*p_buf = p;
return true;
}
static bool
load_memory(const uint8 **p_buf, const uint8 *buf_end, WASMMemory *memory,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = *p_buf, *p_end = buf_end;
uint32 pool_size = wasm_runtime_memory_pool_size();
#if WASM_ENABLE_APP_FRAMEWORK != 0
uint32 max_page_count = pool_size * APP_MEMORY_MAX_GLOBAL_HEAP_PERCENT
/ DEFAULT_NUM_BYTES_PER_PAGE;
#else
uint32 max_page_count = pool_size / DEFAULT_NUM_BYTES_PER_PAGE;
#endif
read_leb_uint32(p, p_end, memory->flags);
read_leb_uint32(p, p_end, memory->init_page_count);
bh_assert(memory->init_page_count <= 65536);
if (memory->flags & 1) {
read_leb_uint32(p, p_end, memory->max_page_count);
bh_assert(memory->init_page_count <= memory->max_page_count);
bh_assert(memory->max_page_count <= 65536);
if (memory->max_page_count > max_page_count)
memory->max_page_count = max_page_count;
}
else
/* Limit the maximum memory size to max_page_count */
memory->max_page_count = max_page_count;
memory->num_bytes_per_page = DEFAULT_NUM_BYTES_PER_PAGE;
*p_buf = p;
return true;
}
static bool
load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = buf, *p_end = buf_end, *p_old;
uint32 import_count, name_len, type_index, i, u32, flags;
uint64 total_size;
WASMImport *import;
WASMImport *import_functions = NULL, *import_tables = NULL;
WASMImport *import_memories = NULL, *import_globals = NULL;
char *sub_module_name, *field_name;
uint8 u8, kind;
read_leb_uint32(p, p_end, import_count);
if (import_count) {
module->import_count = import_count;
total_size = sizeof(WASMImport) * (uint64)import_count;
if (!(module->imports = loader_malloc
(total_size, error_buf, error_buf_size))) {
return false;
}
p_old = p;
/* Scan firstly to get import count of each type */
for (i = 0; i < import_count; i++) {
/* module name */
read_leb_uint32(p, p_end, name_len);
CHECK_BUF(p, p_end, name_len);
p += name_len;
/* field name */
read_leb_uint32(p, p_end, name_len);
CHECK_BUF(p, p_end, name_len);
p += name_len;
CHECK_BUF(p, p_end, 1);
/* 0x00/0x01/0x02/0x03 */
kind = read_uint8(p);
switch (kind) {
case IMPORT_KIND_FUNC: /* import function */
read_leb_uint32(p, p_end, type_index);
module->import_function_count++;
break;
case IMPORT_KIND_TABLE: /* import table */
CHECK_BUF(p, p_end, 1);
/* 0x70 */
u8 = read_uint8(p);
read_leb_uint32(p, p_end, flags);
read_leb_uint32(p, p_end, u32);
if (flags & 1)
read_leb_uint32(p, p_end, u32);
module->import_table_count++;
bh_assert(module->import_table_count <= 1);
break;
case IMPORT_KIND_MEMORY: /* import memory */
read_leb_uint32(p, p_end, flags);
read_leb_uint32(p, p_end, u32);
if (flags & 1)
read_leb_uint32(p, p_end, u32);
module->import_memory_count++;
bh_assert(module->import_memory_count <= 1);
break;
case IMPORT_KIND_GLOBAL: /* import global */
CHECK_BUF(p, p_end, 2);
p += 2;
module->import_global_count++;
break;
default:
bh_assert(0);
break;
}
}
if (module->import_function_count)
import_functions = module->import_functions = module->imports;
if (module->import_table_count)
import_tables = module->import_tables =
module->imports + module->import_function_count;
if (module->import_memory_count)
import_memories = module->import_memories =
module->imports + module->import_function_count + module->import_table_count;
if (module->import_global_count)
import_globals = module->import_globals =
module->imports + module->import_function_count + module->import_table_count
+ module->import_memory_count;
p = p_old;
// TODO: move it out of the loop
/* insert "env", "wasi_unstable" and "wasi_snapshot_preview1" to 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;
}
/* Scan again to read the data */
for (i = 0; i < import_count; i++) {
WASMModule *sub_module = NULL;
/* load module name */
read_leb_uint32(p, p_end, name_len);
CHECK_BUF(p, p_end, name_len);
if (!(sub_module_name = const_str_list_insert(
p, name_len, module, error_buf, error_buf_size))) {
return false;
}
p += name_len;
/* load field name */
read_leb_uint32(p, p_end, name_len);
CHECK_BUF(p, p_end, name_len);
if (!(field_name = const_str_list_insert(
p, name_len, module, error_buf, error_buf_size))) {
return false;
}
p += name_len;
LOG_DEBUG("import #%d: (%s, %s)", i, sub_module_name, field_name);
CHECK_BUF(p, p_end, 1);
/* 0x00/0x01/0x02/0x03 */
kind = read_uint8(p);
switch (kind) {
case IMPORT_KIND_FUNC: /* import function */
bh_assert(import_functions);
import = import_functions++;
if (!load_function_import(module, sub_module,
sub_module_name, field_name, &p,
p_end, &import->u.function,
error_buf, error_buf_size)) {
return false;
}
break;
case IMPORT_KIND_TABLE: /* import table */
bh_assert(import_tables);
import = import_tables++;
if (!load_table_import(sub_module,
sub_module_name,
field_name,
&p,
p_end,
&import->u.table,
error_buf,
error_buf_size)) {
LOG_DEBUG("can not import such a table (%s,%s)",
sub_module_name, field_name);
return false;
}
break;
case IMPORT_KIND_MEMORY: /* import memory */
bh_assert(import_memories);
import = import_memories++;
if (!load_memory_import(sub_module,
sub_module_name,
field_name,
&p,
p_end,
&import->u.memory,
error_buf,
error_buf_size)) {
return false;
}
break;
case IMPORT_KIND_GLOBAL: /* import global */
bh_assert(import_globals);
import = import_globals++;
if (!load_global_import(module,
sub_module,
sub_module_name, field_name, &p,
p_end, &import->u.global,
error_buf, error_buf_size)) {
return false;
}
break;
default:
bh_assert(0);
import = NULL;
break;
}
import->kind = kind;
import->u.names.module_name = sub_module_name;
import->u.names.field_name = field_name;
(void)sub_module;
}
#if WASM_ENABLE_LIBC_WASI != 0
import = module->import_functions;
for (i = 0; i < module->import_function_count; i++, import++) {
if (!strcmp(import->u.names.module_name, "wasi_unstable")
|| !strcmp(import->u.names.module_name, "wasi_snapshot_preview1")) {
module->is_wasi_module = true;
break;
}
}
#endif
}
bh_assert(p == p_end);
LOG_VERBOSE("Load import section success.\n");
(void)u8;
(void)u32;
(void)type_index;
return true;
}
static bool
init_function_local_offsets(WASMFunction *func,
char *error_buf, uint32 error_buf_size)
{
WASMType *param_type = func->func_type;
uint32 param_count = param_type->param_count;
uint8 *param_types = param_type->types;
uint32 local_count = func->local_count;
uint8 *local_types = func->local_types;
uint32 i, local_offset = 0;
uint64 total_size = sizeof(uint16) * ((uint64)param_count + local_count);
if (!(func->local_offsets =
loader_malloc(total_size, error_buf, error_buf_size))) {
return false;
}
for (i = 0; i < param_count; i++) {
func->local_offsets[i] = (uint16)local_offset;
local_offset += wasm_value_type_cell_num(param_types[i]);
}
for (i = 0; i < local_count; i++) {
func->local_offsets[param_count + i] = (uint16)local_offset;
local_offset += wasm_value_type_cell_num(local_types[i]);
}
bh_assert(local_offset == func->param_cell_num + func->local_cell_num);
return true;
}
static bool
load_function_section(const uint8 *buf, const uint8 *buf_end,
const uint8 *buf_code, const uint8 *buf_code_end,
WASMModule *module,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = buf, *p_end = buf_end;
const uint8 *p_code = buf_code, *p_code_end, *p_code_save;
uint32 func_count;
uint64 total_size;
uint32 code_count = 0, code_size, type_index, i, j, k, local_type_index;
uint32 local_count, local_set_count, sub_local_count;
uint8 type;
WASMFunction *func;
read_leb_uint32(p, p_end, func_count);
if (buf_code)
read_leb_uint32(p_code, buf_code_end, code_count);
bh_assert(func_count == code_count);
if (func_count) {
module->function_count = func_count;
total_size = sizeof(WASMFunction*) * (uint64)func_count;
if (!(module->functions =
loader_malloc(total_size, error_buf, error_buf_size))) {
return false;
}
for (i = 0; i < func_count; i++) {
/* Resolve function type */
read_leb_uint32(p, p_end, type_index);
bh_assert(type_index < module->type_count);
read_leb_uint32(p_code, buf_code_end, code_size);
bh_assert(code_size > 0
&& p_code + code_size <= buf_code_end);
/* Resolve local set count */
p_code_end = p_code + code_size;
local_count = 0;
read_leb_uint32(p_code, buf_code_end, local_set_count);
p_code_save = p_code;
/* Calculate total local count */
for (j = 0; j < local_set_count; j++) {
read_leb_uint32(p_code, buf_code_end, sub_local_count);
bh_assert(sub_local_count <= UINT32_MAX - local_count);
CHECK_BUF(p_code, buf_code_end, 1);
/* 0x7F/0x7E/0x7D/0x7C */
type = read_uint8(p_code);
local_count += sub_local_count;
}
/* Alloc memory, layout: function structure + local types */
code_size = (uint32)(p_code_end - p_code);
total_size = sizeof(WASMFunction) + (uint64)local_count;
if (!(func = module->functions[i] =
loader_malloc(total_size, error_buf, error_buf_size))) {
return false;
}
/* Set function type, local count, code size and code body */
func->func_type = module->types[type_index];
func->local_count = local_count;
if (local_count > 0)
func->local_types = (uint8*)func + sizeof(WASMFunction);
func->code_size = code_size;
/*
* we shall make a copy of code body [p_code, p_code + code_size]
* when we are worrying about inappropriate releasing behaviour.
* all code bodies are actually in a buffer which user allocates in
* his embedding environment and we don't have power on them.
* it will be like:
* code_body_cp = malloc(code_size);
* memcpy(code_body_cp, p_code, code_size);
* func->code = code_body_cp;
*/
func->code = (uint8*)p_code;
/* Load each local type */
p_code = p_code_save;
local_type_index = 0;
for (j = 0; j < local_set_count; j++) {
read_leb_uint32(p_code, buf_code_end, sub_local_count);
bh_assert(!(local_type_index + sub_local_count <= local_type_index
|| local_type_index + sub_local_count > local_count));
CHECK_BUF(p_code, buf_code_end, 1);
/* 0x7F/0x7E/0x7D/0x7C */
type = read_uint8(p_code);
bh_assert(type >= VALUE_TYPE_F64 && type <= VALUE_TYPE_I32);
for (k = 0; k < sub_local_count; k++) {
func->local_types[local_type_index++] = type;
}
}
func->param_cell_num = wasm_type_param_cell_num(func->func_type);
func->ret_cell_num = wasm_type_return_cell_num(func->func_type);
func->local_cell_num =
wasm_get_cell_num(func->local_types, func->local_count);
if (!init_function_local_offsets(func, error_buf, error_buf_size))
return false;
p_code = p_code_end;
}
}
bh_assert(p == p_end);
LOG_VERBOSE("Load function section success.\n");
(void)code_count;
return true;
}
static bool
load_table_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = buf, *p_end = buf_end;
uint32 table_count, i;
uint64 total_size;
WASMTable *table;
read_leb_uint32(p, p_end, table_count);
bh_assert(module->import_table_count + table_count <= 1);
if (table_count) {
module->table_count = table_count;
total_size = sizeof(WASMTable) * (uint64)table_count;
if (!(module->tables = loader_malloc
(total_size, error_buf, error_buf_size))) {
return false;
}
/* load each table */
table = module->tables;
for (i = 0; i < table_count; i++, table++)
if (!load_table(&p, p_end, table, error_buf, error_buf_size))
return false;
}
bh_assert(p == p_end);
LOG_VERBOSE("Load table section success.\n");
return true;
}
static bool
load_memory_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = buf, *p_end = buf_end;
uint32 memory_count, i;
uint64 total_size;
WASMMemory *memory;
read_leb_uint32(p, p_end, memory_count);
bh_assert(module->import_memory_count + memory_count <= 1);
if (memory_count) {
module->memory_count = memory_count;
total_size = sizeof(WASMMemory) * (uint64)memory_count;
if (!(module->memories = loader_malloc
(total_size, error_buf, error_buf_size))) {
return false;
}
/* load each memory */
memory = module->memories;
for (i = 0; i < memory_count; i++, memory++)
if (!load_memory(&p, p_end, memory, error_buf, error_buf_size))
return false;
}
bh_assert(p == p_end);
LOG_VERBOSE("Load memory section success.\n");
return true;
}
static bool
load_global_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = buf, *p_end = buf_end;
uint32 global_count, i;
uint64 total_size;
WASMGlobal *global;
uint8 mutable;
read_leb_uint32(p, p_end, global_count);
if (global_count) {
module->global_count = global_count;
total_size = sizeof(WASMGlobal) * (uint64)global_count;
if (!(module->globals = loader_malloc
(total_size, error_buf, error_buf_size))) {
return false;
}
global = module->globals;
for(i = 0; i < global_count; i++, global++) {
CHECK_BUF(p, p_end, 2);
global->type = read_uint8(p);
mutable = read_uint8(p);
bh_assert(mutable < 2);
global->is_mutable = mutable ? true : false;
/* initialize expression */
if (!load_init_expr(&p, p_end, &(global->init_expr),
global->type, error_buf, error_buf_size))
return false;
if (INIT_EXPR_TYPE_GET_GLOBAL == global->init_expr.init_expr_type) {
/**
* Currently, constant expressions occurring as initializers
* of globals are further constrained in that contained
* global.get instructions are
* only allowed to refer to imported globals.
*/
uint32 target_global_index = global->init_expr.u.global_index;
bh_assert(target_global_index < module->import_global_count);
(void)target_global_index;
}
}
}
bh_assert(p == p_end);
LOG_VERBOSE("Load global section success.\n");
return true;
}
static bool
load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = buf, *p_end = buf_end;
uint32 export_count, i, j, index;
uint64 total_size;
uint32 str_len;
WASMExport *export;
const char *name;
read_leb_uint32(p, p_end, export_count);
if (export_count) {
module->export_count = export_count;
total_size = sizeof(WASMExport) * (uint64)export_count;
if (!(module->exports = loader_malloc
(total_size, error_buf, error_buf_size))) {
return false;
}
export = module->exports;
for (i = 0; i < export_count; i++, export++) {
read_leb_uint32(p, p_end, str_len);
CHECK_BUF(p, p_end, str_len);
for (j = 0; j < i; j++) {
name = module->exports[j].name;
bh_assert(!(strlen(name) == str_len
&& memcmp(name, p, str_len) == 0));
}
if (!(export->name = const_str_list_insert(p, str_len, module,
error_buf, error_buf_size))) {
return false;
}
p += str_len;
CHECK_BUF(p, p_end, 1);
export->kind = read_uint8(p);
read_leb_uint32(p, p_end, index);
export->index = index;
switch(export->kind) {
/*function index*/
case EXPORT_KIND_FUNC:
bh_assert(index < module->function_count
+ module->import_function_count);
break;
/*table index*/
case EXPORT_KIND_TABLE:
bh_assert(index < module->table_count
+ module->import_table_count);
break;
/*memory index*/
case EXPORT_KIND_MEMORY:
bh_assert(index < module->memory_count
+ module->import_memory_count);
break;
/*global index*/
case EXPORT_KIND_GLOBAL:
bh_assert(index < module->global_count
+ module->import_global_count);
break;
default:
bh_assert(0);
break;
}
}
}
bh_assert(p == p_end);
LOG_VERBOSE("Load export section success.\n");
(void)name;
return true;
}
static bool
load_table_segment_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = buf, *p_end = buf_end;
uint32 table_segment_count, i, j, table_index, function_count, function_index;
uint64 total_size;
WASMTableSeg *table_segment;
read_leb_uint32(p, p_end, table_segment_count);
if (table_segment_count) {
module->table_seg_count = table_segment_count;
total_size = sizeof(WASMTableSeg) * (uint64)table_segment_count;
if (!(module->table_segments = loader_malloc
(total_size, error_buf, error_buf_size))) {
return false;
}
table_segment = module->table_segments;
for (i = 0; i < table_segment_count; i++, table_segment++) {
bh_assert(p < p_end);
read_leb_uint32(p, p_end, table_index);
bh_assert(table_index < module->import_table_count
+ module->table_count);
table_segment->table_index = table_index;
/* initialize expression */
if (!load_init_expr(&p, p_end, &(table_segment->base_offset),
VALUE_TYPE_I32, error_buf, error_buf_size))
return false;
read_leb_uint32(p, p_end, function_count);
table_segment->function_count = function_count;
total_size = sizeof(uint32) * (uint64)function_count;
if (!(table_segment->func_indexes = (uint32 *)
loader_malloc(total_size, error_buf, error_buf_size))) {
return false;
}
for (j = 0; j < function_count; j++) {
read_leb_uint32(p, p_end, function_index);
Fix app manager parse applet name issue (#280)
2020-06-11 14:19:55 +08:00
bh_assert(function_index < module->import_function_count
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
+ module->function_count);
table_segment->func_indexes[j] = function_index;
}
}
}
bh_assert(p == p_end);
LOG_VERBOSE("Load table segment section success.\n");
return true;
}
static bool
load_data_segment_section(const uint8 *buf, const uint8 *buf_end,
WASMModule *module,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = buf, *p_end = buf_end;
uint32 data_seg_count, i, mem_index, data_seg_len;
uint64 total_size;
WASMDataSeg *dataseg;
InitializerExpression init_expr;
#if WASM_ENABLE_BULK_MEMORY != 0
bool is_passive = false;
uint32 mem_flag;
#endif
read_leb_uint32(p, p_end, data_seg_count);
#if WASM_ENABLE_BULK_MEMORY != 0
bh_assert(module->data_seg_count1 == 0
|| data_seg_count == module->data_seg_count1);
#endif
if (data_seg_count) {
module->data_seg_count = data_seg_count;
total_size = sizeof(WASMDataSeg*) * (uint64)data_seg_count;
if (!(module->data_segments = loader_malloc
(total_size, error_buf, error_buf_size))) {
return false;
}
for (i = 0; i < data_seg_count; i++) {
read_leb_uint32(p, p_end, mem_index);
#if WASM_ENABLE_BULK_MEMORY != 0
is_passive = false;
mem_flag = mem_index & 0x03;
switch (mem_flag) {
case 0x01:
is_passive = true;
break;
case 0x00:
/* no memory index, treat index as 0 */
mem_index = 0;
goto check_mem_index;
case 0x02:
/* read following memory index */
read_leb_uint32(p, p_end, mem_index);
check_mem_index:
bh_assert(mem_index < module->import_memory_count
+ module->memory_count);
break;
case 0x03:
default:
bh_assert(0);
break;
}
#else
bh_assert(mem_index < module->import_memory_count
+ module->memory_count);
#endif /* WASM_ENABLE_BULK_MEMORY */
#if WASM_ENABLE_BULK_MEMORY != 0
if (!is_passive)
#endif
if (!load_init_expr(&p, p_end, &init_expr, VALUE_TYPE_I32,
error_buf, error_buf_size))
return false;
read_leb_uint32(p, p_end, data_seg_len);
if (!(dataseg = module->data_segments[i] = loader_malloc
(sizeof(WASMDataSeg), error_buf, error_buf_size))) {
return false;
}
#if WASM_ENABLE_BULK_MEMORY != 0
dataseg->is_passive = is_passive;
if (!is_passive)
#endif
{
bh_memcpy_s(&dataseg->base_offset, sizeof(InitializerExpression),
&init_expr, sizeof(InitializerExpression));
dataseg->memory_index = mem_index;
}
dataseg->data_length = data_seg_len;
CHECK_BUF(p, p_end, data_seg_len);
dataseg->data = (uint8*)p;
p += data_seg_len;
}
}
bh_assert(p == p_end);
LOG_VERBOSE("Load data segment section success.\n");
return true;
}
#if WASM_ENABLE_BULK_MEMORY != 0
static bool
load_datacount_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = buf, *p_end = buf_end;
uint32 data_seg_count1 = 0;
read_leb_uint32(p, p_end, data_seg_count1);
module->data_seg_count1 = data_seg_count1;
bh_assert(p == p_end);
LOG_VERBOSE("Load datacount section success.\n");
return true;
}
#endif
static bool
load_code_section(const uint8 *buf, const uint8 *buf_end,
const uint8 *buf_func,
const uint8 *buf_func_end,
WASMModule *module,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = buf, *p_end = buf_end;
const uint8 *p_func = buf_func;
uint32 func_count = 0, code_count;
/* code has been loaded in function section, so pass it here, just check
* whether function and code section have inconsistent lengths */
read_leb_uint32(p, p_end, code_count);
if (buf_func)
read_leb_uint32(p_func, buf_func_end, func_count);
bh_assert(func_count == code_count);
LOG_VERBOSE("Load code segment section success.\n");
(void)code_count;
(void)func_count;
return true;
}
static bool
load_start_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = buf, *p_end = buf_end;
WASMType *type;
uint32 start_function;
read_leb_uint32(p, p_end, start_function);
bh_assert(start_function < module->function_count
+ module->import_function_count);
if (start_function < module->import_function_count)
type = module->import_functions[start_function].u.function.func_type;
else
type = module->functions[start_function - module->import_function_count]
->func_type;
bh_assert(type->param_count == 0 && type->result_count == 0);
module->start_function = start_function;
bh_assert(p == p_end);
LOG_VERBOSE("Load start section success.\n");
(void)type;
return true;
}
static bool
load_user_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
char *error_buf, uint32 error_buf_size)
{
const uint8 *p = buf, *p_end = buf_end;
uint32 name_len;
bh_assert(p < p_end);
read_leb_uint32(p, p_end, name_len);
bh_assert(name_len > 0
&& p + name_len <= p_end);
LOG_VERBOSE("Load custom section success.\n");
(void)name_len;
return true;
}
static bool
wasm_loader_prepare_bytecode(WASMModule *module, WASMFunction *func,
BlockAddr *block_addr_cache,
char *error_buf, uint32 error_buf_size);
#if WASM_ENABLE_FAST_INTERP != 0
void **
wasm_interp_get_handle_table();
static void **handle_table;
#endif
static bool
load_from_sections(WASMModule *module, WASMSection *sections,
char *error_buf, uint32 error_buf_size)
{
WASMExport *export;
WASMSection *section = sections;
const uint8 *buf, *buf_end, *buf_code = NULL, *buf_code_end = NULL,
*buf_func = NULL, *buf_func_end = NULL;
WASMGlobal *llvm_data_end_global = NULL, *llvm_heap_base_global = NULL;
WASMGlobal *llvm_stack_top_global = NULL, *global;
uint32 llvm_data_end = UINT32_MAX, llvm_heap_base = UINT32_MAX;
uint32 llvm_stack_top = UINT32_MAX, global_index, i;
uint32 data_end_global_index = UINT32_MAX;
uint32 heap_base_global_index = UINT32_MAX;
uint32 stack_top_global_index = UINT32_MAX;
BlockAddr *block_addr_cache;
uint64 total_size;
/* Find code and function sections if have */
while (section) {
if (section->section_type == SECTION_TYPE_CODE) {
buf_code = section->section_body;
buf_code_end = buf_code + section->section_body_size;
}
else if (section->section_type == SECTION_TYPE_FUNC) {
buf_func = section->section_body;
buf_func_end = buf_func + section->section_body_size;
}
section = section->next;
}
section = sections;
while (section) {
buf = section->section_body;
buf_end = buf + section->section_body_size;
LOG_DEBUG("to section %d", section->section_type);
switch (section->section_type) {
case SECTION_TYPE_USER:
/* unsupported user section, ignore it. */
if (!load_user_section(buf, buf_end, module, error_buf, error_buf_size))
return false;
break;
case SECTION_TYPE_TYPE:
if (!load_type_section(buf, buf_end, module, error_buf, error_buf_size))
return false;
break;
case SECTION_TYPE_IMPORT:
if (!load_import_section(buf, buf_end, module, error_buf, error_buf_size))
return false;
break;
case SECTION_TYPE_FUNC:
if (!load_function_section(buf, buf_end, buf_code, buf_code_end,
module, error_buf, error_buf_size))
return false;
break;
case SECTION_TYPE_TABLE:
if (!load_table_section(buf, buf_end, module, error_buf, error_buf_size))
return false;
break;
case SECTION_TYPE_MEMORY:
if (!load_memory_section(buf, buf_end, module, error_buf, error_buf_size))
return false;
break;
case SECTION_TYPE_GLOBAL:
if (!load_global_section(buf, buf_end, module, error_buf, error_buf_size))
return false;
break;
case SECTION_TYPE_EXPORT:
if (!load_export_section(buf, buf_end, module, error_buf, error_buf_size))
return false;
break;
case SECTION_TYPE_START:
if (!load_start_section(buf, buf_end, module, error_buf, error_buf_size))
return false;
break;
case SECTION_TYPE_ELEM:
if (!load_table_segment_section(buf, buf_end, module, error_buf, error_buf_size))
return false;
break;
case SECTION_TYPE_CODE:
if (!load_code_section(buf, buf_end, buf_func, buf_func_end,
module, error_buf, error_buf_size))
return false;
break;
case SECTION_TYPE_DATA:
if (!load_data_segment_section(buf, buf_end, module, error_buf, error_buf_size))
return false;
break;
#if WASM_ENABLE_BULK_MEMORY != 0
case SECTION_TYPE_DATACOUNT:
if (!load_datacount_section(buf, buf_end, module, error_buf, error_buf_size))
return false;
break;
#endif
default:
set_error_buf(error_buf, error_buf_size,
"WASM module load failed: invalid section id");
return false;
}
section = section->next;
}
#if WASM_ENABLE_FAST_INTERP != 0
handle_table = wasm_interp_get_handle_table();
#endif
total_size = sizeof(BlockAddr) * (uint64)BLOCK_ADDR_CACHE_SIZE * BLOCK_ADDR_CONFLICT_SIZE;
if (!(block_addr_cache = loader_malloc
(total_size, error_buf, error_buf_size))) {
return false;
}
for (i = 0; i < module->function_count; i++) {
WASMFunction *func = module->functions[i];
memset(block_addr_cache, 0, (uint32)total_size);
if (!wasm_loader_prepare_bytecode(module, func, block_addr_cache,
error_buf, error_buf_size)) {
wasm_runtime_free(block_addr_cache);
return false;
}
}
wasm_runtime_free(block_addr_cache);
/* Resolve llvm auxiliary data/stack/heap info and reset memory info */
Enable shared memory && add pthread support (#282)
2020-06-15 19:04:04 +08:00
export = module->exports;
for (i = 0; i < module->export_count; i++, export++) {
if (export->kind == EXPORT_KIND_GLOBAL) {
if (!strcmp(export->name, "__heap_base")) {
global_index = export->index - module->import_global_count;
global = module->globals + global_index;
if (global->type == VALUE_TYPE_I32
&& !global->is_mutable
&& global->init_expr.init_expr_type ==
INIT_EXPR_TYPE_I32_CONST) {
heap_base_global_index = global_index;
llvm_heap_base_global = global;
llvm_heap_base = global->init_expr.u.i32;
LOG_VERBOSE("found llvm __heap_base global, value: %d\n",
llvm_heap_base);
}
}
else if (!strcmp(export->name, "__data_end")) {
global_index = export->index - module->import_global_count;
global = module->globals + global_index;
if (global->type == VALUE_TYPE_I32
&& !global->is_mutable
&& global->init_expr.init_expr_type ==
INIT_EXPR_TYPE_I32_CONST) {
data_end_global_index = global_index;
llvm_data_end_global = global;
llvm_data_end = global->init_expr.u.i32;
LOG_VERBOSE("found llvm __data_end global, value: %d\n",
llvm_data_end);
llvm_data_end = align_uint(llvm_data_end, 16);
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
}
Enable shared memory && add pthread support (#282)
2020-06-15 19:04:04 +08:00
}
if (llvm_data_end_global && llvm_heap_base_global) {
if ((data_end_global_index == heap_base_global_index + 1
&& (int32)data_end_global_index > 1)
|| (heap_base_global_index == data_end_global_index + 1
&& (int32)heap_base_global_index > 1)) {
global_index =
data_end_global_index < heap_base_global_index
? data_end_global_index - 1 : heap_base_global_index - 1;
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
global = module->globals + global_index;
if (global->type == VALUE_TYPE_I32
Enable shared memory && add pthread support (#282)
2020-06-15 19:04:04 +08:00
&& global->is_mutable
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
&& global->init_expr.init_expr_type ==
Enable shared memory && add pthread support (#282)
2020-06-15 19:04:04 +08:00
INIT_EXPR_TYPE_I32_CONST) {
llvm_stack_top_global = global;
llvm_stack_top = global->init_expr.u.i32;
stack_top_global_index = global_index;
LOG_VERBOSE("found llvm stack top global, "
"value: %d, global index: %d\n",
llvm_stack_top, global_index);
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
}
}
Enable shared memory && add pthread support (#282)
2020-06-15 19:04:04 +08:00
module->llvm_aux_data_end = llvm_data_end;
module->llvm_aux_stack_bottom = llvm_stack_top;
module->llvm_aux_stack_size = llvm_stack_top > llvm_data_end
? llvm_stack_top - llvm_data_end
: llvm_stack_top;
module->llvm_aux_stack_global_index = stack_top_global_index;
LOG_VERBOSE("aux stack bottom: %d, size: %d\n",
module->llvm_aux_stack_bottom,
module->llvm_aux_stack_size);
break;
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
}
}
Enable shared memory && add pthread support (#282)
2020-06-15 19:04:04 +08:00
}
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
Enable shared memory && add pthread support (#282)
2020-06-15 19:04:04 +08:00
if (!module->possible_memory_grow) {
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
if (llvm_data_end_global
&& llvm_heap_base_global
&& llvm_stack_top_global
&& llvm_stack_top <= llvm_heap_base) {
WASMMemoryImport *memory_import;
WASMMemory *memory;
uint64 init_memory_size;
uint32 shrunk_memory_size = llvm_heap_base > llvm_data_end
? llvm_heap_base : llvm_data_end;
if (module->import_memory_count) {
memory_import = &module->import_memories[0].u.memory;
init_memory_size = (uint64)memory_import->num_bytes_per_page *
memory_import->init_page_count;
if (llvm_heap_base <= init_memory_size
&& llvm_data_end <= init_memory_size) {
/* Reset memory info to decrease memory usage */
memory_import->num_bytes_per_page = shrunk_memory_size;
memory_import->init_page_count = 1;
LOG_VERBOSE("reset import memory size to %d\n",
shrunk_memory_size);
}
}
if (module->memory_count) {
memory = &module->memories[0];
init_memory_size = (uint64)memory->num_bytes_per_page *
memory->init_page_count;
if (llvm_heap_base <= init_memory_size
&& llvm_data_end <= init_memory_size) {
/* Reset memory info to decrease memory usage */
memory->num_bytes_per_page = shrunk_memory_size;
memory->init_page_count = 1;
LOG_VERBOSE("reset memory size to %d\n", shrunk_memory_size);
}
}
}
}
return true;
}
#if BH_ENABLE_MEMORY_PROFILING != 0
static void wasm_loader_free(void *ptr)
{
wasm_runtime_free(ptr);
}
#else
#define wasm_loader_free wasm_free
#endif
static WASMModule*
create_module(char *error_buf, uint32 error_buf_size)
{
WASMModule *module = loader_malloc(sizeof(WASMModule),
error_buf, error_buf_size);
if (!module) {
return NULL;
}
module->module_type = Wasm_Module_Bytecode;
/* Set start_function to -1, means no start function */
module->start_function = (uint32)-1;
#if WASM_ENABLE_MULTI_MODULE != 0
module->import_module_list = &module->import_module_list_head;
#endif
return module;
}
WASMModule *
wasm_loader_load_from_sections(WASMSection *section_list,
char *error_buf, uint32 error_buf_size)
{
WASMModule *module = create_module(error_buf, error_buf_size);
if (!module)
return NULL;
if (!load_from_sections(module, section_list, error_buf, error_buf_size)) {
wasm_loader_unload(module);
return NULL;
}
LOG_VERBOSE("Load module from sections success.\n");
return module;
}
static void
destroy_sections(WASMSection *section_list)
{
WASMSection *section = section_list, *next;
while (section) {
next = section->next;
wasm_runtime_free(section);
section = next;
}
}
static uint8 section_ids[] = {
SECTION_TYPE_USER,
SECTION_TYPE_TYPE,
SECTION_TYPE_IMPORT,
SECTION_TYPE_FUNC,
SECTION_TYPE_TABLE,
SECTION_TYPE_MEMORY,
SECTION_TYPE_GLOBAL,
SECTION_TYPE_EXPORT,
SECTION_TYPE_START,
SECTION_TYPE_ELEM,
#if WASM_ENABLE_BULK_MEMORY != 0
SECTION_TYPE_DATACOUNT,
#endif
SECTION_TYPE_CODE,
SECTION_TYPE_DATA
};
static uint8
get_section_index(uint8 section_type)
{
uint8 max_id = sizeof(section_ids) / sizeof(uint8);
for (uint8 i = 0; i < max_id; i++) {
if (section_type == section_ids[i])
return i;
}
return (uint8)-1;
}
static bool
create_sections(const uint8 *buf, uint32 size,
WASMSection **p_section_list,
char *error_buf, uint32 error_buf_size)
{
WASMSection *section_list_end = NULL, *section;
const uint8 *p = buf, *p_end = buf + size/*, *section_body*/;
uint8 section_type, section_index, last_section_index = (uint8)-1;
uint32 section_size;
bh_assert(!*p_section_list);
p += 8;
while (p < p_end) {
CHECK_BUF(p, p_end, 1);
section_type = read_uint8(p);
section_index = get_section_index(section_type);
if (section_index != (uint8)-1) {
if (section_type != SECTION_TYPE_USER) {
/* Custom sections may be inserted at any place,
while other sections must occur at most once
and in prescribed order. */
bh_assert(last_section_index == (uint8)-1
|| last_section_index < section_index);
last_section_index = section_index;
}
CHECK_BUF1(p, p_end, 1);
read_leb_uint32(p, p_end, section_size);
CHECK_BUF1(p, p_end, section_size);
if (!(section = loader_malloc(sizeof(WASMSection),
error_buf, error_buf_size))) {
return false;
}
section->section_type = section_type;
section->section_body = (uint8*)p;
section->section_body_size = section_size;
if (!*p_section_list)
*p_section_list = section_list_end = section;
else {
section_list_end->next = section;
section_list_end = section;
}
p += section_size;
}
else {
bh_assert(0);
}
}
(void)last_section_index;
return true;
}
static void
exchange32(uint8* p_data)
{
uint8 value = *p_data;
*p_data = *(p_data + 3);
*(p_data + 3) = value;
value = *(p_data + 1);
*(p_data + 1) = *(p_data + 2);
*(p_data + 2) = value;
}
static union {
int a;
char b;
} __ue = { .a = 1 };
#define is_little_endian() (__ue.b == 1)
static bool
load(const uint8 *buf, uint32 size, WASMModule *module,
char *error_buf, uint32 error_buf_size)
{
const uint8 *buf_end = buf + size;
const uint8 *p = buf, *p_end = buf_end;
uint32 magic_number, version;
WASMSection *section_list = NULL;
CHECK_BUF1(p, p_end, sizeof(uint32));
magic_number = read_uint32(p);
if (!is_little_endian())
exchange32((uint8*)&magic_number);
bh_assert(magic_number == WASM_MAGIC_NUMBER);
CHECK_BUF1(p, p_end, sizeof(uint32));
version = read_uint32(p);
if (!is_little_endian())
exchange32((uint8*)&version);
if (version != WASM_CURRENT_VERSION) {
set_error_buf(error_buf, error_buf_size,
"WASM module load failed: unknown binary version");
return false;
}
if (!create_sections(buf, size, &section_list, error_buf, error_buf_size)
|| !load_from_sections(module, section_list, error_buf, error_buf_size)) {
destroy_sections(section_list);
return false;
}
destroy_sections(section_list);
(void)p_end;
return true;
}
WASMModule*
wasm_loader_load(const uint8 *buf, uint32 size, char *error_buf, uint32 error_buf_size)
{
WASMModule *module = create_module(error_buf, error_buf_size);
if (!module) {
return NULL;
}
if (!load(buf, size, module, error_buf, error_buf_size)) {
LOG_VERBOSE("Load module failed, %s", error_buf);
goto fail;
}
LOG_VERBOSE("Load module success");
return module;
fail:
wasm_loader_unload(module);
return NULL;
}
void
wasm_loader_unload(WASMModule *module)
{
uint32 i;
if (!module)
return;
if (module->types) {
for (i = 0; i < module->type_count; i++) {
if (module->types[i])
wasm_runtime_free(module->types[i]);
}
wasm_runtime_free(module->types);
}
if (module->imports)
wasm_runtime_free(module->imports);
if (module->functions) {
for (i = 0; i < module->function_count; i++) {
if (module->functions[i]) {
if (module->functions[i]->local_offsets)
wasm_runtime_free(module->functions[i]->local_offsets);
#if WASM_ENABLE_FAST_INTERP != 0
if (module->functions[i]->code_compiled)
wasm_runtime_free(module->functions[i]->code_compiled);
if (module->functions[i]->consts)
wasm_runtime_free(module->functions[i]->consts);
#endif
wasm_runtime_free(module->functions[i]);
}
}
wasm_runtime_free(module->functions);
}
if (module->tables)
wasm_runtime_free(module->tables);
if (module->memories)
wasm_runtime_free(module->memories);
if (module->globals)
wasm_runtime_free(module->globals);
if (module->exports)
wasm_runtime_free(module->exports);
if (module->table_segments) {
for (i = 0; i < module->table_seg_count; i++) {
if (module->table_segments[i].func_indexes)
wasm_runtime_free(module->table_segments[i].func_indexes);
}
wasm_runtime_free(module->table_segments);
}
if (module->data_segments) {
for (i = 0; i < module->data_seg_count; i++) {
if (module->data_segments[i])
wasm_runtime_free(module->data_segments[i]);
}
wasm_runtime_free(module->data_segments);
}
if (module->const_str_list) {
StringNode *node = module->const_str_list, *node_next;
while (node) {
node_next = node->next;
wasm_runtime_free(node);
node = node_next;
}
}
wasm_runtime_free(module);
}
bool
wasm_loader_find_block_addr(BlockAddr *block_addr_cache,
const uint8 *start_addr,
const uint8 *code_end_addr,
uint8 block_type,
uint8 **p_else_addr,
uint8 **p_end_addr,
char *error_buf,
uint32 error_buf_size)
{
const uint8 *p = start_addr, *p_end = code_end_addr;
uint8 *else_addr = NULL;
uint32 block_nested_depth = 1, count, i, j, t;
uint8 opcode, u8;
BlockAddr block_stack[16] = { 0 }, *block;
i = ((uintptr_t)start_addr) % BLOCK_ADDR_CACHE_SIZE;
block = block_addr_cache + BLOCK_ADDR_CONFLICT_SIZE * i;
for (j = 0; j < BLOCK_ADDR_CONFLICT_SIZE; j++) {
if (block[j].start_addr == start_addr) {
/* Cache hit */
*p_else_addr = block[j].else_addr;
*p_end_addr = block[j].end_addr;
return true;
}
}
/* Cache unhit */
block_stack[0].start_addr = start_addr;
while (p < code_end_addr) {
opcode = *p++;
switch (opcode) {
case WASM_OP_UNREACHABLE:
case WASM_OP_NOP:
break;
case WASM_OP_BLOCK:
case WASM_OP_LOOP:
case WASM_OP_IF:
CHECK_BUF(p, p_end, 1);
/* block result type: 0x40/0x7F/0x7E/0x7D/0x7C */
u8 = read_uint8(p);
if (block_nested_depth < sizeof(block_stack)/sizeof(BlockAddr)) {
block_stack[block_nested_depth].start_addr = p;
block_stack[block_nested_depth].else_addr = NULL;
}
block_nested_depth++;
break;
case WASM_OP_ELSE:
if (block_type == BLOCK_TYPE_IF && block_nested_depth == 1)
else_addr = (uint8*)(p - 1);
if (block_nested_depth - 1 < sizeof(block_stack)/sizeof(BlockAddr))
block_stack[block_nested_depth - 1].else_addr = (uint8*)(p - 1);
break;
case WASM_OP_END:
if (block_nested_depth == 1) {
if (block_type == BLOCK_TYPE_IF)
*p_else_addr = else_addr;
*p_end_addr = (uint8*)(p - 1);
block_stack[0].end_addr = (uint8*)(p - 1);
for (t = 0; t < sizeof(block_stack)/sizeof(BlockAddr); t++) {
start_addr = block_stack[t].start_addr;
if (start_addr) {
i = ((uintptr_t)start_addr) % BLOCK_ADDR_CACHE_SIZE;
block = block_addr_cache + BLOCK_ADDR_CONFLICT_SIZE * i;
for (j = 0; j < BLOCK_ADDR_CONFLICT_SIZE; j++)
if (!block[j].start_addr)
break;
if (j == BLOCK_ADDR_CONFLICT_SIZE) {
memmove(block + 1, block, (BLOCK_ADDR_CONFLICT_SIZE - 1) *
sizeof(BlockAddr));
j = 0;
}
block[j].start_addr = block_stack[t].start_addr;
block[j].else_addr = block_stack[t].else_addr;
block[j].end_addr = block_stack[t].end_addr;
}
else
break;
}
return true;
}
else {
block_nested_depth--;
if (block_nested_depth < sizeof(block_stack)/sizeof(BlockAddr))
block_stack[block_nested_depth].end_addr = (uint8*)(p - 1);
}
break;
case WASM_OP_BR:
case WASM_OP_BR_IF:
skip_leb_uint32(p, p_end); /* labelidx */
break;
case WASM_OP_BR_TABLE:
read_leb_uint32(p, p_end, count); /* lable num */
for (i = 0; i <= count; i++) /* lableidxs */
skip_leb_uint32(p, p_end);
break;
case WASM_OP_RETURN:
break;
case WASM_OP_CALL:
skip_leb_uint32(p, p_end); /* funcidx */
break;
case WASM_OP_CALL_INDIRECT:
skip_leb_uint32(p, p_end); /* typeidx */
CHECK_BUF(p, p_end, 1);
u8 = read_uint8(p); /* 0x00 */
break;
case WASM_OP_DROP:
case WASM_OP_SELECT:
case WASM_OP_DROP_64:
case WASM_OP_SELECT_64:
break;
case WASM_OP_GET_LOCAL:
case WASM_OP_SET_LOCAL:
case WASM_OP_TEE_LOCAL:
case WASM_OP_GET_GLOBAL:
case WASM_OP_SET_GLOBAL:
skip_leb_uint32(p, p_end); /* localidx */
break;
case EXT_OP_GET_LOCAL_FAST:
case EXT_OP_SET_LOCAL_FAST:
case EXT_OP_TEE_LOCAL_FAST:
CHECK_BUF(p, p_end, 1);
p++;
break;
case WASM_OP_I32_LOAD:
case WASM_OP_I64_LOAD:
case WASM_OP_F32_LOAD:
case WASM_OP_F64_LOAD:
case WASM_OP_I32_LOAD8_S:
case WASM_OP_I32_LOAD8_U:
case WASM_OP_I32_LOAD16_S:
case WASM_OP_I32_LOAD16_U:
case WASM_OP_I64_LOAD8_S:
case WASM_OP_I64_LOAD8_U:
case WASM_OP_I64_LOAD16_S:
case WASM_OP_I64_LOAD16_U:
case WASM_OP_I64_LOAD32_S:
case WASM_OP_I64_LOAD32_U:
case WASM_OP_I32_STORE:
case WASM_OP_I64_STORE:
case WASM_OP_F32_STORE:
case WASM_OP_F64_STORE:
case WASM_OP_I32_STORE8:
case WASM_OP_I32_STORE16:
case WASM_OP_I64_STORE8:
case WASM_OP_I64_STORE16:
case WASM_OP_I64_STORE32:
skip_leb_uint32(p, p_end); /* align */
skip_leb_uint32(p, p_end); /* offset */
break;
case WASM_OP_MEMORY_SIZE:
case WASM_OP_MEMORY_GROW:
skip_leb_uint32(p, p_end); /* 0x00 */
break;
case WASM_OP_I32_CONST:
skip_leb_int32(p, p_end);
break;
case WASM_OP_I64_CONST:
skip_leb_int64(p, p_end);
break;
case WASM_OP_F32_CONST:
p += sizeof(float32);
break;
case WASM_OP_F64_CONST:
p += sizeof(float64);
break;
case WASM_OP_I32_EQZ:
case WASM_OP_I32_EQ:
case WASM_OP_I32_NE:
case WASM_OP_I32_LT_S:
case WASM_OP_I32_LT_U:
case WASM_OP_I32_GT_S:
case WASM_OP_I32_GT_U:
case WASM_OP_I32_LE_S:
case WASM_OP_I32_LE_U:
case WASM_OP_I32_GE_S:
case WASM_OP_I32_GE_U:
case WASM_OP_I64_EQZ:
case WASM_OP_I64_EQ:
case WASM_OP_I64_NE:
case WASM_OP_I64_LT_S:
case WASM_OP_I64_LT_U:
case WASM_OP_I64_GT_S:
case WASM_OP_I64_GT_U:
case WASM_OP_I64_LE_S:
case WASM_OP_I64_LE_U:
case WASM_OP_I64_GE_S:
case WASM_OP_I64_GE_U:
case WASM_OP_F32_EQ:
case WASM_OP_F32_NE:
case WASM_OP_F32_LT:
case WASM_OP_F32_GT:
case WASM_OP_F32_LE:
case WASM_OP_F32_GE:
case WASM_OP_F64_EQ:
case WASM_OP_F64_NE:
case WASM_OP_F64_LT:
case WASM_OP_F64_GT:
case WASM_OP_F64_LE:
case WASM_OP_F64_GE:
case WASM_OP_I32_CLZ:
case WASM_OP_I32_CTZ:
case WASM_OP_I32_POPCNT:
case WASM_OP_I32_ADD:
case WASM_OP_I32_SUB:
case WASM_OP_I32_MUL:
case WASM_OP_I32_DIV_S:
case WASM_OP_I32_DIV_U:
case WASM_OP_I32_REM_S:
case WASM_OP_I32_REM_U:
case WASM_OP_I32_AND:
case WASM_OP_I32_OR:
case WASM_OP_I32_XOR:
case WASM_OP_I32_SHL:
case WASM_OP_I32_SHR_S:
case WASM_OP_I32_SHR_U:
case WASM_OP_I32_ROTL:
case WASM_OP_I32_ROTR:
case WASM_OP_I64_CLZ:
case WASM_OP_I64_CTZ:
case WASM_OP_I64_POPCNT:
case WASM_OP_I64_ADD:
case WASM_OP_I64_SUB:
case WASM_OP_I64_MUL:
case WASM_OP_I64_DIV_S:
case WASM_OP_I64_DIV_U:
case WASM_OP_I64_REM_S:
case WASM_OP_I64_REM_U:
case WASM_OP_I64_AND:
case WASM_OP_I64_OR:
case WASM_OP_I64_XOR:
case WASM_OP_I64_SHL:
case WASM_OP_I64_SHR_S:
case WASM_OP_I64_SHR_U:
case WASM_OP_I64_ROTL:
case WASM_OP_I64_ROTR:
case WASM_OP_F32_ABS:
case WASM_OP_F32_NEG:
case WASM_OP_F32_CEIL:
case WASM_OP_F32_FLOOR:
case WASM_OP_F32_TRUNC:
case WASM_OP_F32_NEAREST:
case WASM_OP_F32_SQRT:
case WASM_OP_F32_ADD:
case WASM_OP_F32_SUB:
case WASM_OP_F32_MUL:
case WASM_OP_F32_DIV:
case WASM_OP_F32_MIN:
case WASM_OP_F32_MAX:
case WASM_OP_F32_COPYSIGN:
case WASM_OP_F64_ABS:
case WASM_OP_F64_NEG:
case WASM_OP_F64_CEIL:
case WASM_OP_F64_FLOOR:
case WASM_OP_F64_TRUNC:
case WASM_OP_F64_NEAREST:
case WASM_OP_F64_SQRT:
case WASM_OP_F64_ADD:
case WASM_OP_F64_SUB:
case WASM_OP_F64_MUL:
case WASM_OP_F64_DIV:
case WASM_OP_F64_MIN:
case WASM_OP_F64_MAX:
case WASM_OP_F64_COPYSIGN:
case WASM_OP_I32_WRAP_I64:
case WASM_OP_I32_TRUNC_S_F32:
case WASM_OP_I32_TRUNC_U_F32:
case WASM_OP_I32_TRUNC_S_F64:
case WASM_OP_I32_TRUNC_U_F64:
case WASM_OP_I64_EXTEND_S_I32:
case WASM_OP_I64_EXTEND_U_I32:
case WASM_OP_I64_TRUNC_S_F32:
case WASM_OP_I64_TRUNC_U_F32:
case WASM_OP_I64_TRUNC_S_F64:
case WASM_OP_I64_TRUNC_U_F64:
case WASM_OP_F32_CONVERT_S_I32:
case WASM_OP_F32_CONVERT_U_I32:
case WASM_OP_F32_CONVERT_S_I64:
case WASM_OP_F32_CONVERT_U_I64:
case WASM_OP_F32_DEMOTE_F64:
case WASM_OP_F64_CONVERT_S_I32:
case WASM_OP_F64_CONVERT_U_I32:
case WASM_OP_F64_CONVERT_S_I64:
case WASM_OP_F64_CONVERT_U_I64:
case WASM_OP_F64_PROMOTE_F32:
case WASM_OP_I32_REINTERPRET_F32:
case WASM_OP_I64_REINTERPRET_F64:
case WASM_OP_F32_REINTERPRET_I32:
case WASM_OP_F64_REINTERPRET_I64:
case WASM_OP_I32_EXTEND8_S:
case WASM_OP_I32_EXTEND16_S:
case WASM_OP_I64_EXTEND8_S:
case WASM_OP_I64_EXTEND16_S:
case WASM_OP_I64_EXTEND32_S:
break;
case WASM_OP_MISC_PREFIX:
{
opcode = read_uint8(p);
switch (opcode) {
case WASM_OP_I32_TRUNC_SAT_S_F32:
case WASM_OP_I32_TRUNC_SAT_U_F32:
case WASM_OP_I32_TRUNC_SAT_S_F64:
case WASM_OP_I32_TRUNC_SAT_U_F64:
case WASM_OP_I64_TRUNC_SAT_S_F32:
case WASM_OP_I64_TRUNC_SAT_U_F32:
case WASM_OP_I64_TRUNC_SAT_S_F64:
case WASM_OP_I64_TRUNC_SAT_U_F64:
break;
#if WASM_ENABLE_BULK_MEMORY != 0
case WASM_OP_MEMORY_INIT:
skip_leb_uint32(p, p_end);
/* skip memory idx */
p++;
break;
case WASM_OP_DATA_DROP:
skip_leb_uint32(p, p_end);
break;
case WASM_OP_MEMORY_COPY:
/* skip two memory idx */
p += 2;
break;
case WASM_OP_MEMORY_FILL:
/* skip memory idx */
p++;
break;
#endif
default:
bh_assert(0);
break;
}
break;
}
default:
bh_assert(0);
break;
}
}
(void)u8;
return false;
}
#define REF_I32 VALUE_TYPE_I32
#define REF_F32 VALUE_TYPE_F32
#define REF_I64_1 VALUE_TYPE_I64
#define REF_I64_2 VALUE_TYPE_I64
#define REF_F64_1 VALUE_TYPE_F64
#define REF_F64_2 VALUE_TYPE_F64
#define REF_ANY VALUE_TYPE_ANY
#if WASM_ENABLE_FAST_INTERP != 0
#if WASM_DEBUG_PREPROCESSOR != 0
#define LOG_OP(...) os_printf(__VA_ARGS__)
#else
#define LOG_OP(...)
#endif
#define PATCH_ELSE 0
#define PATCH_END 1
typedef struct BranchBlockPatch {
struct BranchBlockPatch *next;
uint8 patch_type;
uint8 *code_compiled;
} BranchBlockPatch;
#endif
typedef struct BranchBlock {
uint8 block_type;
uint8 return_type;
uint8 *start_addr;
uint8 *else_addr;
uint8 *end_addr;
uint32 stack_cell_num;
#if WASM_ENABLE_FAST_INTERP != 0
uint16 dynamic_offset;
uint8 *code_compiled;
BranchBlockPatch *patch_list;
#endif
/* Indicate the operand stack is in polymorphic state.
* If the opcode is one of unreachable/br/br_table/return, stack is marked
* to polymorphic state until the block's 'end' opcode is processed.
* If stack is in polymorphic state and stack is empty, instruction can
* pop any type of value directly without decreasing stack top pointer
* and stack cell num. */
bool is_stack_polymorphic;
} BranchBlock;
typedef struct WASMLoaderContext {
/* frame ref stack */
uint8 *frame_ref;
uint8 *frame_ref_bottom;
uint8 *frame_ref_boundary;
uint32 frame_ref_size;
uint32 stack_cell_num;
uint32 max_stack_cell_num;
/* frame csp stack */
BranchBlock *frame_csp;
BranchBlock *frame_csp_bottom;
BranchBlock *frame_csp_boundary;
uint32 frame_csp_size;
uint32 csp_num;
uint32 max_csp_num;
#if WASM_ENABLE_FAST_INTERP != 0
/* frame offset stack */
int16 *frame_offset;
int16 *frame_offset_bottom;
int16 *frame_offset_boundary;
uint32 frame_offset_size;
int16 dynamic_offset;
int16 start_dynamic_offset;
int16 max_dynamic_offset;
/* preserved local offset */
int16 preserved_local_offset;
/* const buffer */
uint8 *const_buf;
uint16 num_const;
uint16 const_buf_size;
uint16 const_cell_num;
/* processed code */
uint8 *p_code_compiled;
uint8 *p_code_compiled_end;
uint32 code_compiled_size;
#endif
} WASMLoaderContext;
typedef struct Const {
WASMValue value;
uint16 slot_index;
uint8 value_type;
} Const;
static void*
memory_realloc(void *mem_old, uint32 size_old, uint32 size_new,
char *error_buf, uint32 error_buf_size)
{
uint8 *mem_new;
bh_assert(size_new > size_old);
if ((mem_new = loader_malloc
(size_new, error_buf, error_buf_size))) {
bh_memcpy_s(mem_new, size_new, mem_old, size_old);
memset(mem_new + size_old, 0, size_new - size_old);
wasm_runtime_free(mem_old);
}
return mem_new;
}
#define MEM_REALLOC(mem, size_old, size_new) do { \
void *mem_new = memory_realloc(mem, size_old, size_new, \
error_buf, error_buf_size); \
if (!mem_new) \
goto fail; \
mem = mem_new; \
} while (0)
#define CHECK_CSP_PUSH() do { \
if (ctx->frame_csp >= ctx->frame_csp_boundary) { \
MEM_REALLOC(ctx->frame_csp_bottom, ctx->frame_csp_size, \
(uint32)(ctx->frame_csp_size \
+ 8 * sizeof(BranchBlock))); \
ctx->frame_csp_size += (uint32)(8 * sizeof(BranchBlock)); \
ctx->frame_csp_boundary = ctx->frame_csp_bottom + \
ctx->frame_csp_size / sizeof(BranchBlock); \
ctx->frame_csp = ctx->frame_csp_bottom + ctx->csp_num; \
} \
} while (0)
#define CHECK_CSP_POP() do { \
bh_assert(ctx->csp_num >= 1); \
} while (0)
#if WASM_ENABLE_FAST_INTERP != 0
static bool
check_offset_push(WASMLoaderContext *ctx,
char *error_buf, uint32 error_buf_size)
{
uint32 cell_num = (ctx->frame_offset - ctx->frame_offset_bottom);
if (ctx->frame_offset >= ctx->frame_offset_boundary) {
MEM_REALLOC(ctx->frame_offset_bottom, ctx->frame_offset_size,
ctx->frame_offset_size + 16);
ctx->frame_offset_size += 16;
ctx->frame_offset_boundary = ctx->frame_offset_bottom +
ctx->frame_offset_size / sizeof(int16);
ctx->frame_offset = ctx->frame_offset_bottom + cell_num;
}
return true;
fail:
return false;
}
static bool
check_offset_pop(WASMLoaderContext *ctx, uint32 cells)
{
if (ctx->frame_offset - cells < ctx->frame_offset_bottom)
return false;
return true;
}
static void
free_label_patch_list(BranchBlock *frame_csp)
{
BranchBlockPatch *label_patch = frame_csp->patch_list;
BranchBlockPatch *next;
while (label_patch != NULL) {
next = label_patch->next;
wasm_runtime_free(label_patch);
label_patch = next;
}
frame_csp->patch_list = NULL;
}
static void
free_all_label_patch_lists(BranchBlock *frame_csp, uint32 csp_num)
{
BranchBlock *tmp_csp = frame_csp;
for (uint32 i = 0; i < csp_num; i++) {
free_label_patch_list(tmp_csp);
tmp_csp ++;
}
}
#endif
static bool
check_stack_push(WASMLoaderContext *ctx,
char *error_buf, uint32 error_buf_size)
{
if (ctx->frame_ref >= ctx->frame_ref_boundary) {
MEM_REALLOC(ctx->frame_ref_bottom, ctx->frame_ref_size,
ctx->frame_ref_size + 16);
ctx->frame_ref_size += 16;
ctx->frame_ref_boundary = ctx->frame_ref_bottom + ctx->frame_ref_size;
ctx->frame_ref = ctx->frame_ref_bottom + ctx->stack_cell_num;
}
return true;
fail:
return false;
}
static bool
check_stack_top_values(uint8 *frame_ref, int32 stack_cell_num, uint8 type,
char *error_buf, uint32 error_buf_size)
{
bh_assert(!(((type == VALUE_TYPE_I32 || type == VALUE_TYPE_F32)
&& stack_cell_num < 1)
|| ((type == VALUE_TYPE_I64 || type == VALUE_TYPE_F64)
&& stack_cell_num < 2)));
bh_assert(!((type == VALUE_TYPE_I32 && *(frame_ref - 1) != REF_I32)
|| (type == VALUE_TYPE_F32 && *(frame_ref - 1) != REF_F32)
|| (type == VALUE_TYPE_I64
&& (*(frame_ref - 2) != REF_I64_1
|| *(frame_ref - 1) != REF_I64_2))
|| (type == VALUE_TYPE_F64
&& (*(frame_ref - 2) != REF_F64_1
|| *(frame_ref - 1) != REF_F64_2))));
return true;
}
static bool
check_stack_pop(WASMLoaderContext *ctx, uint8 type,
char *error_buf, uint32 error_buf_size)
{
int32 block_stack_cell_num = (int32)
(ctx->stack_cell_num - (ctx->frame_csp - 1)->stack_cell_num);
if (block_stack_cell_num > 0
&& *(ctx->frame_ref - 1) == VALUE_TYPE_ANY) {
/* the stack top is a value of any type, return success */
return true;
}
if (!check_stack_top_values(ctx->frame_ref, block_stack_cell_num,
type, error_buf, error_buf_size))
return false;
return true;
}
static void
wasm_loader_ctx_destroy(WASMLoaderContext *ctx)
{
if (ctx) {
if (ctx->frame_ref_bottom)
wasm_runtime_free(ctx->frame_ref_bottom);
if (ctx->frame_csp_bottom) {
#if WASM_ENABLE_FAST_INTERP != 0
free_all_label_patch_lists(ctx->frame_csp_bottom, ctx->csp_num);
#endif
wasm_runtime_free(ctx->frame_csp_bottom);
}
#if WASM_ENABLE_FAST_INTERP != 0
if (ctx->frame_offset_bottom)
wasm_runtime_free(ctx->frame_offset_bottom);
if (ctx->const_buf)
wasm_runtime_free(ctx->const_buf);
#endif
wasm_runtime_free(ctx);
}
}
static WASMLoaderContext*
wasm_loader_ctx_init(WASMFunction *func)
{
WASMLoaderContext *loader_ctx =
wasm_runtime_malloc(sizeof(WASMLoaderContext));
if (!loader_ctx)
return false;
memset(loader_ctx, 0, sizeof(WASMLoaderContext));
loader_ctx->frame_ref_size = 32;
if (!(loader_ctx->frame_ref_bottom = loader_ctx->frame_ref =
wasm_runtime_malloc(loader_ctx->frame_ref_size)))
goto fail;
memset(loader_ctx->frame_ref_bottom, 0, loader_ctx->frame_ref_size);
loader_ctx->frame_ref_boundary = loader_ctx->frame_ref_bottom +
loader_ctx->frame_ref_size;
loader_ctx->frame_csp_size = sizeof(BranchBlock) * 8;
if (!(loader_ctx->frame_csp_bottom = loader_ctx->frame_csp =
wasm_runtime_malloc(loader_ctx->frame_csp_size)))
goto fail;
memset(loader_ctx->frame_csp_bottom, 0, loader_ctx->frame_csp_size);
loader_ctx->frame_csp_boundary = loader_ctx->frame_csp_bottom + 8;
#if WASM_ENABLE_FAST_INTERP != 0
loader_ctx->frame_offset_size = sizeof(int16) * 32;
if (!(loader_ctx->frame_offset_bottom = loader_ctx->frame_offset =
wasm_runtime_malloc(loader_ctx->frame_offset_size)))
goto fail;
memset(loader_ctx->frame_offset_bottom, 0,
loader_ctx->frame_offset_size);
loader_ctx->frame_offset_boundary = loader_ctx->frame_offset_bottom + 32;
loader_ctx->num_const = 0;
loader_ctx->const_buf_size = sizeof(Const) * 8;
if (!(loader_ctx->const_buf = wasm_runtime_malloc(loader_ctx->const_buf_size)))
goto fail;
memset(loader_ctx->const_buf, 0, loader_ctx->const_buf_size);
loader_ctx->start_dynamic_offset = loader_ctx->dynamic_offset =
loader_ctx->max_dynamic_offset = func->param_cell_num +
func->local_cell_num;
#endif
return loader_ctx;
fail:
wasm_loader_ctx_destroy(loader_ctx);
return NULL;
}
static bool
wasm_loader_push_frame_ref(WASMLoaderContext *ctx, uint8 type,
char *error_buf, uint32 error_buf_size)
{
if (type == VALUE_TYPE_VOID)
return true;
if (!check_stack_push(ctx, error_buf, error_buf_size))
return false;
*ctx->frame_ref++ = type;
ctx->stack_cell_num++;
if (ctx->stack_cell_num > ctx->max_stack_cell_num)
ctx->max_stack_cell_num = ctx->stack_cell_num;
if (type == VALUE_TYPE_I32
|| type == VALUE_TYPE_F32
|| type == VALUE_TYPE_ANY)
return true;
if (!check_stack_push(ctx, error_buf, error_buf_size))
return false;
*ctx->frame_ref++ = type;
ctx->stack_cell_num++;
if (ctx->stack_cell_num > ctx->max_stack_cell_num)
ctx->max_stack_cell_num = ctx->stack_cell_num;
return true;
}
static bool
wasm_loader_pop_frame_ref(WASMLoaderContext *ctx, uint8 type,
char *error_buf, uint32 error_buf_size)
{
BranchBlock *cur_block = ctx->frame_csp - 1;
int32 available_stack_cell = (int32)
(ctx->stack_cell_num - cur_block->stack_cell_num);
/* Directly return success if current block is in stack
* polymorphic state while stack is empty. */
if (available_stack_cell <= 0 && cur_block->is_stack_polymorphic)
return true;
if (type == VALUE_TYPE_VOID)
return true;
if (!check_stack_pop(ctx, type, error_buf, error_buf_size))
return false;
ctx->frame_ref--;
ctx->stack_cell_num--;
if (type == VALUE_TYPE_I32
|| type == VALUE_TYPE_F32
|| *ctx->frame_ref == VALUE_TYPE_ANY)
return true;
ctx->frame_ref--;
ctx->stack_cell_num--;
return true;
}
static bool
wasm_loader_push_pop_frame_ref(WASMLoaderContext *ctx, uint8 pop_cnt,
uint8 type_push, uint8 type_pop,
char *error_buf, uint32 error_buf_size)
{
for (int i = 0; i < pop_cnt; i++) {
if (!wasm_loader_pop_frame_ref(ctx, type_pop, error_buf, error_buf_size))
return false;
}
if (!wasm_loader_push_frame_ref(ctx, type_push, error_buf, error_buf_size))
return false;
return true;
}
static bool
wasm_loader_push_frame_csp(WASMLoaderContext *ctx, uint8 type,
uint8 ret_type, uint8* start_addr,
char *error_buf, uint32 error_buf_size)
{
CHECK_CSP_PUSH();
memset(ctx->frame_csp, 0, sizeof(BranchBlock));
ctx->frame_csp->block_type = type;
ctx->frame_csp->return_type = ret_type;
ctx->frame_csp->start_addr = start_addr;
ctx->frame_csp->stack_cell_num = ctx->stack_cell_num;
#if WASM_ENABLE_FAST_INTERP != 0
ctx->frame_csp->dynamic_offset = ctx->dynamic_offset;
ctx->frame_csp->patch_list = NULL;
#endif
ctx->frame_csp++;
ctx->csp_num++;
if (ctx->csp_num > ctx->max_csp_num)
ctx->max_csp_num = ctx->csp_num;
return true;
fail:
return false;
}
static bool
wasm_loader_pop_frame_csp(WASMLoaderContext *ctx,
char *error_buf, uint32 error_buf_size)
{
CHECK_CSP_POP();
ctx->frame_csp--;
ctx->csp_num--;
return true;
}
static bool
wasm_loader_check_br(WASMLoaderContext *ctx, uint32 depth,
char *error_buf, uint32 error_buf_size)
{
BranchBlock *target_block, *cur_block;
int32 available_stack_cell;
bh_assert(ctx->csp_num >= depth + 1);
target_block = ctx->frame_csp - (depth + 1);
cur_block = ctx->frame_csp - 1;
available_stack_cell = (int32)
(ctx->stack_cell_num - cur_block->stack_cell_num);
if (available_stack_cell <= 0 && target_block->is_stack_polymorphic)
return true;
if (target_block->block_type != BLOCK_TYPE_LOOP) {
uint8 type = target_block->return_type;
if (!check_stack_top_values(ctx->frame_ref, available_stack_cell,
type, error_buf, error_buf_size))
return false;
}
return true;
}
#if WASM_ENABLE_FAST_INTERP != 0
#if WASM_ENABLE_ABS_LABEL_ADDR != 0
#define emit_label(opcode) do { \
wasm_loader_emit_ptr(loader_ctx, handle_table[opcode]); \
LOG_OP("\nemit_op [%02x]\t", opcode); \
} while (0)
#define skip_label() do { \
wasm_loader_emit_backspace(loader_ctx, sizeof(void *)); \
LOG_OP("\ndelete last op\n"); \
} while (0)
#else
#define emit_label(opcode) do { \
int32 offset = (int32)(handle_table[opcode] - handle_table[0]); \
bh_assert(offset >= INT16_MIN && offset < INT16_MAX); \
wasm_loader_emit_int16(loader_ctx, offset); \
LOG_OP("\nemit_op [%02x]\t", opcode); \
} while (0)
// drop local.get / const / block / loop / end
#define skip_label() do { \
wasm_loader_emit_backspace(loader_ctx, sizeof(int16)); \
LOG_OP("\ndelete last op\n"); \
} while (0)
#endif /* WASM_ENABLE_ABS_LABEL_ADDR */
#define emit_empty_label_addr_and_frame_ip(type) do { \
if (!add_label_patch_to_list(loader_ctx->frame_csp - 1, type, \
loader_ctx->p_code_compiled, \
error_buf, error_buf_size)) \
goto fail; \
/* label address, to be patched */ \
wasm_loader_emit_ptr(loader_ctx, NULL); \
} while (0)
#define emit_br_info(frame_csp) do { \
if (!wasm_loader_emit_br_info(loader_ctx, frame_csp, \
error_buf, error_buf_size)) \
goto fail; \
} while (0)
#define LAST_OP_OUTPUT_I32() (last_op >= WASM_OP_I32_EQZ \
&& last_op <= WASM_OP_I32_ROTR) \
|| (last_op == WASM_OP_I32_LOAD \
|| last_op == WASM_OP_F32_LOAD) \
|| (last_op >= WASM_OP_I32_LOAD8_S \
&& last_op <= WASM_OP_I32_LOAD16_U) \
|| (last_op >= WASM_OP_F32_ABS \
&& last_op <= WASM_OP_F32_COPYSIGN) \
|| (last_op >= WASM_OP_I32_WRAP_I64 \
&& last_op <= WASM_OP_I32_TRUNC_U_F64) \
|| (last_op >= WASM_OP_F32_CONVERT_S_I32 \
&& last_op <= WASM_OP_F32_DEMOTE_F64) \
|| (last_op == WASM_OP_I32_REINTERPRET_F32) \
|| (last_op == WASM_OP_F32_REINTERPRET_I32) \
|| (last_op == EXT_OP_COPY_STACK_TOP)
#define LAST_OP_OUTPUT_I64() (last_op >= WASM_OP_I64_CLZ \
&& last_op <= WASM_OP_I64_ROTR) \
|| (last_op >= WASM_OP_F64_ABS \
&& last_op <= WASM_OP_F64_COPYSIGN) \
|| (last_op == WASM_OP_I64_LOAD \
|| last_op == WASM_OP_F64_LOAD) \
|| (last_op >= WASM_OP_I64_LOAD8_S \
&& last_op <= WASM_OP_I64_LOAD32_U) \
|| (last_op >= WASM_OP_I64_EXTEND_S_I32 \
&& last_op <= WASM_OP_I64_TRUNC_U_F64) \
|| (last_op >= WASM_OP_F64_CONVERT_S_I32 \
&& last_op <= WASM_OP_F64_PROMOTE_F32) \
|| (last_op == WASM_OP_I64_REINTERPRET_F64) \
|| (last_op == WASM_OP_F64_REINTERPRET_I64) \
|| (last_op == EXT_OP_COPY_STACK_TOP_I64)
#define GET_CONST_OFFSET(type, val) do { \
if (!(wasm_loader_get_const_offset(loader_ctx, type, \
&val, &operand_offset, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#define GET_CONST_F32_OFFSET(type, fval) do { \
if (!(wasm_loader_get_const_offset(loader_ctx, type, \
&fval, &operand_offset, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#define GET_CONST_F64_OFFSET(type, fval) do { \
if (!(wasm_loader_get_const_offset(loader_ctx, type, \
&fval, &operand_offset, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#define emit_operand(ctx, offset) do { \
wasm_loader_emit_int16(ctx, offset); \
LOG_OP("%d\t", offset); \
} while (0)
#define emit_byte(ctx, byte) do { \
wasm_loader_emit_uint8(ctx, byte); \
LOG_OP("%d\t", byte); \
} while (0)
Implement memory access bound check with hardware trap for 64-bit platforms (#293) Also implement native stack overflow check with hardware trap for 64-bit platforms Refine classic interpreter and fast interpreter to improve performance Update document
2020-06-28 15:41:25 +08:00
#define emit_uint32(ctx, value) do { \
wasm_loader_emit_uint32(ctx, value); \
LOG_OP("%d\t", value); \
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
} while (0)
Implement memory access bound check with hardware trap for 64-bit platforms (#293) Also implement native stack overflow check with hardware trap for 64-bit platforms Refine classic interpreter and fast interpreter to improve performance Update document
2020-06-28 15:41:25 +08:00
#define emit_leb() do { \
wasm_loader_emit_leb(loader_ctx, p_org, p); \
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
} while (0)
static bool
wasm_loader_ctx_reinit(WASMLoaderContext *ctx)
{
if (!(ctx->p_code_compiled = wasm_runtime_malloc(ctx->code_compiled_size)))
return false;
memset(ctx->p_code_compiled, 0, ctx->code_compiled_size);
ctx->p_code_compiled_end = ctx->p_code_compiled +
ctx->code_compiled_size;
/* clean up frame ref */
memset(ctx->frame_ref_bottom, 0, ctx->frame_ref_size);
ctx->frame_ref = ctx->frame_ref_bottom;
ctx->stack_cell_num = 0;
/* clean up frame csp */
memset(ctx->frame_csp_bottom, 0, ctx->frame_csp_size);
ctx->frame_csp = ctx->frame_csp_bottom;
ctx->csp_num = 0;
ctx->max_csp_num = 0;
/* clean up frame offset */
memset(ctx->frame_offset_bottom, 0, ctx->frame_offset_size);
ctx->frame_offset = ctx->frame_offset_bottom;
ctx->dynamic_offset = ctx->start_dynamic_offset;
/* init preserved local offsets */
ctx->preserved_local_offset = ctx->max_dynamic_offset;
/* const buf is reserved */
return true;
}
Implement memory access bound check with hardware trap for 64-bit platforms (#293) Also implement native stack overflow check with hardware trap for 64-bit platforms Refine classic interpreter and fast interpreter to improve performance Update document
2020-06-28 15:41:25 +08:00
static void
wasm_loader_emit_uint32(WASMLoaderContext *ctx, uint32 value)
{
if (ctx->p_code_compiled) {
*(uint32*)(ctx->p_code_compiled) = value;
ctx->p_code_compiled += sizeof(uint32);
}
else
ctx->code_compiled_size += sizeof(uint32);
}
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
static void
wasm_loader_emit_int16(WASMLoaderContext *ctx, int16 value)
{
if (ctx->p_code_compiled) {
*(int16*)(ctx->p_code_compiled) = value;
ctx->p_code_compiled += sizeof(int16);
}
else
ctx->code_compiled_size += sizeof(int16);
}
static void
wasm_loader_emit_uint8(WASMLoaderContext *ctx, uint8 value)
{
if (ctx->p_code_compiled) {
*(ctx->p_code_compiled) = value;
ctx->p_code_compiled += sizeof(uint8);
}
else
ctx->code_compiled_size += sizeof(uint8);
}
static void
wasm_loader_emit_ptr(WASMLoaderContext *ctx, void *value)
{
if (ctx->p_code_compiled) {
*(uint8**)(ctx->p_code_compiled) = value;
ctx->p_code_compiled += sizeof(void *);
}
else
ctx->code_compiled_size += sizeof(void *);
}
static void
wasm_loader_emit_backspace(WASMLoaderContext *ctx, uint32 size)
{
if (ctx->p_code_compiled) {
ctx->p_code_compiled -= size;
}
else
ctx->code_compiled_size -= size;
}
static void
wasm_loader_emit_leb(WASMLoaderContext *ctx, uint8* start, uint8* end)
{
if (ctx->p_code_compiled) {
bh_memcpy_s(ctx->p_code_compiled,
ctx->p_code_compiled_end - ctx->p_code_compiled,
start, end - start);
ctx->p_code_compiled += (end - start);
}
else {
ctx->code_compiled_size += (end - start);
}
}
static bool
preserve_referenced_local(WASMLoaderContext *loader_ctx, uint8 opcode,
uint32 local_index, uint32 local_type, bool *preserved,
char *error_buf, uint32 error_buf_size)
{
int16 preserved_offset = (int16)local_index;
*preserved = false;
for (uint32 i = 0; i < loader_ctx->stack_cell_num; i++) {
/* move previous local into dynamic space before a set/tee_local opcode */
if (loader_ctx->frame_offset_bottom[i] == (int16)local_index) {
if (preserved_offset == (int16)local_index) {
*preserved = true;
skip_label();
if (local_type == VALUE_TYPE_I32
|| local_type == VALUE_TYPE_F32) {
preserved_offset = loader_ctx->preserved_local_offset;
/* Only increase preserve offset in the second traversal */
if (loader_ctx->p_code_compiled)
loader_ctx->preserved_local_offset++;
emit_label(EXT_OP_COPY_STACK_TOP);
}
else {
preserved_offset = loader_ctx->preserved_local_offset;
if (loader_ctx->p_code_compiled)
loader_ctx->preserved_local_offset += 2;
emit_label(EXT_OP_COPY_STACK_TOP_I64);
}
emit_operand(loader_ctx, local_index);
emit_operand(loader_ctx, preserved_offset);
emit_label(opcode);
}
loader_ctx->frame_offset_bottom[i] = preserved_offset;
}
}
return true;
#if WASM_ENABLE_ABS_LABEL_ADDR == 0
fail:
return false;
#endif
}
static bool
add_label_patch_to_list(BranchBlock *frame_csp,
uint8 patch_type, uint8 *p_code_compiled,
char *error_buf, uint32 error_buf_size)
{
BranchBlockPatch *patch = loader_malloc
(sizeof(BranchBlockPatch), error_buf, error_buf_size);
if (!patch) {
return false;
}
patch->patch_type = patch_type;
patch->code_compiled = p_code_compiled;
if (!frame_csp->patch_list) {
frame_csp->patch_list = patch;
patch->next = NULL;
}
else {
patch->next = frame_csp->patch_list;
frame_csp->patch_list = patch;
}
return true;
}
static void
apply_label_patch(WASMLoaderContext *ctx, uint8 depth,
uint8 patch_type)
{
BranchBlock *frame_csp = ctx->frame_csp - depth;
BranchBlockPatch *node = frame_csp->patch_list;
BranchBlockPatch *node_prev = NULL, *node_next;
if (!ctx->p_code_compiled)
return;
while (node) {
node_next = node->next;
if (node->patch_type == patch_type) {
*((uint8**)node->code_compiled) = ctx->p_code_compiled;
if (node_prev == NULL) {
frame_csp->patch_list = node_next;
}
else {
node_prev->next = node_next;
}
wasm_runtime_free(node);
}
else {
node_prev = node;
}
node = node_next;
}
}
static bool
wasm_loader_emit_br_info(WASMLoaderContext *ctx, BranchBlock *frame_csp,
char *error_buf, uint32 error_buf_size)
{
emit_operand(ctx, frame_csp->dynamic_offset);
if (frame_csp->block_type == BLOCK_TYPE_LOOP ||
frame_csp->return_type == VALUE_TYPE_VOID) {
emit_byte(ctx, 0);
emit_operand(ctx, 0);
}
else if (frame_csp->return_type == VALUE_TYPE_I32
|| frame_csp->return_type == VALUE_TYPE_F32) {
emit_byte(ctx, 1);
emit_operand(ctx, *(int16*)(ctx->frame_offset - 1));
}
else if (frame_csp->return_type == VALUE_TYPE_I64
|| frame_csp->return_type == VALUE_TYPE_F64) {
emit_byte(ctx, 2);
emit_operand(ctx, *(int16*)(ctx->frame_offset - 2));
}
if (frame_csp->block_type == BLOCK_TYPE_LOOP) {
wasm_loader_emit_ptr(ctx, frame_csp->code_compiled);
}
else {
if (!add_label_patch_to_list(frame_csp, PATCH_END,
ctx->p_code_compiled,
error_buf, error_buf_size))
return false;
/* label address, to be patched */
wasm_loader_emit_ptr(ctx, NULL);
}
return true;
}
static bool
wasm_loader_push_frame_offset(WASMLoaderContext *ctx, uint8 type,
bool disable_emit, int16 operand_offset,
char *error_buf, uint32 error_buf_size)
{
if (type == VALUE_TYPE_VOID)
return true;
// only check memory overflow in first traverse
if (ctx->p_code_compiled == NULL) {
if (!check_offset_push(ctx, error_buf, error_buf_size))
return false;
}
if (disable_emit)
*(ctx->frame_offset)++ = operand_offset;
else {
emit_operand(ctx, ctx->dynamic_offset);
*(ctx->frame_offset)++ = ctx->dynamic_offset;
ctx->dynamic_offset++;
if (ctx->dynamic_offset > ctx->max_dynamic_offset)
ctx->max_dynamic_offset = ctx->dynamic_offset;
}
if (type == VALUE_TYPE_I32 || type == VALUE_TYPE_F32)
return true;
if (ctx->p_code_compiled == NULL) {
if (!check_offset_push(ctx, error_buf, error_buf_size))
return false;
}
ctx->frame_offset++;
if (!disable_emit) {
ctx->dynamic_offset++;
if (ctx->dynamic_offset > ctx->max_dynamic_offset)
ctx->max_dynamic_offset = ctx->dynamic_offset;
}
return true;
}
/* This function should be in front of wasm_loader_pop_frame_ref
as they both use ctx->stack_cell_num, and ctx->stack_cell_num
will be modified by wasm_loader_pop_frame_ref */
static bool
wasm_loader_pop_frame_offset(WASMLoaderContext *ctx, uint8 type,
char *error_buf, uint32 error_buf_size)
{
/* if ctx->frame_csp equals ctx->frame_csp_bottom,
then current block is the function block */
uint32 depth = ctx->frame_csp > ctx->frame_csp_bottom ? 1 : 0;
BranchBlock *cur_block = ctx->frame_csp - depth;
int32 available_stack_cell = (int32)
(ctx->stack_cell_num - cur_block->stack_cell_num);
/* Directly return success if current block is in stack
* polymorphic state while stack is empty. */
if (available_stack_cell <= 0 && cur_block->is_stack_polymorphic)
return true;
if (type == VALUE_TYPE_VOID)
return true;
if (type == VALUE_TYPE_I32 || type == VALUE_TYPE_F32) {
/* Check the offset stack bottom to ensure the frame offset
stack will not go underflow. But we don't thrown error
and return true here, because the error msg should be
given in wasm_loader_pop_frame_ref */
if (!check_offset_pop(ctx, 1))
return true;
ctx->frame_offset -= 1;
if ((*(ctx->frame_offset) > ctx->start_dynamic_offset)
&& (*(ctx->frame_offset) < ctx->max_dynamic_offset))
ctx->dynamic_offset -= 1;
}
else {
if (!check_offset_pop(ctx, 2))
return true;
ctx->frame_offset -= 2;
if ((*(ctx->frame_offset) > ctx->start_dynamic_offset)
&& (*(ctx->frame_offset) < ctx->max_dynamic_offset))
ctx->dynamic_offset -= 2;
}
emit_operand(ctx, *(ctx->frame_offset));
return true;
}
static bool
wasm_loader_push_pop_frame_offset(WASMLoaderContext *ctx, uint8 pop_cnt,
uint8 type_push, uint8 type_pop,
bool disable_emit, int16 operand_offset,
char *error_buf, uint32 error_buf_size)
{
for (int i = 0; i < pop_cnt; i++) {
if (!wasm_loader_pop_frame_offset(ctx, type_pop, error_buf, error_buf_size))
return false;
}
if (!wasm_loader_push_frame_offset(ctx, type_push,
disable_emit, operand_offset,
error_buf, error_buf_size))
return false;
return true;
}
static bool
wasm_loader_push_frame_ref_offset(WASMLoaderContext *ctx, uint8 type,
bool disable_emit, int16 operand_offset,
char *error_buf, uint32 error_buf_size)
{
if (!(wasm_loader_push_frame_offset(ctx, type, disable_emit, operand_offset,
error_buf, error_buf_size)))
return false;
if (!(wasm_loader_push_frame_ref(ctx, type, error_buf, error_buf_size)))
return false;
return true;
}
static bool
wasm_loader_pop_frame_ref_offset(WASMLoaderContext *ctx, uint8 type,
char *error_buf, uint32 error_buf_size)
{
/* put wasm_loader_pop_frame_offset in front of wasm_loader_pop_frame_ref */
if (!wasm_loader_pop_frame_offset(ctx, type, error_buf, error_buf_size))
return false;
if (!wasm_loader_pop_frame_ref(ctx, type, error_buf, error_buf_size))
return false;
return true;
}
static bool
wasm_loader_push_pop_frame_ref_offset(WASMLoaderContext *ctx, uint8 pop_cnt,
uint8 type_push, uint8 type_pop,
bool disable_emit, int16 operand_offset,
char *error_buf, uint32 error_buf_size)
{
if (!wasm_loader_push_pop_frame_offset(ctx, pop_cnt, type_push, type_pop,
disable_emit, operand_offset,
error_buf, error_buf_size))
return false;
if (!wasm_loader_push_pop_frame_ref(ctx, pop_cnt, type_push, type_pop,
error_buf, error_buf_size))
return false;
return true;
}
static bool
wasm_loader_get_const_offset(WASMLoaderContext *ctx, uint8 type,
void *value, int16 *offset,
char *error_buf, uint32 error_buf_size)
{
int16 operand_offset = 0;
Const *c;
for (c = (Const *)ctx->const_buf;
(uint8*)c < ctx->const_buf + ctx->num_const * sizeof(Const); c ++) {
if ((type == c->value_type)
&& ((type == VALUE_TYPE_I64 && *(int64*)value == c->value.i64)
|| (type == VALUE_TYPE_I32 && *(int32*)value == c->value.i32)
|| (type == VALUE_TYPE_F64
&& (0 == memcmp(value, &(c->value.f64), sizeof(float64))))
|| (type == VALUE_TYPE_F32
&& (0 == memcmp(value, &(c->value.f32), sizeof(float32)))))) {
operand_offset = c->slot_index;
break;
}
if (c->value_type == VALUE_TYPE_I64
|| c->value_type == VALUE_TYPE_F64)
operand_offset += 2;
else
operand_offset += 1;
}
if ((uint8 *)c == ctx->const_buf + ctx->num_const * sizeof(Const)) {
if ((uint8 *)c == ctx->const_buf + ctx->const_buf_size) {
MEM_REALLOC(ctx->const_buf,
ctx->const_buf_size,
ctx->const_buf_size + 4 * sizeof(Const));
ctx->const_buf_size += 4 * sizeof(Const);
c = (Const *)(ctx->const_buf + ctx->num_const * sizeof(Const));
}
c->value_type = type;
switch (type) {
case VALUE_TYPE_F64:
bh_memcpy_s(&(c->value.f64), sizeof(WASMValue), value, sizeof(float64));
ctx->const_cell_num += 2;
/* The const buf will be reversed, we use the second cell */
/* of the i64/f64 const so the finnal offset is corrent */
operand_offset ++;
break;
case VALUE_TYPE_I64:
c->value.i64 = *(int64*)value;
ctx->const_cell_num += 2;
operand_offset ++;
break;
case VALUE_TYPE_F32:
bh_memcpy_s(&(c->value.f32), sizeof(WASMValue), value, sizeof(float32));
ctx->const_cell_num ++;
break;
case VALUE_TYPE_I32:
c->value.i32 = *(int32*)value;
ctx->const_cell_num ++;
break;
default:
break;
}
c->slot_index = operand_offset;
ctx->num_const ++;
LOG_OP("#### new const [%d]: %ld\n",
ctx->num_const, (int64)c->value.i64);
}
/* use negetive index for const */
operand_offset = -(operand_offset + 1);
*offset = operand_offset;
return true;
fail:
return false;
}
/*
PUSH(POP)_XXX = push(pop) frame_ref + push(pop) frame_offset
-- Mostly used for the binary / compare operation
PUSH(POP)_OFFSET_TYPE only push(pop) the frame_offset stack
-- Mostly used in block / control instructions
The POP will always emit the offset on the top of the frame_offset stack
PUSH can be used in two ways:
1. directly PUSH:
PUSH_XXX();
will allocate a dynamic space and emit
2. silent PUSH:
operand_offset = xxx; disable_emit = true;
PUSH_XXX();
only push the frame_offset stack, no emit
*/
#define PUSH_I32() do { \
if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_I32, \
disable_emit, operand_offset,\
error_buf, error_buf_size)) \
goto fail; \
} while (0)
#define PUSH_F32() do { \
if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_F32, \
disable_emit, operand_offset,\
error_buf, error_buf_size)) \
goto fail; \
} while (0)
#define PUSH_I64() do { \
if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_I64, \
disable_emit, operand_offset,\
error_buf, error_buf_size)) \
goto fail; \
} while (0)
#define PUSH_F64() do { \
if (!wasm_loader_push_frame_ref_offset(loader_ctx, VALUE_TYPE_F64, \
disable_emit, operand_offset,\
error_buf, error_buf_size)) \
goto fail; \
} while (0)
#define POP_I32() do { \
if (!wasm_loader_pop_frame_ref_offset(loader_ctx, VALUE_TYPE_I32, \
error_buf, error_buf_size)) \
goto fail; \
} while (0)
#define POP_F32() do { \
if (!wasm_loader_pop_frame_ref_offset(loader_ctx, VALUE_TYPE_F32, \
error_buf, error_buf_size)) \
goto fail; \
} while (0)
#define POP_I64() do { \
if (!wasm_loader_pop_frame_ref_offset(loader_ctx, VALUE_TYPE_I64, \
error_buf, error_buf_size)) \
goto fail; \
} while (0)
#define POP_F64() do { \
if (!wasm_loader_pop_frame_ref_offset(loader_ctx, VALUE_TYPE_F64, \
error_buf, error_buf_size)) \
goto fail; \
} while (0)
#define PUSH_OFFSET_TYPE(type) do { \
if (!(wasm_loader_push_frame_offset(loader_ctx, type, \
disable_emit, operand_offset, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#define POP_OFFSET_TYPE(type) do { \
if (!(wasm_loader_pop_frame_offset(loader_ctx, type, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#define POP_AND_PUSH(type_pop, type_push) do { \
if (!(wasm_loader_push_pop_frame_ref_offset(loader_ctx, 1, \
type_push, type_pop, \
disable_emit, operand_offset, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
/* type of POPs should be the same */
#define POP2_AND_PUSH(type_pop, type_push) do { \
if (!(wasm_loader_push_pop_frame_ref_offset(loader_ctx, 2, \
type_push, type_pop, \
disable_emit, operand_offset, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#else /* WASM_ENABLE_FAST_INTERP */
#define PUSH_I32() do { \
if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_I32, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#define PUSH_F32() do { \
if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_F32, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#define PUSH_I64() do { \
if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_I64, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#define PUSH_F64() do { \
if (!(wasm_loader_push_frame_ref(loader_ctx, VALUE_TYPE_F64, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#define POP_I32() do { \
if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_I32, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#define POP_F32() do { \
if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_F32, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#define POP_I64() do { \
if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_I64, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#define POP_F64() do { \
if (!(wasm_loader_pop_frame_ref(loader_ctx, VALUE_TYPE_F64, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#define POP_AND_PUSH(type_pop, type_push) do { \
if (!(wasm_loader_push_pop_frame_ref(loader_ctx, 1, \
type_push, type_pop, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
/* type of POPs should be the same */
#define POP2_AND_PUSH(type_pop, type_push) do { \
if (!(wasm_loader_push_pop_frame_ref(loader_ctx, 2, \
type_push, type_pop, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#endif /* WASM_ENABLE_FAST_INTERP */
#if WASM_ENABLE_FAST_INTERP != 0
static bool
reserve_block_ret(WASMLoaderContext *loader_ctx, uint8 opcode, bool disable_emit,
char *error_buf, uint32 error_buf_size)
{
int16 operand_offset = 0;
uint8 block_depth = 0;
if (opcode == WASM_OP_ELSE)
block_depth = 1;
else
block_depth = 0;
if ((loader_ctx->frame_csp - block_depth)->return_type != VALUE_TYPE_VOID) {
uint8 return_cells;
if ((loader_ctx->frame_csp - block_depth)->return_type == VALUE_TYPE_I32
|| (loader_ctx->frame_csp - block_depth)->return_type == VALUE_TYPE_F32)
return_cells = 1;
else
return_cells = 2;
if ((loader_ctx->frame_csp - block_depth)->dynamic_offset !=
*(loader_ctx->frame_offset - return_cells)) {
/* insert op_copy before else opcode */
if (opcode == WASM_OP_ELSE)
skip_label();
if (return_cells == 1)
emit_label(EXT_OP_COPY_STACK_TOP);
else
emit_label(EXT_OP_COPY_STACK_TOP_I64);
emit_operand(loader_ctx, *(loader_ctx->frame_offset - return_cells));
emit_operand(loader_ctx, (loader_ctx->frame_csp - block_depth)->dynamic_offset);
if (opcode == WASM_OP_ELSE) {
*(loader_ctx->frame_offset - return_cells) =
(loader_ctx->frame_csp - block_depth)->dynamic_offset;
}
else {
loader_ctx->frame_offset -= return_cells;
loader_ctx->dynamic_offset = loader_ctx->frame_csp->dynamic_offset;
PUSH_OFFSET_TYPE((loader_ctx->frame_csp - block_depth)->return_type);
wasm_loader_emit_backspace(loader_ctx, sizeof(int16));
}
if (opcode == WASM_OP_ELSE)
emit_label(opcode);
}
}
return true;
fail:
return false;
}
#endif /* WASM_ENABLE_FAST_INTERP */
#define RESERVE_BLOCK_RET() do { \
if (!reserve_block_ret(loader_ctx, opcode, disable_emit, \
error_buf, error_buf_size)) \
goto fail; \
} while (0)
#define PUSH_TYPE(type) do { \
if (!(wasm_loader_push_frame_ref(loader_ctx, type, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#define POP_TYPE(type) do { \
if (!(wasm_loader_pop_frame_ref(loader_ctx, type, \
error_buf, error_buf_size))) \
goto fail; \
} while (0)
#define PUSH_CSP(type, ret_type, _start_addr) do { \
if (!wasm_loader_push_frame_csp(loader_ctx, type, ret_type, \
_start_addr, error_buf, \
error_buf_size)) \
goto fail; \
} while (0)
#define POP_CSP() do { \
if (!wasm_loader_pop_frame_csp(loader_ctx, \
error_buf, error_buf_size)) \
goto fail; \
} while (0)
#define GET_LOCAL_INDEX_TYPE_AND_OFFSET() do { \
read_leb_uint32(p, p_end, local_idx); \
bh_assert(local_idx < param_count + local_count);\
local_type = local_idx < param_count \
? param_types[local_idx] \
: local_types[local_idx - param_count]; \
local_offset = local_offsets[local_idx]; \
} while (0)
#define CHECK_BR(depth) do { \
if (!wasm_loader_check_br(loader_ctx, depth, \
error_buf, error_buf_size)) \
goto fail; \
} while (0)
#define CHECK_MEMORY() do { \
bh_assert(module->import_memory_count \
+ module->memory_count > 0); \
} while (0)
#define CHECK_BLOCK_TYPE(type) do { \
bh_assert(type == VALUE_TYPE_I32 \
|| type == VALUE_TYPE_I64 \
|| type == VALUE_TYPE_F32 \
|| type == VALUE_TYPE_F64 \
|| type == VALUE_TYPE_VOID); \
} while (0)
static BranchBlock *
check_branch_block(WASMLoaderContext *loader_ctx,
uint8 **p_buf, uint8 *buf_end,
char *error_buf, uint32 error_buf_size)
{
uint8 *p = *p_buf, *p_end = buf_end;
BranchBlock *frame_csp_tmp;
uint32 depth;
read_leb_uint32(p, p_end, depth);
CHECK_BR(depth);
frame_csp_tmp = loader_ctx->frame_csp - depth - 1;
#if WASM_ENABLE_FAST_INTERP != 0
emit_br_info(frame_csp_tmp);
#endif
*p_buf = p;
return frame_csp_tmp;
fail:
return NULL;
}
static bool
check_branch_block_ret(WASMLoaderContext *loader_ctx,
BranchBlock *frame_csp_tmp,
char *error_buf, uint32 error_buf_size)
{
#if WASM_ENABLE_FAST_INTERP != 0
BranchBlock *cur_block = loader_ctx->frame_csp - 1;
bool disable_emit = true;
int16 operand_offset = 0;
#endif
if (frame_csp_tmp->block_type != BLOCK_TYPE_LOOP) {
uint8 block_return_type = frame_csp_tmp->return_type;
#if WASM_ENABLE_FAST_INTERP != 0
/* If the stack is in polymorphic state, do fake pop and push on
offset stack to keep the depth of offset stack to be the same
with ref stack */
if (cur_block->is_stack_polymorphic) {
POP_OFFSET_TYPE(block_return_type);
PUSH_OFFSET_TYPE(block_return_type);
}
#endif
POP_TYPE(block_return_type);
PUSH_TYPE(block_return_type);
}
return true;
fail:
return false;
}
static bool
check_block_stack(WASMLoaderContext *ctx, BranchBlock *block,
char *error_buf, uint32 error_buf_size)
{
uint8 type = block->return_type;
int32 available_stack_cell = (int32)
(ctx->stack_cell_num - block->stack_cell_num);
if (type != VALUE_TYPE_VOID
&& available_stack_cell <= 0
&& block->is_stack_polymorphic) {
if (!(wasm_loader_push_frame_ref(ctx, type, error_buf, error_buf_size))
#if WASM_ENABLE_FAST_INTERP != 0
|| !(wasm_loader_push_frame_offset(ctx, type, true, 0, error_buf, error_buf_size))
#endif
)
return false;
return true;
}
if (type != VALUE_TYPE_VOID
&& available_stack_cell == 1
&& *(ctx->frame_ref - 1) == VALUE_TYPE_ANY) {
if (type == VALUE_TYPE_I32 || type == VALUE_TYPE_F32) {
/* If the stack top is a value of any type, change its type to the
* same as block return type and return success */
*(ctx->frame_ref - 1) = type;
}
else {
if (!(wasm_loader_push_frame_ref(ctx, VALUE_TYPE_I32,
error_buf, error_buf_size))
#if WASM_ENABLE_FAST_INTERP != 0
|| !(wasm_loader_push_frame_offset(ctx, VALUE_TYPE_I32,
true, 0,
error_buf, error_buf_size))
#endif
)
return false;
*(ctx->frame_ref - 1) = *(ctx->frame_ref - 2) = type;
}
return true;
}
bh_assert(!(((type == VALUE_TYPE_I32 || type == VALUE_TYPE_F32)
&& available_stack_cell != 1)
|| ((type == VALUE_TYPE_I64 || type == VALUE_TYPE_F64)
&& available_stack_cell != 2)
|| (type == VALUE_TYPE_VOID
&& available_stack_cell > 0)));
if (!check_stack_top_values(ctx->frame_ref, available_stack_cell,
type, error_buf, error_buf_size))
return false;
return true;
}
/* reset the stack to the state of before entering the last block */
#if WASM_ENABLE_FAST_INTERP != 0
#define RESET_STACK() do { \
loader_ctx->stack_cell_num = \
(loader_ctx->frame_csp - 1)->stack_cell_num; \
loader_ctx->frame_ref = \
loader_ctx->frame_ref_bottom + loader_ctx->stack_cell_num; \
loader_ctx->frame_offset = \
loader_ctx->frame_offset_bottom + loader_ctx->stack_cell_num; \
} while (0)
#else
#define RESET_STACK() do { \
loader_ctx->stack_cell_num = \
(loader_ctx->frame_csp - 1)->stack_cell_num; \
loader_ctx->frame_ref = \
loader_ctx->frame_ref_bottom + loader_ctx->stack_cell_num; \
} while (0)
#endif
/* set current block's stack polymorphic state */
#define SET_CUR_BLOCK_STACK_POLYMORPHIC_STATE(flag) do { \
BranchBlock *cur_block = loader_ctx->frame_csp - 1; \
cur_block->is_stack_polymorphic = flag; \
} while (0)
static bool
wasm_loader_prepare_bytecode(WASMModule *module, WASMFunction *func,
BlockAddr *block_addr_cache,
char *error_buf, uint32 error_buf_size)
{
uint8 *p = func->code, *p_end = func->code + func->code_size, *p_org;
uint32 param_count, local_count, global_count;
uint8 *param_types, ret_type, *local_types, local_type, global_type;
uint16 *local_offsets, local_offset;
uint32 count, i, local_idx, global_idx, u32, align, mem_offset;
int32 i32, i32_const = 0;
int64 i64;
uint8 opcode, u8, block_return_type;
bool return_value = false;
WASMLoaderContext *loader_ctx;
BranchBlock *frame_csp_tmp;
#if WASM_ENABLE_BULK_MEMORY != 0
uint32 segment_index;
#endif
#if WASM_ENABLE_FAST_INTERP != 0
uint8 *func_const_end, *func_const;
int16 operand_offset;
uint8 last_op = 0;
bool disable_emit, preserve_local = false;
float32 f32;
float64 f64;
LOG_OP("\nProcessing func | [%d] params | [%d] locals | [%d] return\n",
func->param_cell_num,
func->local_cell_num,
func->ret_cell_num);
#endif
global_count = module->import_global_count + module->global_count;
param_count = func->func_type->param_count;
param_types = func->func_type->types;
ret_type = func->func_type->result_count
? param_types[param_count] : VALUE_TYPE_VOID;
local_count = func->local_count;
local_types = func->local_types;
local_offsets = func->local_offsets;
if (!(loader_ctx = wasm_loader_ctx_init(func))) {
set_error_buf(error_buf, error_buf_size,
"WASM loader prepare bytecode failed: "
"allocate memory failed");
goto fail;
}
#if WASM_ENABLE_FAST_INTERP != 0
re_scan:
if (loader_ctx->code_compiled_size > 0) {
if (!wasm_loader_ctx_reinit(loader_ctx)) {
set_error_buf(error_buf, error_buf_size,
"WASM loader prepare bytecode failed: "
"allocate memory failed");
goto fail;
}
p = func->code;
func->code_compiled = loader_ctx->p_code_compiled;
}
#endif
PUSH_CSP(BLOCK_TYPE_FUNCTION, ret_type, p);
while (p < p_end) {
opcode = *p++;
#if WASM_ENABLE_FAST_INTERP != 0
p_org = p;
disable_emit = false;
emit_label(opcode);
#endif
switch (opcode) {
case WASM_OP_UNREACHABLE:
RESET_STACK();
SET_CUR_BLOCK_STACK_POLYMORPHIC_STATE(true);
break;
case WASM_OP_NOP:
#if WASM_ENABLE_FAST_INTERP != 0
skip_label();
#endif
break;
case WASM_OP_BLOCK:
/* 0x40/0x7F/0x7E/0x7D/0x7C */
block_return_type = read_uint8(p);
CHECK_BLOCK_TYPE(block_return_type);
PUSH_CSP(BLOCK_TYPE_BLOCK, block_return_type, p);
#if WASM_ENABLE_FAST_INTERP != 0
skip_label();
#endif
break;
case WASM_OP_LOOP:
/* 0x40/0x7F/0x7E/0x7D/0x7C */
block_return_type = read_uint8(p);
CHECK_BLOCK_TYPE(block_return_type);
PUSH_CSP(BLOCK_TYPE_LOOP, block_return_type, p);
#if WASM_ENABLE_FAST_INTERP != 0
skip_label();
(loader_ctx->frame_csp - 1)->code_compiled =
loader_ctx->p_code_compiled;
#endif
break;
case WASM_OP_IF:
POP_I32();
/* 0x40/0x7F/0x7E/0x7D/0x7C */
block_return_type = read_uint8(p);
CHECK_BLOCK_TYPE(block_return_type);
PUSH_CSP(BLOCK_TYPE_IF, block_return_type, p);
#if WASM_ENABLE_FAST_INTERP != 0
emit_empty_label_addr_and_frame_ip(PATCH_ELSE);
emit_empty_label_addr_and_frame_ip(PATCH_END);
#endif
break;
case WASM_OP_ELSE:
bh_assert(loader_ctx->csp_num >= 2
&& (loader_ctx->frame_csp - 1)->block_type
== BLOCK_TYPE_IF);
/* check whether if branch's stack matches its result type */
if (!check_block_stack(loader_ctx, loader_ctx->frame_csp - 1,
error_buf, error_buf_size))
goto fail;
(loader_ctx->frame_csp - 1)->else_addr = p - 1;
#if WASM_ENABLE_FAST_INTERP != 0
/* if the result of if branch is in local or const area, add a copy op */
RESERVE_BLOCK_RET();
emit_empty_label_addr_and_frame_ip(PATCH_END);
apply_label_patch(loader_ctx, 1, PATCH_ELSE);
#endif
RESET_STACK();
SET_CUR_BLOCK_STACK_POLYMORPHIC_STATE(false);
break;
case WASM_OP_END:
{
/* check whether block stack matches its result type */
if (!check_block_stack(loader_ctx, loader_ctx->frame_csp - 1,
error_buf, error_buf_size))
goto fail;
/* if has return value, but no else branch, fail */
bh_assert(!((loader_ctx->frame_csp - 1)->block_type == BLOCK_TYPE_IF
&& (loader_ctx->frame_csp - 1)->return_type != VALUE_TYPE_VOID
&& !(loader_ctx->frame_csp - 1)->else_addr));
POP_CSP();
#if WASM_ENABLE_FAST_INTERP != 0
skip_label();
/* copy the result to the block return address */
RESERVE_BLOCK_RET();
apply_label_patch(loader_ctx, 0, PATCH_END);
free_label_patch_list(loader_ctx->frame_csp);
if (loader_ctx->frame_csp->block_type == BLOCK_TYPE_FUNCTION) {
emit_label(WASM_OP_RETURN);
POP_OFFSET_TYPE(loader_ctx->frame_csp->return_type);
}
#endif
if (loader_ctx->csp_num > 0) {
loader_ctx->frame_csp->end_addr = p - 1;
}
else {
/* end of function block, function will return,
ignore the following bytecodes */
p = p_end;
continue;
}
SET_CUR_BLOCK_STACK_POLYMORPHIC_STATE(false);
break;
}
case WASM_OP_BR:
{
if (!(frame_csp_tmp = check_branch_block(loader_ctx, &p, p_end,
error_buf, error_buf_size)))
goto fail;
if (!check_branch_block_ret(loader_ctx, frame_csp_tmp,
error_buf, error_buf_size))
goto fail;
RESET_STACK();
SET_CUR_BLOCK_STACK_POLYMORPHIC_STATE(true);
break;
}
case WASM_OP_BR_IF:
{
POP_I32();
if (!(frame_csp_tmp = check_branch_block(loader_ctx, &p, p_end,
error_buf, error_buf_size)))
goto fail;
if (!check_branch_block_ret(loader_ctx, frame_csp_tmp,
error_buf, error_buf_size))
goto fail;
break;
}
case WASM_OP_BR_TABLE:
{
uint8 ret_type;
read_leb_uint32(p, p_end, count);
#if WASM_ENABLE_FAST_INTERP != 0
Implement memory access bound check with hardware trap for 64-bit platforms (#293) Also implement native stack overflow check with hardware trap for 64-bit platforms Refine classic interpreter and fast interpreter to improve performance Update document
2020-06-28 15:41:25 +08:00
emit_uint32(loader_ctx, count);
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
#endif
POP_I32();
/* TODO: check the const */
for (i = 0; i <= count; i++) {
if (!(frame_csp_tmp = check_branch_block(loader_ctx, &p, p_end,
error_buf, error_buf_size)))
goto fail;
if (!check_branch_block_ret(loader_ctx, frame_csp_tmp,
error_buf, error_buf_size))
goto fail;
if (i == 0) {
ret_type = frame_csp_tmp->block_type == BLOCK_TYPE_LOOP ?
VALUE_TYPE_VOID : frame_csp_tmp->return_type;
}
else {
/* Check whether all table items have the same return type */
uint8 tmp_ret_type = frame_csp_tmp->block_type == BLOCK_TYPE_LOOP ?
VALUE_TYPE_VOID : frame_csp_tmp->return_type;
bh_assert(ret_type == tmp_ret_type);
(void)tmp_ret_type;
}
}
RESET_STACK();
SET_CUR_BLOCK_STACK_POLYMORPHIC_STATE(true);
(void)ret_type;
break;
}
case WASM_OP_RETURN:
{
POP_TYPE(ret_type);
PUSH_TYPE(ret_type);
#if WASM_ENABLE_FAST_INTERP != 0
// emit the offset after return opcode
POP_OFFSET_TYPE(ret_type);
#endif
RESET_STACK();
SET_CUR_BLOCK_STACK_POLYMORPHIC_STATE(true);
break;
}
case WASM_OP_CALL:
{
WASMType *func_type;
uint32 func_idx;
int32 idx;
read_leb_uint32(p, p_end, func_idx);
#if WASM_ENABLE_FAST_INTERP != 0
// we need to emit func_idx before arguments
Implement memory access bound check with hardware trap for 64-bit platforms (#293) Also implement native stack overflow check with hardware trap for 64-bit platforms Refine classic interpreter and fast interpreter to improve performance Update document
2020-06-28 15:41:25 +08:00
emit_uint32(loader_ctx, func_idx);
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
#endif
bh_assert(func_idx < module->import_function_count
+ module->function_count);
if (func_idx < module->import_function_count)
func_type = module->import_functions[func_idx].u.function.func_type;
else
func_type =
module->functions[func_idx - module->import_function_count]->func_type;
if (func_type->param_count > 0) {
for (idx = (int32)(func_type->param_count - 1); idx >= 0; idx--) {
POP_TYPE(func_type->types[idx]);
#if WASM_ENABLE_FAST_INTERP != 0
POP_OFFSET_TYPE(func_type->types[idx]);
#endif
}
}
if (func_type->result_count) {
PUSH_TYPE(func_type->types[func_type->param_count]);
#if WASM_ENABLE_FAST_INTERP != 0
PUSH_OFFSET_TYPE(func_type->types[func_type->param_count]);
#endif
}
func->has_op_func_call = true;
break;
}
case WASM_OP_CALL_INDIRECT:
{
int32 idx;
WASMType *func_type;
uint32 type_idx;
bh_assert(module->import_table_count
+ module->table_count > 0);
read_leb_uint32(p, p_end, type_idx);
#if WASM_ENABLE_FAST_INTERP != 0
// we need to emit func_idx before arguments
Implement memory access bound check with hardware trap for 64-bit platforms (#293) Also implement native stack overflow check with hardware trap for 64-bit platforms Refine classic interpreter and fast interpreter to improve performance Update document
2020-06-28 15:41:25 +08:00
emit_uint32(loader_ctx, type_idx);
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
#endif
/* reserved byte 0x00 */
bh_assert(*p == 0x00);
p++;
POP_I32();
bh_assert(type_idx < module->type_count);
func_type = module->types[type_idx];
if (func_type->param_count > 0) {
for (idx = (int32)(func_type->param_count - 1); idx >= 0; idx--) {
POP_TYPE(func_type->types[idx]);
#if WASM_ENABLE_FAST_INTERP != 0
POP_OFFSET_TYPE(func_type->types[idx]);
#endif
}
}
if (func_type->result_count > 0) {
PUSH_TYPE(func_type->types[func_type->param_count]);
#if WASM_ENABLE_FAST_INTERP != 0
PUSH_OFFSET_TYPE(func_type->types[func_type->param_count]);
#endif
}
func->has_op_func_call = true;
break;
}
case WASM_OP_DROP:
case WASM_OP_DROP_64:
{
BranchBlock *cur_block = loader_ctx->frame_csp - 1;
int32 available_stack_cell = (int32)
(loader_ctx->stack_cell_num - cur_block->stack_cell_num);
bh_assert(!(available_stack_cell <= 0
&& !cur_block->is_stack_polymorphic));
if (available_stack_cell > 0) {
if (*(loader_ctx->frame_ref - 1) == REF_I32
|| *(loader_ctx->frame_ref - 1) == REF_F32) {
loader_ctx->frame_ref--;
loader_ctx->stack_cell_num--;
#if WASM_ENABLE_FAST_INTERP != 0
skip_label();
loader_ctx->frame_offset--;
if (*(loader_ctx->frame_offset) >
loader_ctx->start_dynamic_offset)
loader_ctx->dynamic_offset --;
#endif
}
else {
loader_ctx->frame_ref -= 2;
loader_ctx->stack_cell_num -= 2;
#if (WASM_ENABLE_FAST_INTERP == 0) || (WASM_ENABLE_JIT != 0)
*(p - 1) = WASM_OP_DROP_64;
#endif
#if WASM_ENABLE_FAST_INTERP != 0
skip_label();
loader_ctx->frame_offset -= 2;
if (*(loader_ctx->frame_offset) >
loader_ctx->start_dynamic_offset)
loader_ctx->dynamic_offset -= 2;
#endif
}
}
else {
#if WASM_ENABLE_FAST_INTERP != 0
skip_label();
#endif
}
break;
}
case WASM_OP_SELECT:
case WASM_OP_SELECT_64:
{
uint8 ref_type;
BranchBlock *cur_block = loader_ctx->frame_csp - 1;
int32 available_stack_cell;
POP_I32();
available_stack_cell = (int32)
(loader_ctx->stack_cell_num - cur_block->stack_cell_num);
bh_assert(!(available_stack_cell <= 0
&& !cur_block->is_stack_polymorphic));
if (available_stack_cell > 0) {
switch (*(loader_ctx->frame_ref - 1)) {
case REF_I32:
case REF_F32:
break;
case REF_I64_2:
case REF_F64_2:
#if (WASM_ENABLE_FAST_INTERP == 0) || (WASM_ENABLE_JIT != 0)
*(p - 1) = WASM_OP_SELECT_64;
#endif
#if WASM_ENABLE_FAST_INTERP != 0
if (loader_ctx->p_code_compiled) {
#if WASM_ENABLE_ABS_LABEL_ADDR != 0
*(void**)(loader_ctx->p_code_compiled - 2 - sizeof(void*)) =
handle_table[WASM_OP_SELECT_64];
#else
*((int16*)loader_ctx->p_code_compiled - 2) = (int16)
(handle_table[WASM_OP_SELECT_64] - handle_table[0]);
#endif
}
#endif
break;
}
ref_type = *(loader_ctx->frame_ref - 1);
#if WASM_ENABLE_FAST_INTERP != 0
POP_OFFSET_TYPE(ref_type);
#endif
POP_TYPE(ref_type);
#if WASM_ENABLE_FAST_INTERP != 0
POP_OFFSET_TYPE(ref_type);
#endif
POP_TYPE(ref_type);
#if WASM_ENABLE_FAST_INTERP != 0
PUSH_OFFSET_TYPE(ref_type);
#endif
PUSH_TYPE(ref_type);
}
else {
#if WASM_ENABLE_FAST_INTERP != 0
PUSH_OFFSET_TYPE(VALUE_TYPE_ANY);
#endif
PUSH_TYPE(VALUE_TYPE_ANY);
}
break;
}
case WASM_OP_GET_LOCAL:
{
p_org = p - 1;
GET_LOCAL_INDEX_TYPE_AND_OFFSET();
PUSH_TYPE(local_type);
#if WASM_ENABLE_FAST_INTERP != 0
/* Get Local is optimized out */
skip_label();
disable_emit = true;
operand_offset = local_offset;
PUSH_OFFSET_TYPE(local_type);
#else
#if (WASM_ENABLE_WAMR_COMPILER == 0) && (WASM_ENABLE_JIT == 0)
if (local_offset < 0x80) {
*p_org++ = EXT_OP_GET_LOCAL_FAST;
if (local_type == VALUE_TYPE_I32
|| local_type == VALUE_TYPE_F32)
*p_org++ = (uint8)local_offset;
else
*p_org++ = (uint8)(local_offset | 0x80);
while (p_org < p)
*p_org++ = WASM_OP_NOP;
}
#endif
#endif
break;
}
case WASM_OP_SET_LOCAL:
{
p_org = p - 1;
GET_LOCAL_INDEX_TYPE_AND_OFFSET();
POP_TYPE(local_type);
#if WASM_ENABLE_FAST_INTERP != 0
if (!(preserve_referenced_local(loader_ctx, opcode, local_offset,
local_type, &preserve_local,
error_buf, error_buf_size)))
goto fail;
if (local_offset < 256) {
skip_label();
if ((!preserve_local) && (LAST_OP_OUTPUT_I32())) {
if (loader_ctx->p_code_compiled)
*(int16*)(loader_ctx->p_code_compiled - 2) = local_offset;
loader_ctx->frame_offset --;
loader_ctx->dynamic_offset --;
}
else if ((!preserve_local) && (LAST_OP_OUTPUT_I64())) {
if (loader_ctx->p_code_compiled)
*(int16*)(loader_ctx->p_code_compiled - 2) = local_offset;
loader_ctx->frame_offset -= 2;
loader_ctx->dynamic_offset -= 2;
}
else {
if (local_type == VALUE_TYPE_I32
|| local_type == VALUE_TYPE_F32) {
emit_label(EXT_OP_SET_LOCAL_FAST);
emit_byte(loader_ctx, local_offset);
}
else {
emit_label(EXT_OP_SET_LOCAL_FAST_I64);
emit_byte(loader_ctx, local_offset);
}
POP_OFFSET_TYPE(local_type);
}
}
else { /* local index larger than 255, reserve leb */
p_org ++;
emit_leb();
POP_OFFSET_TYPE(local_type);
}
#else
#if (WASM_ENABLE_WAMR_COMPILER == 0) && (WASM_ENABLE_JIT == 0)
if (local_offset < 0x80) {
*p_org++ = EXT_OP_SET_LOCAL_FAST;
if (local_type == VALUE_TYPE_I32
|| local_type == VALUE_TYPE_F32)
*p_org++ = (uint8)local_offset;
else
*p_org++ = (uint8)(local_offset | 0x80);
while (p_org < p)
*p_org++ = WASM_OP_NOP;
}
#endif
#endif
break;
}
case WASM_OP_TEE_LOCAL:
{
p_org = p - 1;
GET_LOCAL_INDEX_TYPE_AND_OFFSET();
#if WASM_ENABLE_FAST_INTERP != 0
/* If the stack is in polymorphic state, do fake pop and push on
offset stack to keep the depth of offset stack to be the same
with ref stack */
BranchBlock *cur_block = loader_ctx->frame_csp - 1;
if (cur_block->is_stack_polymorphic) {
POP_OFFSET_TYPE(local_type);
PUSH_OFFSET_TYPE(local_type);
}
#endif
POP_TYPE(local_type);
PUSH_TYPE(local_type);
#if WASM_ENABLE_FAST_INTERP != 0
if (!(preserve_referenced_local(loader_ctx, opcode, local_offset,
local_type, &preserve_local,
error_buf, error_buf_size)))
goto fail;
if (local_offset < 256) {
skip_label();
if (local_type == VALUE_TYPE_I32
|| local_type == VALUE_TYPE_F32) {
emit_label(EXT_OP_TEE_LOCAL_FAST);
emit_byte(loader_ctx, local_offset);
}
else {
emit_label(EXT_OP_TEE_LOCAL_FAST_I64);
emit_byte(loader_ctx, local_offset);
}
}
else { /* local index larger than 255, reserve leb */
p_org ++;
emit_leb();
}
emit_operand(loader_ctx, *(loader_ctx->frame_offset -
wasm_value_type_cell_num(local_type)));
#else
#if (WASM_ENABLE_WAMR_COMPILER == 0) && (WASM_ENABLE_JIT == 0)
if (local_offset < 0x80) {
*p_org++ = EXT_OP_TEE_LOCAL_FAST;
if (local_type == VALUE_TYPE_I32
|| local_type == VALUE_TYPE_F32)
*p_org++ = (uint8)local_offset;
else
*p_org++ = (uint8)(local_offset | 0x80);
while (p_org < p)
*p_org++ = WASM_OP_NOP;
}
#endif
#endif
break;
}
case WASM_OP_GET_GLOBAL:
{
read_leb_uint32(p, p_end, global_idx);
bh_assert(global_idx < global_count);
global_type = global_idx < module->import_global_count
? module->import_globals[global_idx].u.global.type
:module->globals[global_idx - module->import_global_count].type;
PUSH_TYPE(global_type);
#if WASM_ENABLE_FAST_INTERP != 0
Implement memory access bound check with hardware trap for 64-bit platforms (#293) Also implement native stack overflow check with hardware trap for 64-bit platforms Refine classic interpreter and fast interpreter to improve performance Update document
2020-06-28 15:41:25 +08:00
emit_uint32(loader_ctx, global_idx);
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
PUSH_OFFSET_TYPE(global_type);
#endif
break;
}
case WASM_OP_SET_GLOBAL:
{
bool is_mutable = false;
read_leb_uint32(p, p_end, global_idx);
bh_assert(global_idx < global_count);
is_mutable =
global_idx < module->import_global_count
? module->import_globals[global_idx].u.global.is_mutable
: module->globals[global_idx - module->import_global_count]
.is_mutable;
bh_assert(is_mutable);
global_type =
global_idx < module->import_global_count
? module->import_globals[global_idx].u.global.type
: module->globals[global_idx - module->import_global_count]
.type;
POP_TYPE(global_type);
#if WASM_ENABLE_FAST_INTERP != 0
Implement memory access bound check with hardware trap for 64-bit platforms (#293) Also implement native stack overflow check with hardware trap for 64-bit platforms Refine classic interpreter and fast interpreter to improve performance Update document
2020-06-28 15:41:25 +08:00
emit_uint32(loader_ctx, global_idx);
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
POP_OFFSET_TYPE(global_type);
#endif
(void)is_mutable;
break;
}
/* load */
case WASM_OP_I32_LOAD:
case WASM_OP_I32_LOAD8_S:
case WASM_OP_I32_LOAD8_U:
case WASM_OP_I32_LOAD16_S:
case WASM_OP_I32_LOAD16_U:
case WASM_OP_I64_LOAD:
case WASM_OP_I64_LOAD8_S:
case WASM_OP_I64_LOAD8_U:
case WASM_OP_I64_LOAD16_S:
case WASM_OP_I64_LOAD16_U:
case WASM_OP_I64_LOAD32_S:
case WASM_OP_I64_LOAD32_U:
case WASM_OP_F32_LOAD:
case WASM_OP_F64_LOAD:
/* store */
case WASM_OP_I32_STORE:
case WASM_OP_I32_STORE8:
case WASM_OP_I32_STORE16:
case WASM_OP_I64_STORE:
case WASM_OP_I64_STORE8:
case WASM_OP_I64_STORE16:
case WASM_OP_I64_STORE32:
case WASM_OP_F32_STORE:
case WASM_OP_F64_STORE:
{
#if WASM_ENABLE_FAST_INTERP != 0
/* change F32/F64 into I32/I64 */
if (opcode == WASM_OP_F32_LOAD) {
skip_label();
emit_label(WASM_OP_I32_LOAD);
}
else if (opcode == WASM_OP_F64_LOAD) {
skip_label();
emit_label(WASM_OP_I64_LOAD);
}
else if (opcode == WASM_OP_F32_STORE) {
skip_label();
emit_label(WASM_OP_I32_STORE);
}
else if (opcode == WASM_OP_F64_STORE) {
skip_label();
emit_label(WASM_OP_I64_STORE);
}
#endif
CHECK_MEMORY();
read_leb_uint32(p, p_end, align); /* align */
read_leb_uint32(p, p_end, mem_offset); /* offset */
#if WASM_ENABLE_FAST_INTERP != 0
Implement memory access bound check with hardware trap for 64-bit platforms (#293) Also implement native stack overflow check with hardware trap for 64-bit platforms Refine classic interpreter and fast interpreter to improve performance Update document
2020-06-28 15:41:25 +08:00
emit_uint32(loader_ctx, mem_offset);
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
#endif
switch (opcode)
{
/* load */
case WASM_OP_I32_LOAD:
case WASM_OP_I32_LOAD8_S:
case WASM_OP_I32_LOAD8_U:
case WASM_OP_I32_LOAD16_S:
case WASM_OP_I32_LOAD16_U:
POP_AND_PUSH(VALUE_TYPE_I32, VALUE_TYPE_I32);
break;
case WASM_OP_I64_LOAD:
case WASM_OP_I64_LOAD8_S:
case WASM_OP_I64_LOAD8_U:
case WASM_OP_I64_LOAD16_S:
case WASM_OP_I64_LOAD16_U:
case WASM_OP_I64_LOAD32_S:
case WASM_OP_I64_LOAD32_U:
POP_AND_PUSH(VALUE_TYPE_I32, VALUE_TYPE_I64);
break;
case WASM_OP_F32_LOAD:
POP_AND_PUSH(VALUE_TYPE_I32, VALUE_TYPE_F32);
break;
case WASM_OP_F64_LOAD:
POP_AND_PUSH(VALUE_TYPE_I32, VALUE_TYPE_F64);
break;
/* store */
case WASM_OP_I32_STORE:
case WASM_OP_I32_STORE8:
case WASM_OP_I32_STORE16:
POP_I32();
POP_I32();
break;
case WASM_OP_I64_STORE:
case WASM_OP_I64_STORE8:
case WASM_OP_I64_STORE16:
case WASM_OP_I64_STORE32:
POP_I64();
POP_I32();
break;
case WASM_OP_F32_STORE:
POP_F32();
POP_I32();
break;
case WASM_OP_F64_STORE:
POP_F64();
POP_I32();
break;
default:
break;
}
break;
}
case WASM_OP_MEMORY_SIZE:
CHECK_MEMORY();
/* reserved byte 0x00 */
bh_assert(*p == 0x00);
p++;
PUSH_I32();
break;
case WASM_OP_MEMORY_GROW:
CHECK_MEMORY();
/* reserved byte 0x00 */
bh_assert(*p == 0x00);
p++;
POP_AND_PUSH(VALUE_TYPE_I32, VALUE_TYPE_I32);
func->has_op_memory_grow = true;
module->possible_memory_grow = true;
break;
case WASM_OP_I32_CONST:
read_leb_int32(p, p_end, i32_const);
#if WASM_ENABLE_FAST_INTERP != 0
skip_label();
disable_emit = true;
GET_CONST_OFFSET(VALUE_TYPE_I32, i32_const);
#else
(void)i32_const;
#endif
PUSH_I32();
break;
case WASM_OP_I64_CONST:
read_leb_int64(p, p_end, i64);
#if WASM_ENABLE_FAST_INTERP != 0
skip_label();
disable_emit = true;
GET_CONST_OFFSET(VALUE_TYPE_I64, i64);
#endif
PUSH_I64();
break;
case WASM_OP_F32_CONST:
p += sizeof(float32);
#if WASM_ENABLE_FAST_INTERP != 0
skip_label();
disable_emit = true;
bh_memcpy_s((uint8*)&f32, sizeof(float32), p_org, sizeof(float32));
GET_CONST_F32_OFFSET(VALUE_TYPE_F32, f32);
#endif
PUSH_F32();
break;
case WASM_OP_F64_CONST:
p += sizeof(float64);
#if WASM_ENABLE_FAST_INTERP != 0
skip_label();
disable_emit = true;
/* Some MCU may require 8-byte align */
bh_memcpy_s((uint8*)&f64, sizeof(float64), p_org, sizeof(float64));
GET_CONST_F64_OFFSET(VALUE_TYPE_F64, f64);
#endif
PUSH_F64();
break;
case WASM_OP_I32_EQZ:
POP_AND_PUSH(VALUE_TYPE_I32, VALUE_TYPE_I32);
break;
case WASM_OP_I32_EQ:
case WASM_OP_I32_NE:
case WASM_OP_I32_LT_S:
case WASM_OP_I32_LT_U:
case WASM_OP_I32_GT_S:
case WASM_OP_I32_GT_U:
case WASM_OP_I32_LE_S:
case WASM_OP_I32_LE_U:
case WASM_OP_I32_GE_S:
case WASM_OP_I32_GE_U:
POP2_AND_PUSH(VALUE_TYPE_I32, VALUE_TYPE_I32);
break;
case WASM_OP_I64_EQZ:
POP_AND_PUSH(VALUE_TYPE_I64, VALUE_TYPE_I32);
break;
case WASM_OP_I64_EQ:
case WASM_OP_I64_NE:
case WASM_OP_I64_LT_S:
case WASM_OP_I64_LT_U:
case WASM_OP_I64_GT_S:
case WASM_OP_I64_GT_U:
case WASM_OP_I64_LE_S:
case WASM_OP_I64_LE_U:
case WASM_OP_I64_GE_S:
case WASM_OP_I64_GE_U:
POP2_AND_PUSH(VALUE_TYPE_I64, VALUE_TYPE_I32);
break;
case WASM_OP_F32_EQ:
case WASM_OP_F32_NE:
case WASM_OP_F32_LT:
case WASM_OP_F32_GT:
case WASM_OP_F32_LE:
case WASM_OP_F32_GE:
POP2_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_I32);
break;
case WASM_OP_F64_EQ:
case WASM_OP_F64_NE:
case WASM_OP_F64_LT:
case WASM_OP_F64_GT:
case WASM_OP_F64_LE:
case WASM_OP_F64_GE:
POP2_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_I32);
break;
case WASM_OP_I32_CLZ:
case WASM_OP_I32_CTZ:
case WASM_OP_I32_POPCNT:
POP_AND_PUSH(VALUE_TYPE_I32, VALUE_TYPE_I32);
break;
case WASM_OP_I32_ADD:
case WASM_OP_I32_SUB:
case WASM_OP_I32_MUL:
case WASM_OP_I32_DIV_S:
case WASM_OP_I32_DIV_U:
case WASM_OP_I32_REM_S:
case WASM_OP_I32_REM_U:
case WASM_OP_I32_AND:
case WASM_OP_I32_OR:
case WASM_OP_I32_XOR:
case WASM_OP_I32_SHL:
case WASM_OP_I32_SHR_S:
case WASM_OP_I32_SHR_U:
case WASM_OP_I32_ROTL:
case WASM_OP_I32_ROTR:
POP2_AND_PUSH(VALUE_TYPE_I32, VALUE_TYPE_I32);
break;
case WASM_OP_I64_CLZ:
case WASM_OP_I64_CTZ:
case WASM_OP_I64_POPCNT:
POP_AND_PUSH(VALUE_TYPE_I64, VALUE_TYPE_I64);
break;
case WASM_OP_I64_ADD:
case WASM_OP_I64_SUB:
case WASM_OP_I64_MUL:
case WASM_OP_I64_DIV_S:
case WASM_OP_I64_DIV_U:
case WASM_OP_I64_REM_S:
case WASM_OP_I64_REM_U:
case WASM_OP_I64_AND:
case WASM_OP_I64_OR:
case WASM_OP_I64_XOR:
case WASM_OP_I64_SHL:
case WASM_OP_I64_SHR_S:
case WASM_OP_I64_SHR_U:
case WASM_OP_I64_ROTL:
case WASM_OP_I64_ROTR:
POP2_AND_PUSH(VALUE_TYPE_I64, VALUE_TYPE_I64);
break;
case WASM_OP_F32_ABS:
case WASM_OP_F32_NEG:
case WASM_OP_F32_CEIL:
case WASM_OP_F32_FLOOR:
case WASM_OP_F32_TRUNC:
case WASM_OP_F32_NEAREST:
case WASM_OP_F32_SQRT:
POP_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_F32);
break;
case WASM_OP_F32_ADD:
case WASM_OP_F32_SUB:
case WASM_OP_F32_MUL:
case WASM_OP_F32_DIV:
case WASM_OP_F32_MIN:
case WASM_OP_F32_MAX:
case WASM_OP_F32_COPYSIGN:
POP2_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_F32);
break;
case WASM_OP_F64_ABS:
case WASM_OP_F64_NEG:
case WASM_OP_F64_CEIL:
case WASM_OP_F64_FLOOR:
case WASM_OP_F64_TRUNC:
case WASM_OP_F64_NEAREST:
case WASM_OP_F64_SQRT:
POP_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_F64);
break;
case WASM_OP_F64_ADD:
case WASM_OP_F64_SUB:
case WASM_OP_F64_MUL:
case WASM_OP_F64_DIV:
case WASM_OP_F64_MIN:
case WASM_OP_F64_MAX:
case WASM_OP_F64_COPYSIGN:
POP2_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_F64);
break;
case WASM_OP_I32_WRAP_I64:
POP_AND_PUSH(VALUE_TYPE_I64, VALUE_TYPE_I32);
break;
case WASM_OP_I32_TRUNC_S_F32:
case WASM_OP_I32_TRUNC_U_F32:
POP_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_I32);
break;
case WASM_OP_I32_TRUNC_S_F64:
case WASM_OP_I32_TRUNC_U_F64:
POP_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_I32);
break;
case WASM_OP_I64_EXTEND_S_I32:
case WASM_OP_I64_EXTEND_U_I32:
POP_AND_PUSH(VALUE_TYPE_I32, VALUE_TYPE_I64);
break;
case WASM_OP_I64_TRUNC_S_F32:
case WASM_OP_I64_TRUNC_U_F32:
POP_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_I64);
break;
case WASM_OP_I64_TRUNC_S_F64:
case WASM_OP_I64_TRUNC_U_F64:
POP_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_I64);
break;
case WASM_OP_F32_CONVERT_S_I32:
case WASM_OP_F32_CONVERT_U_I32:
POP_AND_PUSH(VALUE_TYPE_I32, VALUE_TYPE_F32);
break;
case WASM_OP_F32_CONVERT_S_I64:
case WASM_OP_F32_CONVERT_U_I64:
POP_AND_PUSH(VALUE_TYPE_I64, VALUE_TYPE_F32);
break;
case WASM_OP_F32_DEMOTE_F64:
POP_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_F32);
break;
case WASM_OP_F64_CONVERT_S_I32:
case WASM_OP_F64_CONVERT_U_I32:
POP_AND_PUSH(VALUE_TYPE_I32, VALUE_TYPE_F64);
break;
case WASM_OP_F64_CONVERT_S_I64:
case WASM_OP_F64_CONVERT_U_I64:
POP_AND_PUSH(VALUE_TYPE_I64, VALUE_TYPE_F64);
break;
case WASM_OP_F64_PROMOTE_F32:
POP_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_F64);
break;
case WASM_OP_I32_REINTERPRET_F32:
POP_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_I32);
break;
case WASM_OP_I64_REINTERPRET_F64:
POP_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_I64);
break;
case WASM_OP_F32_REINTERPRET_I32:
POP_AND_PUSH(VALUE_TYPE_I32, VALUE_TYPE_F32);
break;
case WASM_OP_F64_REINTERPRET_I64:
POP_AND_PUSH(VALUE_TYPE_I64, VALUE_TYPE_F64);
break;
case WASM_OP_I32_EXTEND8_S:
case WASM_OP_I32_EXTEND16_S:
POP_AND_PUSH(VALUE_TYPE_I32, VALUE_TYPE_I32);
break;
case WASM_OP_I64_EXTEND8_S:
case WASM_OP_I64_EXTEND16_S:
case WASM_OP_I64_EXTEND32_S:
POP_AND_PUSH(VALUE_TYPE_I64, VALUE_TYPE_I64);
break;
case WASM_OP_MISC_PREFIX:
{
opcode = read_uint8(p);
#if WASM_ENABLE_FAST_INTERP != 0
emit_byte(loader_ctx, opcode);
#endif
switch (opcode)
{
case WASM_OP_I32_TRUNC_SAT_S_F32:
case WASM_OP_I32_TRUNC_SAT_U_F32:
POP_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_I32);
break;
case WASM_OP_I32_TRUNC_SAT_S_F64:
case WASM_OP_I32_TRUNC_SAT_U_F64:
POP_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_I32);
break;
case WASM_OP_I64_TRUNC_SAT_S_F32:
case WASM_OP_I64_TRUNC_SAT_U_F32:
POP_AND_PUSH(VALUE_TYPE_F32, VALUE_TYPE_I64);
break;
case WASM_OP_I64_TRUNC_SAT_S_F64:
case WASM_OP_I64_TRUNC_SAT_U_F64:
POP_AND_PUSH(VALUE_TYPE_F64, VALUE_TYPE_I64);
break;
#if WASM_ENABLE_BULK_MEMORY != 0
case WASM_OP_MEMORY_INIT:
read_leb_uint32(p, p_end, segment_index);
#if WASM_ENABLE_FAST_INTERP != 0
Implement memory access bound check with hardware trap for 64-bit platforms (#293) Also implement native stack overflow check with hardware trap for 64-bit platforms Refine classic interpreter and fast interpreter to improve performance Update document
2020-06-28 15:41:25 +08:00
emit_uint32(loader_ctx, segment_index);
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
#endif
bh_assert(module->import_memory_count
+ module->memory_count > 0);
bh_assert(*p == 0x00);
p++;
bh_assert(segment_index < module->data_seg_count);
bh_assert(module->data_seg_count1 > 0);
POP_I32();
POP_I32();
POP_I32();
break;
case WASM_OP_DATA_DROP:
read_leb_uint32(p, p_end, segment_index);
#if WASM_ENABLE_FAST_INTERP != 0
Implement memory access bound check with hardware trap for 64-bit platforms (#293) Also implement native stack overflow check with hardware trap for 64-bit platforms Refine classic interpreter and fast interpreter to improve performance Update document
2020-06-28 15:41:25 +08:00
emit_uint32(loader_ctx, segment_index);
Implement wasm mini loader and refine footprint of loader and runtime (#276)
2020-06-08 11:19:09 +08:00
#endif
bh_assert(segment_index < module->data_seg_count);
bh_assert(module->data_seg_count1 > 0);
break;
case WASM_OP_MEMORY_COPY:
/* both src and dst memory index should be 0 */
bh_assert(*(int16*)p != 0x0000);
p += 2;
bh_assert(module->import_memory_count
+ module->memory_count > 0);
POP_I32();
POP_I32();
POP_I32();
break;
case WASM_OP_MEMORY_FILL:
bh_assert(*p == 0);
p++;
bh_assert(module->import_memory_count
+ module->memory_count > 0);
POP_I32();
POP_I32();
POP_I32();
break;
/* TODO: to support bulk table operation */
#endif /* WASM_ENABLE_BULK_MEMORY */
default:
bh_assert(0);
break;
}
break;
}
default:
bh_assert(0);
break;
}
#if WASM_ENABLE_FAST_INTERP != 0
last_op = opcode;
#endif
}
if (loader_ctx->csp_num > 0) {
set_error_buf(error_buf, error_buf_size,
"WASM module load failed: "
"function body must end with END opcode.");
goto fail;
}
#if WASM_ENABLE_FAST_INTERP != 0
if (loader_ctx->p_code_compiled == NULL)
goto re_scan;
func->const_cell_num = loader_ctx->const_cell_num;
if (!(func->consts = func_const =
loader_malloc(func->const_cell_num * 4,
error_buf, error_buf_size))) {
goto fail;
}
func_const_end = func->consts + func->const_cell_num * 4;
// reverse the const buf
for (int i = loader_ctx->num_const - 1; i >= 0; i--) {
Const *c = (Const*)(loader_ctx->const_buf + i * sizeof(Const));
if (c->value_type == VALUE_TYPE_F64
|| c->value_type == VALUE_TYPE_I64) {
bh_memcpy_s(func_const, func_const_end - func_const,
&(c->value.f64), sizeof(int64));
func_const += sizeof(int64);
} else {
bh_memcpy_s(func_const, func_const_end - func_const,
&(c->value.f32), sizeof(int32));
func_const += sizeof(int32);
}
}
func->max_stack_cell_num = loader_ctx->preserved_local_offset -
loader_ctx->start_dynamic_offset + 1;
#else
func->max_stack_cell_num = loader_ctx->max_stack_cell_num;
#endif
func->max_block_num = loader_ctx->max_csp_num;
return_value = true;
fail:
wasm_loader_ctx_destroy(loader_ctx);
(void)u8;
(void)u32;
(void)i32;
(void)i64;
(void)global_count;
(void)local_count;
(void)local_offset;
(void)p_org;
(void)mem_offset;
(void)align;
return return_value;
}
Reference in New Issue Copy Permalink