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

Re-org memory allocation interfaces, add --stack-size and --heap-size option (#193)

Browse Source
This commit is contained in:
wenyongh 2020-03-10 19:54:44 +08:00 committed by GitHub
parent 381859d530
commit 0fdd49ea31
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
110 changed files with 1264 additions and 2125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -53,7 +53,7 @@ cd wamr-compiler
mkdir build && cd build mkdir build && cd build
cmake .. cmake ..
make make
ln -s ./wamrc /usr/bin/wamrc ln -s {current path}/wamrc /usr/bin/wamrc
``` ```
### Build the mini product ### Build the mini product

4
core/app-framework/app-native-shared/attr_container.c
View File

@ -16,10 +16,14 @@ typedef union jvalue {
double d; double d;
} jvalue; } jvalue;
#ifndef bh_memcpy_s
int b_memcpy_s(void * s1, unsigned int s1max,
const void * s2, unsigned int n);
#define bh_memcpy_s(dest, dlen, src, slen) do { \ #define bh_memcpy_s(dest, dlen, src, slen) do { \
int _ret = slen == 0 ? 0 : b_memcpy_s (dest, dlen, src, slen); \ int _ret = slen == 0 ? 0 : b_memcpy_s (dest, dlen, src, slen); \
(void)_ret; \ (void)_ret; \
} while (0) } while (0)
#endif
static inline int16_t get_int16(const char *buf) static inline int16_t get_int16(const char *buf)
{ {

4
core/app-framework/app-native-shared/bi-inc/attr_container.h
View File

@ -406,11 +406,11 @@ void
attr_container_dump(const attr_container_t *attr_cont); attr_container_dump(const attr_container_t *attr_cont);
#ifndef attr_container_malloc #ifndef attr_container_malloc
#define attr_container_malloc wa_malloc #define attr_container_malloc WA_MALLOC
#endif #endif
#ifndef attr_container_free #ifndef attr_container_free
#define attr_container_free wa_free #define attr_container_free WA_FREE
#endif #endif
#ifndef attr_container_printf #ifndef attr_container_printf

2
core/app-framework/app-native-shared/bi-inc/shared_utils.h
View File

@ -145,6 +145,8 @@ unpack_response(char * packet, int size, response_t * response);
void void
free_req_resp_packet(char * packet); free_req_resp_packet(char * packet);
char *
wa_strdup(const char *str);
#ifdef __cplusplus #ifdef __cplusplus

24
core/app-framework/app-native-shared/restful_utils.c
View File

@ -43,7 +43,7 @@ char * pack_request(request_t *request, int * size)
{ {
int url_len = strlen(request->url) + 1; int url_len = strlen(request->url) + 1;
int len = REQUEST_PACKET_FIX_PART_LEN + url_len + request->payload_len; int len = REQUEST_PACKET_FIX_PART_LEN + url_len + request->payload_len;
char * packet = (char*) wa_malloc(len); char * packet = (char*) WA_MALLOC(len);
if (packet == NULL) if (packet == NULL)
return NULL; return NULL;
@ -65,7 +65,7 @@ char * pack_request(request_t *request, int * size)
void free_req_resp_packet(char * packet) void free_req_resp_packet(char * packet)
{ {
wa_free(packet); WA_FREE(packet);
} }
request_t * unpack_request(char * packet, int size, request_t * request) request_t * unpack_request(char * packet, int size, request_t * request)
@ -108,7 +108,7 @@ request_t * unpack_request(char * packet, int size, request_t * request)
char * pack_response(response_t *response, int * size) char * pack_response(response_t *response, int * size)
{ {
int len = RESPONSE_PACKET_FIX_PART_LEN + response->payload_len; int len = RESPONSE_PACKET_FIX_PART_LEN + response->payload_len;
char * packet = (char*) wa_malloc(len); char * packet = (char*) WA_MALLOC(len);
if (packet == NULL) if (packet == NULL)
return NULL; return NULL;
@ -152,7 +152,7 @@ response_t * unpack_response(char * packet, int size, response_t * response)
request_t *clone_request(request_t *request) request_t *clone_request(request_t *request)
{ {
/* deep clone */ /* deep clone */
request_t *req = (request_t *) wa_malloc(sizeof(request_t)); request_t *req = (request_t *) WA_MALLOC(sizeof(request_t));
if (req == NULL) if (req == NULL)
return NULL; return NULL;
@ -169,7 +169,7 @@ request_t *clone_request(request_t *request)
req->payload_len = request->payload_len; req->payload_len = request->payload_len;
if (request->payload_len) { if (request->payload_len) {
req->payload = (char *) wa_malloc(request->payload_len); req->payload = (char *) WA_MALLOC(request->payload_len);
if (!req->payload) if (!req->payload)
goto fail; goto fail;
memcpy(req->payload, request->payload, request->payload_len); memcpy(req->payload, request->payload, request->payload_len);
@ -188,24 +188,24 @@ fail:
void request_cleaner(request_t *request) void request_cleaner(request_t *request)
{ {
if (request->url != NULL) if (request->url != NULL)
wa_free(request->url); WA_FREE(request->url);
if (request->payload != NULL && request->payload_len > 0) if (request->payload != NULL && request->payload_len > 0)
wa_free(request->payload); WA_FREE(request->payload);
wa_free(request); WA_FREE(request);
} }
void response_cleaner(response_t * response) void response_cleaner(response_t * response)
{ {
if (response->payload != NULL && response->payload_len > 0) if (response->payload != NULL && response->payload_len > 0)
wa_free(response->payload); WA_FREE(response->payload);
wa_free(response); WA_FREE(response);
} }
response_t * clone_response(response_t * response) response_t * clone_response(response_t * response)
{ {
response_t *clone = (response_t *) wa_malloc(sizeof(response_t)); response_t *clone = (response_t *) WA_MALLOC(sizeof(response_t));
if (clone == NULL) if (clone == NULL)
return NULL; return NULL;
@ -216,7 +216,7 @@ response_t * clone_response(response_t * response)
clone->reciever = response->reciever; clone->reciever = response->reciever;
clone->payload_len = response->payload_len; clone->payload_len = response->payload_len;
if (clone->payload_len) { if (clone->payload_len) {
clone->payload = (char *) wa_malloc(response->payload_len); clone->payload = (char *) WA_MALLOC(response->payload_len);
if (!clone->payload) if (!clone->payload)
goto fail; goto fail;
memcpy(clone->payload, response->payload, response->payload_len); memcpy(clone->payload, response->payload, response->payload_len);

2
core/app-framework/base/app/bh_platform.c
View File

@ -75,7 +75,7 @@ uint16 ntohs(uint16 value)
char *wa_strdup(const char *s) char *wa_strdup(const char *s)
{ {
char *s1 = NULL; char *s1 = NULL;
if (s && (s1 = wa_malloc(strlen(s) + 1))) if (s && (s1 = WA_MALLOC(strlen(s) + 1)))
memcpy(s1, s, strlen(s) + 1); memcpy(s1, s, strlen(s) + 1);
return s1; return s1;
} }

10
core/app-framework/base/app/bh_platform.h
View File

@ -25,14 +25,14 @@ typedef int int32;
#define inline __inline #define inline __inline
#endif #endif
// all wasm-app<->native shared source files should use wa_malloc/wa_free. // all wasm-app<->native shared source files should use WA_MALLOC/WA_FREE.
// they will be mapped to different implementations in each side // they will be mapped to different implementations in each side
#ifndef wa_malloc #ifndef WA_MALLOC
#define wa_malloc malloc #define WA_MALLOC malloc
#endif #endif
#ifndef wa_free #ifndef WA_FREE
#define wa_free free #define WA_FREE free
#endif #endif
char *wa_strdup(const char *s); char *wa_strdup(const char *s);

4
core/app-framework/base/native/timer_wrapper.c
View File

@ -107,7 +107,7 @@ timer_ctx_t create_wasm_timer_ctx(unsigned int module_id, int prealloc_num)
return NULL; return NULL;
timer_ctx_node_t * node = (timer_ctx_node_t*) timer_ctx_node_t * node = (timer_ctx_node_t*)
bh_malloc(sizeof(timer_ctx_node_t)); wasm_runtime_malloc(sizeof(timer_ctx_node_t));
if (node == NULL) { if (node == NULL) {
destroy_timer_ctx(ctx); destroy_timer_ctx(ctx);
return NULL; return NULL;
@ -131,7 +131,7 @@ void destroy_module_timer_ctx(unsigned int module_id)
if (timer_ctx_get_owner(elem->timer_ctx) == module_id) { if (timer_ctx_get_owner(elem->timer_ctx) == module_id) {
bh_list_remove(&g_timer_ctx_list, elem); bh_list_remove(&g_timer_ctx_list, elem);
destroy_timer_ctx(elem->timer_ctx); destroy_timer_ctx(elem->timer_ctx);
bh_free(elem); wasm_runtime_free(elem);
break; break;
} }

20
core/app-framework/connection/native/linux/connection_mgr.c
View File

@ -115,8 +115,8 @@ static void add_connection(sys_connection_t *conn)
#define FREE_CONNECTION(conn) do { \ #define FREE_CONNECTION(conn) do { \
if (conn->arg) \ if (conn->arg) \
bh_free(conn->arg); \ wasm_runtime_free(conn->arg); \
bh_free(conn); \ wasm_runtime_free(conn); \
} while (0) } while (0)
static int get_app_conns_num(uint32 module_id) static int get_app_conns_num(uint32 module_id)
@ -223,7 +223,7 @@ static uint32 _conn_open(wasm_module_inst_t module_inst,
if (get_app_conns_num(module_id) >= MAX_CONNECTION_PER_APP) if (get_app_conns_num(module_id) >= MAX_CONNECTION_PER_APP)
return -1; return -1;
conn = (sys_connection_t *)bh_malloc(sizeof(*conn)); conn = (sys_connection_t *)wasm_runtime_malloc(sizeof(*conn));
if (conn == NULL) if (conn == NULL)
return -1; return -1;
@ -296,7 +296,7 @@ static uint32 _conn_open(wasm_module_inst_t module_inst,
fail: fail:
find_connection(conn->handle, true); find_connection(conn->handle, true);
bh_free(conn); wasm_runtime_free(conn);
return -1; return -1;
} }
@ -356,7 +356,7 @@ static bool _conn_config(uint32 handle, attr_container_t *cfg)
port = attr_container_get_as_uint16(cfg, "port"); port = attr_container_get_as_uint16(cfg, "port");
if (conn->arg == NULL) { if (conn->arg == NULL) {
addr = (struct sockaddr_in *)bh_malloc(sizeof(*addr)); addr = (struct sockaddr_in *)wasm_runtime_malloc(sizeof(*addr));
if (addr == NULL) if (addr == NULL)
return false; return false;
@ -390,8 +390,8 @@ typedef struct connection_event {
static void connection_event_cleaner(connection_event_t *conn_event) static void connection_event_cleaner(connection_event_t *conn_event)
{ {
if (conn_event->data != NULL) if (conn_event->data != NULL)
bh_free(conn_event->data); wasm_runtime_free(conn_event->data);
bh_free(conn_event); wasm_runtime_free(conn_event);
} }
static void post_msg_to_module(sys_connection_t *conn, static void post_msg_to_module(sys_connection_t *conn,
@ -406,14 +406,14 @@ static void post_msg_to_module(sys_connection_t *conn,
if (module == NULL) if (module == NULL)
return; return;
conn_data_event = (connection_event_t *)bh_malloc(sizeof(*conn_data_event)); conn_data_event = (connection_event_t *)wasm_runtime_malloc(sizeof(*conn_data_event));
if (conn_data_event == NULL) if (conn_data_event == NULL)
return; return;
if (len > 0) { if (len > 0) {
data_copy = (char *)bh_malloc(len); data_copy = (char *)wasm_runtime_malloc(len);
if (data_copy == NULL) { if (data_copy == NULL) {
bh_free(conn_data_event); wasm_runtime_free(conn_data_event);
return; return;
} }
bh_memcpy_s(data_copy, len, data, len); bh_memcpy_s(data_copy, len, data, len);

24
core/app-framework/sensor/native/runtime_sensor.c
View File

@ -32,10 +32,10 @@ sensor_event_cleaner(sensor_event_data_t *sensor_event)
if (sensor_event->data_fmt == FMT_ATTR_CONTAINER) if (sensor_event->data_fmt == FMT_ATTR_CONTAINER)
attr_container_destroy(sensor_event->data); attr_container_destroy(sensor_event->data);
else else
bh_free(sensor_event->data); wasm_runtime_free(sensor_event->data);
} }
bh_free(sensor_event); wasm_runtime_free(sensor_event);
} }
static void static void
@ -56,7 +56,7 @@ wasm_sensor_callback(void *client, uint32 sensor_id, void *user_data)
return; return;
sensor_data_len = attr_container_get_serialize_length(sensor_data); sensor_data_len = attr_container_get_serialize_length(sensor_data);
sensor_data_clone = (attr_container_t *)bh_malloc(sensor_data_len); sensor_data_clone = (attr_container_t *)wasm_runtime_malloc(sensor_data_len);
if (sensor_data_clone == NULL) if (sensor_data_clone == NULL)
return; return;
@ -64,9 +64,9 @@ wasm_sensor_callback(void *client, uint32 sensor_id, void *user_data)
bh_memcpy_s(sensor_data_clone, sensor_data_len, bh_memcpy_s(sensor_data_clone, sensor_data_len,
sensor_data, sensor_data_len); sensor_data, sensor_data_len);
sensor_event = (sensor_event_data_t *)bh_malloc(sizeof(*sensor_event)); sensor_event = (sensor_event_data_t *)wasm_runtime_malloc(sizeof(*sensor_event));
if (sensor_event == NULL) { if (sensor_event == NULL) {
bh_free(sensor_data_clone); wasm_runtime_free(sensor_data_clone);
return; return;
} }
@ -158,7 +158,7 @@ wasm_sensor_open(wasm_exec_env_t exec_env,
return -1; return -1;
} }
sensor_client_t * client = (sensor_client_t*) bh_malloc( sensor_client_t * client = (sensor_client_t*) wasm_runtime_malloc(
sizeof(sensor_client_t)); sizeof(sensor_client_t));
if (client == NULL) { if (client == NULL) {
vm_mutex_unlock(&s->lock); vm_mutex_unlock(&s->lock);
@ -220,7 +220,7 @@ wasm_sensor_close(wasm_exec_env_t exec_env, uint32 sensor)
vm_mutex_lock(&s->lock); vm_mutex_lock(&s->lock);
if ((c = find_sensor_client(s, client_id, true)) != NULL) if ((c = find_sensor_client(s, client_id, true)) != NULL)
bh_free(c); wasm_runtime_free(c);
vm_mutex_unlock(&s->lock); vm_mutex_unlock(&s->lock);
refresh_read_interval(s); refresh_read_interval(s);
@ -272,7 +272,7 @@ sensor_obj_t
add_sys_sensor(char * name, char * description, int instance, add_sys_sensor(char * name, char * description, int instance,
uint32 default_interval, void * read_func, void * config_func) uint32 default_interval, void * read_func, void * config_func)
{ {
sys_sensor_t * s = (sys_sensor_t *) bh_malloc(sizeof(sys_sensor_t)); sys_sensor_t * s = (sys_sensor_t *) wasm_runtime_malloc(sizeof(sys_sensor_t));
if (s == NULL) if (s == NULL)
return NULL; return NULL;
@ -282,15 +282,15 @@ add_sys_sensor(char * name, char * description, int instance,
s->default_interval = default_interval; s->default_interval = default_interval;
if (!s->name) { if (!s->name) {
bh_free(s); wasm_runtime_free(s);
return NULL; return NULL;
} }
if (description) { if (description) {
s->description = bh_strdup(description); s->description = bh_strdup(description);
if (!s->description) { if (!s->description) {
bh_free(s->name); wasm_runtime_free(s->name);
bh_free(s); wasm_runtime_free(s);
return NULL; return NULL;
} }
} }
@ -414,7 +414,7 @@ void sensor_cleanup_callback(uint32 module_id)
sensor_client_t *c; sensor_client_t *c;
vm_mutex_lock(&s->lock); vm_mutex_lock(&s->lock);
if ((c = find_sensor_client(s, module_id, true)) != NULL) { if ((c = find_sensor_client(s, module_id, true)) != NULL) {
bh_free(c); wasm_runtime_free(c);
} }
vm_mutex_unlock(&s->lock); vm_mutex_unlock(&s->lock);
s = s->next; s = s->next;

6
core/app-framework/wgl/native/wgl_native_utils.c
View File

@ -124,7 +124,7 @@ void wgl_native_func_call(wasm_module_inst_t module_inst,
argc1++; /* module_inst */ argc1++; /* module_inst */
argc1 += func_def->arg_num; argc1 += func_def->arg_num;
if (argc1 > 16) { if (argc1 > 16) {
argv_copy = (intptr_t *)bh_malloc(func_def->arg_num * argv_copy = (intptr_t *)wasm_runtime_malloc(func_def->arg_num *
sizeof(intptr_t)); sizeof(intptr_t));
if (argv_copy == NULL) if (argv_copy == NULL)
return; return;
@ -190,14 +190,14 @@ void wgl_native_func_call(wasm_module_inst_t module_inst,
} }
if (argv_copy != argv_copy_buf) if (argv_copy != argv_copy_buf)
bh_free(argv_copy); wasm_runtime_free(argv_copy);
/* success return */ /* success return */
return; return;
fail: fail:
if (argv_copy != argv_copy_buf) if (argv_copy != argv_copy_buf)
bh_free(argv_copy); wasm_runtime_free(argv_copy);
return; return;
} }

8
core/app-framework/wgl/native/wgl_obj_wrapper.c
View File

@ -93,7 +93,7 @@ static void cleanup_object_list(uint32 module_id)
found = true; found = true;
lv_obj_del(elem->obj); lv_obj_del(elem->obj);
bh_list_remove(&g_object_list, elem); bh_list_remove(&g_object_list, elem);
bh_free(elem); wasm_runtime_free(elem);
elem = next; elem = next;
} else { } else {
elem = (object_node_t *)bh_list_elem_next(elem); elem = (object_node_t *)bh_list_elem_next(elem);
@ -150,7 +150,7 @@ bool wgl_native_add_object(lv_obj_t *obj, uint32 module_id, uint32 *obj_id)
{ {
object_node_t *node; object_node_t *node;
node = (object_node_t *) bh_malloc(sizeof(object_node_t)); node = (object_node_t *) wasm_runtime_malloc(sizeof(object_node_t));
if (node == NULL) if (node == NULL)
return false; return false;
@ -200,7 +200,7 @@ static void _obj_del_recursive(lv_obj_t *obj)
while (elem) { while (elem) {
if (obj == elem->obj) { if (obj == elem->obj) {
bh_list_remove(&g_object_list, elem); bh_list_remove(&g_object_list, elem);
bh_free(elem); wasm_runtime_free(elem);
vm_mutex_unlock(&g_object_list_mutex); vm_mutex_unlock(&g_object_list_mutex);
return; return;
} }
@ -237,7 +237,7 @@ static void post_widget_msg_to_module(object_node_t *object_node, lv_event_t eve
if (module == NULL) if (module == NULL)
return; return;
object_event = (object_event_t *)bh_malloc(sizeof(*object_event)); object_event = (object_event_t *)wasm_runtime_malloc(sizeof(*object_event));
if (object_event == NULL) if (object_event == NULL)
return; return;

1
core/app-mgr/app-manager/app_manager.c
View File

@ -6,7 +6,6 @@
#include "app_manager.h" #include "app_manager.h"
#include "app_manager_host.h" #include "app_manager_host.h"
#include "bh_queue.h" #include "bh_queue.h"
#include "bh_memory.h"
#include "bh_thread.h" #include "bh_thread.h"
#include "bi-inc/attr_container.h" #include "bi-inc/attr_container.h"
#include "event.h" #include "event.h"

3
core/app-mgr/app-manager/app_manager.h
View File

@ -18,6 +18,9 @@
extern "C" { extern "C" {
#endif #endif
#define APP_MGR_MALLOC wasm_runtime_malloc
#define APP_MGR_FREE wasm_runtime_free
/* bh_printf is defined in each platform */ /* bh_printf is defined in each platform */
#define app_manager_printf bh_printf #define app_manager_printf bh_printf

9
core/app-mgr/app-manager/app_manager_host.c
View File

@ -9,7 +9,6 @@
#include "app_manager.h" #include "app_manager.h"
#include "app_manager_export.h" #include "app_manager_export.h"
#include "coap_ext.h" #include "coap_ext.h"
#include "bh_memory.h"
#include "bh_thread.h" #include "bh_thread.h"
/* host communication interface */ /* host communication interface */
@ -66,7 +65,7 @@ static int on_imrt_link_byte_arrive(unsigned char ch, recv_context_t *ctx)
ctx->message.payload_size = 0; ctx->message.payload_size = 0;
if (ctx->message.payload) { if (ctx->message.payload) {
bh_free(ctx->message.payload); APP_MGR_FREE(ctx->message.payload);
ctx->message.payload = NULL; ctx->message.payload = NULL;
} }
@ -117,7 +116,7 @@ static int on_imrt_link_byte_arrive(unsigned char ch, recv_context_t *ctx)
app_manager_printf("##On byte arrive: payload_size: %d\n", app_manager_printf("##On byte arrive: payload_size: %d\n",
ctx->message.payload_size); ctx->message.payload_size);
if (ctx->message.payload) { if (ctx->message.payload) {
bh_free(ctx->message.payload); APP_MGR_FREE(ctx->message.payload);
ctx->message.payload = NULL; ctx->message.payload = NULL;
} }
@ -137,7 +136,7 @@ static int on_imrt_link_byte_arrive(unsigned char ch, recv_context_t *ctx)
if (ctx->message.message_type != INSTALL_WASM_APP) { if (ctx->message.message_type != INSTALL_WASM_APP) {
ctx->message.payload = ctx->message.payload =
(char *) bh_malloc(ctx->message.payload_size); (char *) APP_MGR_MALLOC(ctx->message.payload_size);
if (!ctx->message.payload) { if (!ctx->message.payload) {
ctx->phase = Phase_Non_Start; ctx->phase = Phase_Non_Start;
return 0; return 0;
@ -222,7 +221,7 @@ int aee_host_msg_callback(void *msg, uint16_t msg_len)
printf("unexpected host msg type: %d\n", msg_type); printf("unexpected host msg type: %d\n", msg_type);
} }
bh_free(recv_ctx.message.payload); APP_MGR_FREE(recv_ctx.message.payload);
recv_ctx.message.payload = NULL; recv_ctx.message.payload = NULL;
recv_ctx.message.payload_size = 0; recv_ctx.message.payload_size = 0;
} }

8
core/app-mgr/app-manager/ble_msg.c
View File

@ -75,16 +75,16 @@ app_instance_free_ble_msg(char *msg)
dev_info = (ble_device_info *) ble_msg->payload; dev_info = (ble_device_info *) ble_msg->payload;
if (dev_info->scan_response != NULL) if (dev_info->scan_response != NULL)
bh_free(dev_info->scan_response); APP_MGR_FREE(dev_info->scan_response);
if (dev_info->private_data != NULL) if (dev_info->private_data != NULL)
bh_free(dev_info->private_data); APP_MGR_FREE(dev_info->private_data);
if (dev_info->adv_data != NULL) if (dev_info->adv_data != NULL)
bh_free(dev_info->adv_data); APP_MGR_FREE(dev_info->adv_data);
if (dev_info != NULL) if (dev_info != NULL)
bh_free(dev_info); APP_MGR_FREE(dev_info);
} }
static void static void

9
core/app-mgr/app-manager/event.c
View File

@ -8,7 +8,6 @@
#include "event.h" #include "event.h"
#include "app_manager.h" #include "app_manager.h"
#include "bh_memory.h"
#include "coap_ext.h" #include "coap_ext.h"
typedef struct _subscribe { typedef struct _subscribe {
@ -38,7 +37,7 @@ static bool find_subscriber(event_reg_t * reg, uint32 id, bool remove_found)
else else
reg->subscribers = next; reg->subscribers = next;
bh_free(c); APP_MGR_FREE(c);
} }
return true; return true;
@ -77,7 +76,7 @@ bool am_register_event(const char *url, uint32_t reg_client)
if (current == NULL) { if (current == NULL) {
if (NULL if (NULL
== (current = (event_reg_t *) bh_malloc( == (current = (event_reg_t *) APP_MGR_MALLOC(
offsetof(event_reg_t, url) + strlen(url) + 1))) { offsetof(event_reg_t, url) + strlen(url) + 1))) {
app_manager_printf("am_register_event: malloc fail\n"); app_manager_printf("am_register_event: malloc fail\n");
return false; return false;
@ -92,7 +91,7 @@ bool am_register_event(const char *url, uint32_t reg_client)
if (find_subscriber(current, reg_client, false)) { if (find_subscriber(current, reg_client, false)) {
return true; return true;
} else { } else {
subscribe_t * s = (subscribe_t*) bh_malloc(sizeof(subscribe_t)); subscribe_t * s = (subscribe_t*) APP_MGR_MALLOC(sizeof(subscribe_t));
if (s == NULL) if (s == NULL)
return false; return false;
@ -128,7 +127,7 @@ bool am_unregister_event(const char *url, uint32_t reg_client)
pre->next = next; pre->next = next;
else else
g_events = next; g_events = next;
bh_free(current); APP_MGR_FREE(current);
current = next; current = next;
continue; continue;
} }

3
core/app-mgr/app-manager/message.c
View File

@ -7,7 +7,6 @@
#include "app_manager_host.h" #include "app_manager_host.h"
#include "event.h" #include "event.h"
#include "bi-inc/attr_container.h" #include "bi-inc/attr_container.h"
#include "bh_memory.h"
#include "coap_ext.h" #include "coap_ext.h"
#if 0 #if 0
@ -21,7 +20,7 @@ bool send_coap_packet_to_host(coap_packet_t * packet)
return false; return false;
app_manager_host_send_msg(buf, size); app_manager_host_send_msg(buf, size);
bh_free(buf); APP_MGR_FREE(buf);
return true; return true;
} }

80
core/app-mgr/app-manager/module_jeff.c
View File

@ -125,7 +125,7 @@ get_class_qname(const JeffString *pname, const JeffString *cname)
{ {
unsigned int length = pname->length ? pname->length + 2 + cname->length unsigned int length = pname->length ? pname->length + 2 + cname->length
: cname->length + 1; : cname->length + 1;
char *buf = bh_malloc(length), *p; char *buf = APP_MGR_MALLOC(length), *p;
if (!buf) if (!buf)
return NULL; return NULL;
@ -166,7 +166,7 @@ send_exception_event_to_host(const char *applet_name, const char *exc_name)
} }
url_len = strlen("/exception/") + strlen(applet_name); url_len = strlen("/exception/") + strlen(applet_name);
url = bh_malloc(url_len + 1); url = APP_MGR_MALLOC(url_len + 1);
if (!url) { if (!url) {
app_manager_printf("Send exception to host fail: allocate memory"); app_manager_printf("Send exception to host fail: allocate memory");
goto fail; goto fail;
@ -182,7 +182,7 @@ send_exception_event_to_host(const char *applet_name, const char *exc_name)
app_send_request_msg_to_host(&msg); app_send_request_msg_to_host(&msg);
bh_free(url); APP_MGR_FREE(url);
fail: fail:
attr_container_destroy(payload); attr_container_destroy(payload);
@ -208,7 +208,7 @@ check_exception()
/* Send exception event to host */ /* Send exception event to host */
if (qname_buf) { if (qname_buf) {
send_exception_event_to_host(app_manager_get_module_name(Module_Jeff), qname_buf); send_exception_event_to_host(app_manager_get_module_name(Module_Jeff), qname_buf);
bh_free(qname_buf); APP_MGR_FREE(qname_buf);
} }
/* Uninstall the applet */ /* Uninstall the applet */
@ -455,17 +455,17 @@ check_exception()
fail: fail:
if (dev_info->scan_response != NULL) { if (dev_info->scan_response != NULL) {
bh_free(dev_info->scan_response); APP_MGR_FREE(dev_info->scan_response);
} }
if (dev_info->private_data != NULL) { if (dev_info->private_data != NULL) {
bh_free(dev_info->private_data); APP_MGR_FREE(dev_info->private_data);
} }
if (dev_info->adv_data != NULL) { if (dev_info->adv_data != NULL) {
bh_free(dev_info->adv_data); APP_MGR_FREE(dev_info->adv_data);
} }
if (dev_info != NULL) { if (dev_info != NULL) {
bh_free(dev_info); APP_MGR_FREE(dev_info);
} }
} }
@ -479,16 +479,16 @@ check_exception()
dev_info = (ble_device_info *) ble_msg->payload; dev_info = (ble_device_info *) ble_msg->payload;
if (dev_info->scan_response != NULL) if (dev_info->scan_response != NULL)
bh_free(dev_info->scan_response); APP_MGR_FREE(dev_info->scan_response);
if (dev_info->private_data != NULL) if (dev_info->private_data != NULL)
bh_free(dev_info->private_data); APP_MGR_FREE(dev_info->private_data);
if (dev_info->adv_data != NULL) if (dev_info->adv_data != NULL)
bh_free(dev_info->adv_data); APP_MGR_FREE(dev_info->adv_data);
if (dev_info != NULL) if (dev_info != NULL)
bh_free(dev_info); APP_MGR_FREE(dev_info);
} }
static void static void
@ -500,7 +500,7 @@ check_exception()
case APPLET_REQUEST: case APPLET_REQUEST:
{ {
bh_request_msg_t *req_msg = (bh_request_msg_t *)msg->payload; bh_request_msg_t *req_msg = (bh_request_msg_t *)msg->payload;
bh_free(req_msg); APP_MGR_FREE(req_msg);
break; break;
} }
@ -516,7 +516,7 @@ check_exception()
attr_container_t *event = sensor_event->event; attr_container_t *event = sensor_event->event;
attr_container_destroy(event); attr_container_destroy(event);
bh_free(sensor_event); APP_MGR_FREE(sensor_event);
} }
break; break;
} }
@ -525,7 +525,7 @@ check_exception()
{ {
if (msg->payload) { if (msg->payload) {
app_instance_free_ble_msg(msg->payload); app_instance_free_ble_msg(msg->payload);
bh_free(msg->payload); APP_MGR_FREE(msg->payload);
} }
break; break;
} }
@ -541,7 +541,7 @@ check_exception()
} }
} }
bh_free(msg); APP_MGR_FREE(msg);
} }
static void static void
@ -609,7 +609,7 @@ check_exception()
fail2: fail2:
jeff_runtime_pop_local_object_ref(1); jeff_runtime_pop_local_object_ref(1);
fail1: fail1:
bh_free(req_msg); APP_MGR_FREE(req_msg);
break; break;
} }
@ -633,7 +633,7 @@ check_exception()
bool ret = attr_container_to_attr_obj(event, &sensor->event); bool ret = attr_container_to_attr_obj(event, &sensor->event);
attr_container_destroy(event); attr_container_destroy(event);
bh_free(sensor_event); APP_MGR_FREE(sensor_event);
if (ret) { if (ret) {
/* Call Sensor.callOnSensorEvent() method */ /* Call Sensor.callOnSensorEvent() method */
@ -649,7 +649,7 @@ check_exception()
{ {
if (msg->payload) { if (msg->payload) {
app_instance_process_ble_msg(msg->payload); app_instance_process_ble_msg(msg->payload);
bh_free(msg->payload); APP_MGR_FREE(msg->payload);
} }
break; break;
} }
@ -678,7 +678,7 @@ check_exception()
} }
} }
bh_free(msg); APP_MGR_FREE(msg);
} }
static JeffClassHeaderLinked* static JeffClassHeaderLinked*
@ -837,7 +837,7 @@ check_exception()
/* TODO: convert bpk file to Jeff file */ /* TODO: convert bpk file to Jeff file */
main_file_len = bpk_file_len; main_file_len = bpk_file_len;
main_file = bh_malloc(main_file_len); main_file = APP_MGR_MALLOC(main_file_len);
if (!main_file) { if (!main_file) {
SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: allocate memory failed."); SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: allocate memory failed.");
return false; return false;
@ -866,7 +866,7 @@ check_exception()
/* Create module data */ /* Create module data */
size = offsetof(module_data, module_name) + strlen(applet_name) + 1; size = offsetof(module_data, module_name) + strlen(applet_name) + 1;
size = align_uint(size, 4); size = align_uint(size, 4);
m_data = bh_malloc(size + sizeof(jeff_applet_data)); m_data = APP_MGR_MALLOC(size + sizeof(jeff_applet_data));
if (!m_data) { if (!m_data) {
SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: allocate memory failed."); SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: allocate memory failed.");
goto fail2; goto fail2;
@ -888,7 +888,7 @@ check_exception()
/* Create applet permissions */ /* Create applet permissions */
applet_perm = attr_container_get_as_string(attr_cont, "perm"); applet_perm = attr_container_get_as_string(attr_cont, "perm");
if (applet_perm != NULL) { if (applet_perm != NULL) {
applet_data->perms = bh_malloc(strlen(applet_perm) + 1); applet_data->perms = APP_MGR_MALLOC(strlen(applet_perm) + 1);
if (!applet_data->perms) { if (!applet_data->perms) {
SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: allocate memory for applet permissions failed."); SEND_ERR_RESPONSE(msg->mid, "Install Applet failed: allocate memory for applet permissions failed.");
goto fail3; goto fail3;
@ -993,16 +993,16 @@ check_exception()
bh_queue_destroy(m_data->queue, NULL); bh_queue_destroy(m_data->queue, NULL);
fail3_1: fail3_1:
bh_free(applet_data->perms); APP_MGR_FREE(applet_data->perms);
fail3: fail3:
bh_free(applet_data); APP_MGR_FREE(applet_data);
fail2: fail2:
jeff_runtime_unload(main_file); jeff_runtime_unload(main_file);
fail1: fail1:
bh_free(main_file); APP_MGR_FREE(main_file);
return false; return false;
} }
@ -1014,7 +1014,7 @@ check_exception()
/* Unload Jeff main file and free it */ /* Unload Jeff main file and free it */
jeff_runtime_unload(applet_data->main_file); jeff_runtime_unload(applet_data->main_file);
bh_free(applet_data->main_file); APP_MGR_FREE(applet_data->main_file);
/* Destroy queue */ /* Destroy queue */
bh_queue_destroy(m_data->queue, app_instance_queue_free_callback); bh_queue_destroy(m_data->queue, app_instance_queue_free_callback);
@ -1027,8 +1027,8 @@ check_exception()
/* Remove module data from module data list and free it */ /* Remove module data from module data list and free it */
app_manager_del_module_data(m_data); app_manager_del_module_data(m_data);
bh_free(applet_data->perms); APP_MGR_FREE(applet_data->perms);
bh_free(m_data); APP_MGR_FREE(m_data);
} }
/* Uninstall Java Applet */ /* Uninstall Java Applet */
@ -1476,7 +1476,7 @@ check_exception()
} }
/* Create queue message for tool agent */ /* Create queue message for tool agent */
if (!(tool_agent_msg = bh_malloc(sizeof(bh_queue_msg_t)))) { if (!(tool_agent_msg = APP_MGR_MALLOC(sizeof(bh_queue_msg_t)))) {
SEND_ERR_RESPONSE(mid, "Send request to tool agent failed: allocate memory failed"); SEND_ERR_RESPONSE(mid, "Send request to tool agent failed: allocate memory failed");
return false; return false;
} }
@ -1487,9 +1487,9 @@ check_exception()
req_msg_len = sizeof(bh_request_msg_t) + strlen(p) + 1 + attr_cont_len; req_msg_len = sizeof(bh_request_msg_t) + strlen(p) + 1 + attr_cont_len;
/* Create request message */ /* Create request message */
if (!(req_msg = bh_malloc(req_msg_len))) { if (!(req_msg = APP_MGR_MALLOC(req_msg_len))) {
SEND_ERR_RESPONSE(mid, "Send request to applet failed: allocate memory failed"); SEND_ERR_RESPONSE(mid, "Send request to applet failed: allocate memory failed");
bh_free(tool_agent_msg); APP_MGR_FREE(tool_agent_msg);
return false; return false;
} }
@ -1511,8 +1511,8 @@ check_exception()
tool_agent_msg->payload_size = req_msg_len; tool_agent_msg->payload_size = req_msg_len;
tool_agent_msg->payload = (char*)req_msg; tool_agent_msg->payload = (char*)req_msg;
if (!bh_queue_send_message(applet_data->tool_agent_queue, tool_agent_msg)) { if (!bh_queue_send_message(applet_data->tool_agent_queue, tool_agent_msg)) {
bh_free(req_msg); APP_MGR_FREE(req_msg);
bh_free(tool_agent_msg); APP_MGR_FREE(tool_agent_msg);
SEND_ERR_RESPONSE SEND_ERR_RESPONSE
(mid, "Send request to tool agent failed: send queue msg failed."); (mid, "Send request to tool agent failed: send queue msg failed.");
return false; return false;
@ -1693,16 +1693,16 @@ check_exception()
goto fail; goto fail;
} }
bh_free(req_msg); APP_MGR_FREE(req_msg);
bh_free(msg); APP_MGR_FREE(msg);
return; return;
fail: fail:
bh_queue_exit_loop_run(queue); bh_queue_exit_loop_run(queue);
bh_free(req_msg); APP_MGR_FREE(req_msg);
} }
bh_free(msg); APP_MGR_FREE(msg);
} }
void void
@ -1712,10 +1712,10 @@ check_exception()
if (msg->message_type == JDWP_REQUEST) { if (msg->message_type == JDWP_REQUEST) {
bh_request_msg_t *req_msg = (bh_request_msg_t*)msg->payload; bh_request_msg_t *req_msg = (bh_request_msg_t*)msg->payload;
bh_free(req_msg); APP_MGR_FREE(req_msg);
} }
bh_free(msg); APP_MGR_FREE(msg);
} }
#endif /* BEIHAI_ENABLE_TOOL_AGENT != 0 */ #endif /* BEIHAI_ENABLE_TOOL_AGENT != 0 */

5
core/app-mgr/app-manager/module_utils.c
View File

@ -6,7 +6,6 @@
#include "app_manager.h" #include "app_manager.h"
#include "app_manager_host.h" #include "app_manager_host.h"
#include "bh_queue.h" #include "bh_queue.h"
#include "bh_memory.h"
#include "bh_thread.h" #include "bh_thread.h"
#include "bi-inc/attr_container.h" #include "bi-inc/attr_container.h"
#include "event.h" #include "event.h"
@ -32,7 +31,7 @@ void module_data_list_destroy()
if (module_data_list) { if (module_data_list) {
while (module_data_list) { while (module_data_list) {
module_data *p = module_data_list->next; module_data *p = module_data_list->next;
bh_free(module_data_list); APP_MGR_FREE(module_data_list);
module_data_list = p; module_data_list = p;
} }
} }
@ -197,7 +196,7 @@ void release_module(module_data *m_data)
destroy_module_timer_ctx(m_data->id); destroy_module_timer_ctx(m_data->id);
bh_free(m_data); APP_MGR_FREE(m_data);
} }
int check_modules_timer_expiry() int check_modules_timer_expiry()

46
core/app-mgr/app-manager/module_wasm_app.c
View File

@ -10,7 +10,6 @@
#include "bh_queue.h" #include "bh_queue.h"
#include "bi-inc/attr_container.h" #include "bi-inc/attr_container.h"
#include "bh_thread.h" #include "bh_thread.h"
#include "bh_memory.h"
#include "coap_ext.h" #include "coap_ext.h"
#include "event.h" #include "event.h"
#include "watchdog.h" #include "watchdog.h"
@ -551,12 +550,7 @@ cleanup_app_resource(module_data *m_data)
static bool static bool
wasm_app_module_init(void) wasm_app_module_init(void)
{ {
/* Initialize WASM VM*/ /* wasm runtime is already initialized by main func */
if (!wasm_runtime_init()) {
app_manager_printf("WASM runtime environment initialization failed.\n");
return false;
}
return true; return true;
} }
@ -776,7 +770,7 @@ wasm_app_module_install(request_t * msg)
/* Create module data including the wasm_app_data as its internal_data*/ /* Create module data including the wasm_app_data as its internal_data*/
m_data_size = offsetof(module_data, module_name) + strlen(m_name) + 1; m_data_size = offsetof(module_data, module_name) + strlen(m_name) + 1;
m_data_size = align_uint(m_data_size, 4); m_data_size = align_uint(m_data_size, 4);
m_data = bh_malloc(m_data_size + sizeof(wasm_data)); m_data = APP_MGR_MALLOC(m_data_size + sizeof(wasm_data));
if (!m_data) { if (!m_data) {
SEND_ERR_RESPONSE(msg->mid, "Install WASM app failed: allocate memory failed."); SEND_ERR_RESPONSE(msg->mid, "Install WASM app failed: allocate memory failed.");
goto fail; goto fail;
@ -1096,7 +1090,7 @@ wasm_app_module_on_install_request_byte_arrive(uint8 ch,
recv_ctx.message.request_url_len = recv_ctx.message.request_url_len =
ntohs(recv_ctx.message.request_url_len); ntohs(recv_ctx.message.request_url_len);
recv_ctx.message.request_url = recv_ctx.message.request_url =
bh_malloc(recv_ctx.message.request_url_len + 1); APP_MGR_MALLOC(recv_ctx.message.request_url_len + 1);
if (NULL == recv_ctx.message.request_url) { if (NULL == recv_ctx.message.request_url) {
app_manager_printf("Allocate memory failed!\n"); app_manager_printf("Allocate memory failed!\n");
goto fail; goto fail;
@ -1177,7 +1171,7 @@ wasm_app_module_on_install_request_byte_arrive(uint8 ch,
uint8 section_type = ch; uint8 section_type = ch;
if (section_type <= SECTION_TYPE_DATA) { if (section_type <= SECTION_TYPE_DATA) {
wasm_section_t *new_section; wasm_section_t *new_section;
if (!(new_section = (wasm_section_t *) bh_malloc(sizeof(wasm_section_t)))) { if (!(new_section = (wasm_section_t *) APP_MGR_MALLOC(sizeof(wasm_section_t)))) {
app_manager_printf("Allocate memory failed!\n"); app_manager_printf("Allocate memory failed!\n");
goto fail; goto fail;
} }
@ -1226,7 +1220,7 @@ wasm_app_module_on_install_request_byte_arrive(uint8 ch,
if ((byte & 0x80) == 0) { if ((byte & 0x80) == 0) {
/* leb128 encoded section size parsed done */ /* leb128 encoded section size parsed done */
if (!(section->section_body = bh_malloc(section->section_body_size))) { if (!(section->section_body = APP_MGR_MALLOC(section->section_body_size))) {
app_manager_printf("Allocate memory failed!\n"); app_manager_printf("Allocate memory failed!\n");
goto fail; goto fail;
} }
@ -1248,7 +1242,7 @@ wasm_app_module_on_install_request_byte_arrive(uint8 ch,
if (recv_ctx.total_received_size == request_total_size) { if (recv_ctx.total_received_size == request_total_size) {
/* whole wasm app received */ /* whole wasm app received */
if (module_wasm_app_handle_install_msg(&recv_ctx.message)) { if (module_wasm_app_handle_install_msg(&recv_ctx.message)) {
bh_free(recv_ctx.message.request_url); APP_MGR_FREE(recv_ctx.message.request_url);
recv_ctx.message.request_url = NULL; recv_ctx.message.request_url = NULL;
memset(&recv_ctx, 0, sizeof(recv_ctx)); memset(&recv_ctx, 0, sizeof(recv_ctx));
return true; return true;
@ -1297,7 +1291,7 @@ wasm_app_module_on_install_request_byte_arrive(uint8 ch,
if (aot_file_cur_offset % 4) if (aot_file_cur_offset % 4)
return true; return true;
if (!(cur_section = (aot_section_t *) bh_malloc(sizeof(aot_section_t)))) { if (!(cur_section = (aot_section_t *) APP_MGR_MALLOC(sizeof(aot_section_t)))) {
app_manager_printf("Allocate memory failed!\n"); app_manager_printf("Allocate memory failed!\n");
goto fail; goto fail;
} }
@ -1377,7 +1371,7 @@ wasm_app_module_on_install_request_byte_arrive(uint8 ch,
} }
else { else {
if (!(section->section_body = if (!(section->section_body =
bh_malloc(section->section_body_size))) { APP_MGR_MALLOC(section->section_body_size))) {
app_manager_printf("Allocate memory failed!\n"); app_manager_printf("Allocate memory failed!\n");
goto fail; goto fail;
} }
@ -1411,7 +1405,7 @@ wasm_app_module_on_install_request_byte_arrive(uint8 ch,
if (recv_ctx.total_received_size == request_total_size) { if (recv_ctx.total_received_size == request_total_size) {
/* whole aot file received */ /* whole aot file received */
if (module_wasm_app_handle_install_msg(&recv_ctx.message)) { if (module_wasm_app_handle_install_msg(&recv_ctx.message)) {
bh_free(recv_ctx.message.request_url); APP_MGR_FREE(recv_ctx.message.request_url);
recv_ctx.message.request_url = NULL; recv_ctx.message.request_url = NULL;
memset(&recv_ctx, 0, sizeof(recv_ctx)); memset(&recv_ctx, 0, sizeof(recv_ctx));
return true; return true;
@ -1449,7 +1443,7 @@ fail:
} }
if (recv_ctx.message.request_url != NULL) { if (recv_ctx.message.request_url != NULL) {
bh_free(recv_ctx.message.request_url); APP_MGR_FREE(recv_ctx.message.request_url);
recv_ctx.message.request_url = NULL; recv_ctx.message.request_url = NULL;
} }
@ -1466,7 +1460,7 @@ module_wasm_app_handle_install_msg(install_wasm_app_msg_t *message)
request_t *request = NULL; request_t *request = NULL;
bh_message_t msg; bh_message_t msg;
request = (request_t *) bh_malloc(sizeof(request_t)); request = (request_t *) APP_MGR_MALLOC(sizeof(request_t));
if (request == NULL) if (request == NULL)
return false; return false;
@ -1477,7 +1471,7 @@ module_wasm_app_handle_install_msg(install_wasm_app_msg_t *message)
request->sender = ID_HOST; request->sender = ID_HOST;
request->mid = message->request_mid; request->mid = message->request_mid;
request->payload_len = sizeof(message->app_file); request->payload_len = sizeof(message->app_file);
request->payload = bh_malloc(request->payload_len); request->payload = APP_MGR_MALLOC(request->payload_len);
if (request->url == NULL || request->payload == NULL) { if (request->url == NULL || request->payload == NULL) {
request_cleaner(request); request_cleaner(request);
@ -1512,8 +1506,8 @@ destroy_all_wasm_sections(wasm_section_list_t sections)
while (cur) { while (cur) {
wasm_section_t *next = cur->next; wasm_section_t *next = cur->next;
if (cur->section_body != NULL) if (cur->section_body != NULL)
bh_free(cur->section_body); APP_MGR_FREE(cur->section_body);
bh_free(cur); APP_MGR_FREE(cur);
cur = next; cur = next;
} }
} }
@ -1537,8 +1531,8 @@ destroy_part_wasm_sections(wasm_section_list_t *p_sections,
*p_sections = next; *p_sections = next;
if (cur->section_body != NULL) if (cur->section_body != NULL)
bh_free(cur->section_body); APP_MGR_FREE(cur->section_body);
bh_free(cur); APP_MGR_FREE(cur);
break; break;
} }
else { else {
@ -1561,9 +1555,9 @@ destroy_all_aot_sections(aot_section_list_t sections)
if (cur->section_type == AOT_SECTION_TYPE_TEXT) if (cur->section_type == AOT_SECTION_TYPE_TEXT)
bh_munmap(cur->section_body, cur->section_body_size); bh_munmap(cur->section_body, cur->section_body_size);
else else
bh_free(cur->section_body); APP_MGR_FREE(cur->section_body);
} }
bh_free(cur); APP_MGR_FREE(cur);
cur = next; cur = next;
} }
} }
@ -1591,9 +1585,9 @@ destroy_part_aot_sections(aot_section_list_t *p_sections,
if (cur->section_type == AOT_SECTION_TYPE_TEXT) if (cur->section_type == AOT_SECTION_TYPE_TEXT)
bh_munmap(cur->section_body, cur->section_body_size); bh_munmap(cur->section_body, cur->section_body_size);
else else
bh_free(cur->section_body); APP_MGR_FREE(cur->section_body);
} }
bh_free(cur); APP_MGR_FREE(cur);
break; break;
} }
else { else {

5
core/app-mgr/app-manager/platform/zephyr/app_mgr_zephyr.c
View File

@ -5,7 +5,6 @@
#include "app_manager.h" #include "app_manager.h"
#include "bh_platform.h" #include "bh_platform.h"
#include "bh_memory.h"
#include <autoconf.h> #include <autoconf.h>
#include <zephyr.h> #include <zephyr.h>
#include <kernel.h> #include <kernel.h>
@ -21,7 +20,7 @@ void*
app_manager_timer_create(void (*timer_callback)(void*), app_manager_timer_create(void (*timer_callback)(void*),
watchdog_timer *wd_timer) watchdog_timer *wd_timer)
{ {
struct k_timer_watchdog *timer = bh_malloc(sizeof(struct k_timer_watchdog)); struct k_timer_watchdog *timer = APP_MGR_MALLOC(sizeof(struct k_timer_watchdog));
if (timer) { if (timer) {
k_timer_init(&timer->timer, (void (*)(struct k_timer*)) timer_callback, k_timer_init(&timer->timer, (void (*)(struct k_timer*)) timer_callback,
@ -34,7 +33,7 @@ app_manager_timer_create(void (*timer_callback)(void*),
void app_manager_timer_destroy(void *timer) void app_manager_timer_destroy(void *timer)
{ {
bh_free(timer); APP_MGR_FREE(timer);
} }
void app_manager_timer_start(void *timer, int timeout) void app_manager_timer_start(void *timer, int timeout)

8
core/app-mgr/app-manager/resource_reg.c
View File

@ -158,14 +158,14 @@ bool am_register_resource(const char *url,
if (register_num >= RESOURCE_REGISTRATION_NUM_MAX) if (register_num >= RESOURCE_REGISTRATION_NUM_MAX)
return false; return false;
r = (app_res_register_t *) bh_malloc(sizeof(app_res_register_t)); r = (app_res_register_t *) APP_MGR_MALLOC(sizeof(app_res_register_t));
if (r == NULL) if (r == NULL)
return false; return false;
memset(r, 0, sizeof(*r)); memset(r, 0, sizeof(*r));
r->url = bh_strdup(url); r->url = bh_strdup(url);
if (r->url == NULL) { if (r->url == NULL) {
bh_free(r); APP_MGR_FREE(r);
return false; return false;
} }
@ -191,8 +191,8 @@ void am_cleanup_registeration(uint32 register_id)
else else
g_resources = next; g_resources = next;
bh_free(r->url); APP_MGR_FREE(r->url);
bh_free(r); APP_MGR_FREE(r);
} else } else
/* if r is freed, should not change prev. Only set prev to r /* if r is freed, should not change prev. Only set prev to r
when r isn't freed. */ when r isn't freed. */

2
core/app-mgr/app-manager/watchdog.c
View File

@ -6,8 +6,6 @@
#include "watchdog.h" #include "watchdog.h"
#include "bh_queue.h" #include "bh_queue.h"
#include "bh_thread.h" #include "bh_thread.h"
#include "bh_memory.h"
#include "jeff_export.h"
#define WATCHDOG_THREAD_PRIORITY 5 #define WATCHDOG_THREAD_PRIORITY 5

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

@ -5,7 +5,6 @@
#include "aot_runtime.h" #include "aot_runtime.h"
#include "bh_common.h" #include "bh_common.h"
#include "bh_memory.h"
#include "bh_log.h" #include "bh_log.h"
#include "aot_reloc.h" #include "aot_reloc.h"
#include "../common/wasm_runtime_common.h" #include "../common/wasm_runtime_common.h"
@ -155,7 +154,7 @@ const_str_set_insert(const uint8 *str, int32 len, AOTModule *module,
char* error_buf, uint32 error_buf_size) char* error_buf, uint32 error_buf_size)
{ {
HashMap *set = module->const_str_set; HashMap *set = module->const_str_set;
char *c_str = wasm_malloc((uint32)len + 1), *value; char *c_str = wasm_runtime_malloc((uint32)len + 1), *value;
if (!c_str) { if (!c_str) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
@ -168,7 +167,7 @@ const_str_set_insert(const uint8 *str, int32 len, AOTModule *module,
c_str[len] = '\0'; c_str[len] = '\0';
if ((value = bh_hash_map_find(set, c_str))) { if ((value = bh_hash_map_find(set, c_str))) {
wasm_free(c_str); wasm_runtime_free(c_str);
return value; return value;
} }
@ -176,7 +175,7 @@ const_str_set_insert(const uint8 *str, int32 len, AOTModule *module,
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"insert string to hash map failed."); "insert string to hash map failed.");
wasm_free(c_str); wasm_runtime_free(c_str);
return NULL; return NULL;
} }
@ -330,8 +329,8 @@ destroy_mem_init_data_list(AOTMemInitData **data_list, uint32 count,
uint32 i; uint32 i;
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
if (data_list[i]) if (data_list[i])
wasm_free(data_list[i]); wasm_runtime_free(data_list[i]);
wasm_free(data_list); wasm_runtime_free(data_list);
} }
} }
@ -349,7 +348,7 @@ load_mem_init_data_list(const uint8 **p_buf, const uint8 *buf_end,
size = sizeof(AOTMemInitData *) * (uint64)module->mem_init_data_count; size = sizeof(AOTMemInitData *) * (uint64)module->mem_init_data_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(module->mem_init_data_list = || !(module->mem_init_data_list =
data_list = wasm_malloc((uint32)size))) { data_list = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -367,7 +366,7 @@ load_mem_init_data_list(const uint8 **p_buf, const uint8 *buf_end,
read_uint32(buf, buf_end, byte_count); read_uint32(buf, buf_end, byte_count);
size = offsetof(AOTMemInitData, bytes) + (uint64)byte_count; size = offsetof(AOTMemInitData, bytes) + (uint64)byte_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(data_list[i] = wasm_malloc((uint32)size))) { || !(data_list[i] = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -419,8 +418,8 @@ destroy_table_init_data_list(AOTTableInitData **data_list, uint32 count,
uint32 i; uint32 i;
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
if (data_list[i]) if (data_list[i])
wasm_free(data_list[i]); wasm_runtime_free(data_list[i]);
wasm_free(data_list); wasm_runtime_free(data_list);
} }
} }
@ -438,7 +437,7 @@ load_table_init_data_list(const uint8 **p_buf, const uint8 *buf_end,
size = sizeof(AOTTableInitData *) * (uint64)module->table_init_data_count; size = sizeof(AOTTableInitData *) * (uint64)module->table_init_data_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(module->table_init_data_list = || !(module->table_init_data_list =
data_list = wasm_malloc((uint32)size))) { data_list = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -459,7 +458,7 @@ load_table_init_data_list(const uint8 **p_buf, const uint8 *buf_end,
size1 = sizeof(uint32) * (uint64)func_index_count; size1 = sizeof(uint32) * (uint64)func_index_count;
size = offsetof(AOTTableInitData, func_indexes) + size1; size = offsetof(AOTTableInitData, func_indexes) + size1;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(data_list[i] = wasm_malloc((uint32)size))) { || !(data_list[i] = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -507,8 +506,8 @@ destroy_func_types(AOTFuncType **func_types, uint32 count, bool is_jit_mode)
uint32 i; uint32 i;
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
if (func_types[i]) if (func_types[i])
wasm_free(func_types[i]); wasm_runtime_free(func_types[i]);
wasm_free(func_types); wasm_runtime_free(func_types);
} }
} }
@ -525,7 +524,7 @@ load_func_types(const uint8 **p_buf, const uint8 *buf_end,
/* Allocate memory */ /* Allocate memory */
size = sizeof(AOTFuncType *) * (uint64)module->func_type_count; size = sizeof(AOTFuncType *) * (uint64)module->func_type_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(module->func_types = func_types = wasm_malloc((uint32)size))) { || !(module->func_types = func_types = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -545,7 +544,7 @@ load_func_types(const uint8 **p_buf, const uint8 *buf_end,
size1 = (uint64)param_count + (uint64)result_count; size1 = (uint64)param_count + (uint64)result_count;
size = offsetof(AOTFuncType, types) + size1; size = offsetof(AOTFuncType, types) + size1;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(func_types[i] = wasm_malloc((uint32)size))) { || !(func_types[i] = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -587,7 +586,7 @@ static void
destroy_import_globals(AOTImportGlobal *import_globals, bool is_jit_mode) destroy_import_globals(AOTImportGlobal *import_globals, bool is_jit_mode)
{ {
if (!is_jit_mode) if (!is_jit_mode)
wasm_free(import_globals); wasm_runtime_free(import_globals);
} }
static bool static bool
@ -604,7 +603,7 @@ load_import_globals(const uint8 **p_buf, const uint8 *buf_end,
size = sizeof(AOTImportGlobal) * (uint64)module->import_global_count; size = sizeof(AOTImportGlobal) * (uint64)module->import_global_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(module->import_globals = || !(module->import_globals =
import_globals = wasm_malloc((uint32)size))) { import_globals = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -657,7 +656,7 @@ static void
destroy_globals(AOTGlobal *globals, bool is_jit_mode) destroy_globals(AOTGlobal *globals, bool is_jit_mode)
{ {
if (!is_jit_mode) if (!is_jit_mode)
wasm_free(globals); wasm_runtime_free(globals);
} }
static bool static bool
@ -674,7 +673,7 @@ load_globals(const uint8 **p_buf, const uint8 *buf_end,
/* Allocate memory */ /* Allocate memory */
size = sizeof(AOTGlobal) * (uint64)module->global_count; size = sizeof(AOTGlobal) * (uint64)module->global_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(module->globals = globals = wasm_malloc((uint32)size))) { || !(module->globals = globals = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -739,7 +738,7 @@ destroy_import_funcs(AOTImportFunc *import_funcs,
bool is_jit_mode) bool is_jit_mode)
{ {
if (!is_jit_mode) if (!is_jit_mode)
wasm_free(import_funcs); wasm_runtime_free(import_funcs);
} }
static bool static bool
@ -757,7 +756,7 @@ load_import_funcs(const uint8 **p_buf, const uint8 *buf_end,
size = sizeof(AOTImportFunc) * (uint64)module->import_func_count; size = sizeof(AOTImportFunc) * (uint64)module->import_func_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(module->import_funcs = || !(module->import_funcs =
import_funcs = wasm_malloc((uint32)size))) { import_funcs = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -831,7 +830,7 @@ destroy_object_data_sections(AOTObjectDataSection *data_sections,
for (i = 0; i < data_section_count; i++, data_section++) for (i = 0; i < data_section_count; i++, data_section++)
if (data_section->data) if (data_section->data)
bh_munmap(data_section->data, data_section->size); bh_munmap(data_section->data, data_section->size);
wasm_free(data_sections); wasm_runtime_free(data_sections);
} }
static bool static bool
@ -848,7 +847,7 @@ load_object_data_sections(const uint8 **p_buf, const uint8 *buf_end,
size = sizeof(AOTObjectDataSection) * (uint64)module->data_section_count; size = sizeof(AOTObjectDataSection) * (uint64)module->data_section_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(module->data_sections = || !(module->data_sections =
data_sections = wasm_malloc((uint32)size))) { data_sections = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -1002,7 +1001,7 @@ load_function_section(const uint8 *buf, const uint8 *buf_end,
size = sizeof(void*) * (uint64)module->func_count; size = sizeof(void*) * (uint64)module->func_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(module->func_ptrs = wasm_malloc((uint32)size))) { || !(module->func_ptrs = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: allocate memory failed."); "AOT module load failed: allocate memory failed.");
return false; return false;
@ -1042,7 +1041,7 @@ load_function_section(const uint8 *buf, const uint8 *buf_end,
size = sizeof(uint32) * (uint64)module->func_count; size = sizeof(uint32) * (uint64)module->func_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(module->func_type_indexes = wasm_malloc((uint32)size))) { || !(module->func_type_indexes = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: allocate memory failed."); "AOT module load failed: allocate memory failed.");
return false; return false;
@ -1074,7 +1073,7 @@ static void
destroy_export_funcs(AOTExportFunc *export_funcs, bool is_jit_mode) destroy_export_funcs(AOTExportFunc *export_funcs, bool is_jit_mode)
{ {
if (!is_jit_mode) if (!is_jit_mode)
wasm_free(export_funcs); wasm_runtime_free(export_funcs);
} }
static bool static bool
@ -1091,7 +1090,7 @@ load_export_funcs(const uint8 **p_buf, const uint8 *buf_end,
size = sizeof(AOTExportFunc) * (uint64)module->export_func_count; size = sizeof(AOTExportFunc) * (uint64)module->export_func_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(module->export_funcs = || !(module->export_funcs =
export_funcs = wasm_malloc((uint32)size))) { export_funcs = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -1204,7 +1203,7 @@ do_text_relocation(AOTModule *module,
if (symbol_len + 1 <= sizeof(symbol_buf)) if (symbol_len + 1 <= sizeof(symbol_buf))
symbol = symbol_buf; symbol = symbol_buf;
else { else {
if (!(symbol = wasm_malloc(symbol_len + 1))) { if (!(symbol = wasm_runtime_malloc(symbol_len + 1))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -1254,7 +1253,7 @@ do_text_relocation(AOTModule *module,
} }
if (symbol != symbol_buf) if (symbol != symbol_buf)
wasm_free(symbol); wasm_runtime_free(symbol);
if (!apply_relocation(module, if (!apply_relocation(module,
aot_text, aot_text_size, aot_text, aot_text_size,
@ -1270,7 +1269,7 @@ do_text_relocation(AOTModule *module,
check_symbol_fail: check_symbol_fail:
if (symbol != symbol_buf) if (symbol != symbol_buf)
wasm_free(symbol); wasm_runtime_free(symbol);
return false; return false;
} }
@ -1399,7 +1398,7 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
/* Allocate memory for relocation groups */ /* Allocate memory for relocation groups */
size = sizeof(AOTRelocationGroup) * (uint64)group_count; size = sizeof(AOTRelocationGroup) * (uint64)group_count;
if (size >= UINT32_MAX || !(groups = wasm_malloc((uint32)size))) { if (size >= UINT32_MAX || !(groups = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -1442,7 +1441,7 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
size = sizeof(AOTRelocation) * (uint64)group->relocation_count; size = sizeof(AOTRelocation) * (uint64)group->relocation_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(group->relocations = relocation = || !(group->relocations = relocation =
wasm_malloc((uint32)size))) { wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -1522,8 +1521,8 @@ fail:
if (groups) { if (groups) {
for (i = 0, group = groups; i < group_count; i++, group++) for (i = 0, group = groups; i < group_count; i++, group++)
if (group->relocations) if (group->relocations)
wasm_free(group->relocations); wasm_runtime_free(group->relocations);
wasm_free(groups); wasm_runtime_free(groups);
} }
return ret; return ret;
@ -1603,16 +1602,16 @@ load_from_sections(AOTModule *module, AOTSection *sections,
#if BEIHAI_ENABLE_MEMORY_PROFILING != 0 #if BEIHAI_ENABLE_MEMORY_PROFILING != 0
static void aot_free(void *ptr) static void aot_free(void *ptr)
{ {
wasm_free(ptr); wasm_runtime_free(ptr);
} }
#else #else
#define aot_free wasm_free #define aot_free wasm_runtime_free
#endif #endif
static AOTModule* static AOTModule*
create_module(char *error_buf, uint32 error_buf_size) create_module(char *error_buf, uint32 error_buf_size)
{ {
AOTModule *module = wasm_malloc(sizeof(AOTModule)); AOTModule *module = wasm_runtime_malloc(sizeof(AOTModule));
if (!module) { if (!module) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
@ -1634,7 +1633,7 @@ create_module(char *error_buf, uint32 error_buf_size)
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"create const string set failed."); "create const string set failed.");
wasm_free(module); wasm_runtime_free(module);
return NULL; return NULL;
} }
@ -1670,7 +1669,7 @@ destroy_sections(AOTSection *section_list, bool destroy_aot_text)
&& section->section_type == AOT_SECTION_TYPE_TEXT && section->section_type == AOT_SECTION_TYPE_TEXT
&& section->section_body) && section->section_body)
bh_munmap((uint8*)section->section_body, section->section_body_size); bh_munmap((uint8*)section->section_body, section->section_body_size);
wasm_free(section); wasm_runtime_free(section);
section = next; section = next;
} }
} }
@ -1694,7 +1693,7 @@ create_sections(const uint8 *buf, uint32 size,
read_uint32(p, p_end, section_size); read_uint32(p, p_end, section_size);
CHECK_BUF(p, p_end, section_size); CHECK_BUF(p, p_end, section_size);
if (!(section = wasm_malloc(sizeof(AOTSection)))) { if (!(section = wasm_runtime_malloc(sizeof(AOTSection)))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -1722,7 +1721,7 @@ create_sections(const uint8 *buf, uint32 size,
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(aot_text = bh_mmap(NULL, (uint32)total_size, || !(aot_text = bh_mmap(NULL, (uint32)total_size,
map_prot, map_flags))) { map_prot, map_flags))) {
wasm_free(section); wasm_runtime_free(section);
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module load failed: " "AOT module load failed: "
"mmap memory failed."); "mmap memory failed.");
@ -1849,7 +1848,7 @@ aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx,
AOTModule *module; AOTModule *module;
/* Allocate memory for module */ /* Allocate memory for module */
if (!(module = wasm_malloc(sizeof(AOTModule)))) { if (!(module = wasm_runtime_malloc(sizeof(AOTModule)))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Allocate memory for AOT module failed."); "Allocate memory for AOT module failed.");
return NULL; return NULL;
@ -1891,7 +1890,7 @@ aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx,
/* Allocate memory for function pointers */ /* Allocate memory for function pointers */
size = (uint64)module->func_count * sizeof(void *); size = (uint64)module->func_count * sizeof(void *);
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(module->func_ptrs = wasm_malloc((uint32)size))) { || !(module->func_ptrs = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, "Create func ptrs fail."); set_error_buf(error_buf, error_buf_size, "Create func ptrs fail.");
goto fail1; goto fail1;
} }
@ -1913,7 +1912,7 @@ aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx,
/* Allocation memory for function type indexes */ /* Allocation memory for function type indexes */
size = (uint64)module->func_count * sizeof(uint32); size = (uint64)module->func_count * sizeof(uint32);
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(module->func_type_indexes = wasm_malloc((uint32)size))) { || !(module->func_type_indexes = wasm_runtime_malloc((uint32)size))) {
set_error_buf(error_buf, error_buf_size, "Create func type indexes fail."); set_error_buf(error_buf, error_buf_size, "Create func type indexes fail.");
goto fail2; goto fail2;
} }
@ -1965,9 +1964,9 @@ aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx,
return module; return module;
fail2: fail2:
wasm_free(module->func_ptrs); wasm_runtime_free(module->func_ptrs);
fail1: fail1:
wasm_free(module); wasm_runtime_free(module);
return NULL; return NULL;
} }
@ -2067,10 +2066,10 @@ aot_unload(AOTModule *module)
module->is_jit_mode); module->is_jit_mode);
if (module->func_type_indexes) if (module->func_type_indexes)
wasm_free(module->func_type_indexes); wasm_runtime_free(module->func_type_indexes);
if (module->func_ptrs) if (module->func_ptrs)
wasm_free(module->func_ptrs); wasm_runtime_free(module->func_ptrs);
if (module->const_str_set) if (module->const_str_set)
bh_hash_map_destroy(module->const_str_set); bh_hash_map_destroy(module->const_str_set);
@ -2082,7 +2081,7 @@ aot_unload(AOTModule *module)
destroy_object_data_sections(module->data_sections, destroy_object_data_sections(module->data_sections,
module->data_section_count); module->data_section_count);
wasm_free(module); wasm_runtime_free(module);
} }
uint32 uint32

26
core/iwasm/aot/aot_runtime.c
View File

@ -4,7 +4,6 @@
*/ */
#include "aot_runtime.h" #include "aot_runtime.h"
#include "bh_memory.h"
#include "bh_log.h" #include "bh_log.h"
#include "mem_alloc.h" #include "mem_alloc.h"
@ -116,7 +115,7 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModule *module,
/* Allocate memory */ /* Allocate memory */
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(module_inst->memory_data.ptr = wasm_malloc((uint32)total_size))) { || !(module_inst->memory_data.ptr = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module instantiate failed: allocate memory failed."); "AOT module instantiate failed: allocate memory failed.");
return false; return false;
@ -166,7 +165,7 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModule *module,
if (length > 0 if (length > 0
&& (base_offset >= module_inst->memory_data_size && (base_offset >= module_inst->memory_data_size
|| base_offset + length > module_inst->memory_data_size)) { || base_offset + length > module_inst->memory_data_size)) {
wasm_free(module_inst->memory_data.ptr); wasm_runtime_free(module_inst->memory_data.ptr);
module_inst->memory_data.ptr = NULL; module_inst->memory_data.ptr = NULL;
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module instantiate failed: data segment out of range."); "AOT module instantiate failed: data segment out of range.");
@ -193,7 +192,7 @@ init_func_ptrs(AOTModuleInstance *module_inst, AOTModule *module,
/* Allocate memory */ /* Allocate memory */
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(module_inst->func_ptrs.ptr = wasm_malloc((uint32)total_size))) { || !(module_inst->func_ptrs.ptr = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module instantiate failed: allocate memory failed."); "AOT module instantiate failed: allocate memory failed.");
return false; return false;
@ -222,7 +221,8 @@ init_func_type_indexes(AOTModuleInstance *module_inst, AOTModule *module,
/* Allocate memory */ /* Allocate memory */
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(module_inst->func_type_indexes.ptr = wasm_malloc((uint32)total_size))) { || !(module_inst->func_type_indexes.ptr =
wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module instantiate failed: allocate memory failed."); "AOT module instantiate failed: allocate memory failed.");
return false; return false;
@ -304,7 +304,7 @@ aot_instantiate(AOTModule *module,
/* Allocate module instance, global data, table data and heap data */ /* Allocate module instance, global data, table data and heap data */
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(module_inst = wasm_malloc((uint32)total_size))) { || !(module_inst = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"AOT module instantiate failed: allocate memory failed."); "AOT module instantiate failed: allocate memory failed.");
return NULL; return NULL;
@ -407,18 +407,18 @@ aot_deinstantiate(AOTModuleInstance *module_inst)
#endif #endif
if (module_inst->memory_data.ptr) if (module_inst->memory_data.ptr)
wasm_free(module_inst->memory_data.ptr); wasm_runtime_free(module_inst->memory_data.ptr);
if (module_inst->heap_handle.ptr) if (module_inst->heap_handle.ptr)
mem_allocator_destroy(module_inst->heap_handle.ptr); mem_allocator_destroy(module_inst->heap_handle.ptr);
if (module_inst->func_ptrs.ptr) if (module_inst->func_ptrs.ptr)
wasm_free(module_inst->func_ptrs.ptr); wasm_runtime_free(module_inst->func_ptrs.ptr);
if (module_inst->func_type_indexes.ptr) if (module_inst->func_type_indexes.ptr)
wasm_free(module_inst->func_type_indexes.ptr); wasm_runtime_free(module_inst->func_type_indexes.ptr);
wasm_free(module_inst); wasm_runtime_free(module_inst);
} }
AOTFunctionInstance* AOTFunctionInstance*
@ -768,8 +768,8 @@ aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count)
return false; return false;
} }
if (!(mem_data_new = wasm_realloc(mem_data_old, (uint32)total_size))) { if (!(mem_data_new = wasm_runtime_realloc(mem_data_old, (uint32)total_size))) {
if (!(mem_data_new = wasm_malloc((uint32)total_size))) { if (!(mem_data_new = wasm_runtime_malloc((uint32)total_size))) {
aot_set_exception(module_inst, "fail to enlarge memory."); aot_set_exception(module_inst, "fail to enlarge memory.");
return false; return false;
} }
@ -778,7 +778,7 @@ aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count)
mem_data_old, total_size_old); mem_data_old, total_size_old);
memset(mem_data_new + total_size_old, memset(mem_data_new + total_size_old,
0, (uint32)total_size - total_size_old); 0, (uint32)total_size - total_size_old);
wasm_free(mem_data_old); wasm_runtime_free(mem_data_old);
} }
module_inst->mem_cur_page_count = total_page_count; module_inst->mem_cur_page_count = total_page_count;

3
core/iwasm/common/iwasm_common.cmake
View File

@ -5,6 +5,9 @@ set (IWASM_COMMON_DIR ${CMAKE_CURRENT_LIST_DIR})
include_directories (${IWASM_COMMON_DIR}) include_directories (${IWASM_COMMON_DIR})
add_definitions(-DBH_MALLOC=wasm_runtime_malloc)
add_definitions(-DBH_FREE=wasm_runtime_free)
file (GLOB c_source_all ${IWASM_COMMON_DIR}/*.c) file (GLOB c_source_all ${IWASM_COMMON_DIR}/*.c)
if (${WAMR_BUILD_TARGET} STREQUAL "X86_64" OR ${WAMR_BUILD_TARGET} STREQUAL "AMD_64") if (${WAMR_BUILD_TARGET} STREQUAL "X86_64" OR ${WAMR_BUILD_TARGET} STREQUAL "AMD_64")

11
core/iwasm/common/wasm_exec_env.c
View File

@ -4,7 +4,6 @@
*/ */
#include "wasm_exec_env.h" #include "wasm_exec_env.h"
#include "bh_memory.h"
#include "wasm_runtime_common.h" #include "wasm_runtime_common.h"
WASMExecEnv * WASMExecEnv *
@ -16,14 +15,14 @@ wasm_exec_env_create(struct WASMModuleInstanceCommon *module_inst,
WASMExecEnv *exec_env; WASMExecEnv *exec_env;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(exec_env = wasm_malloc((uint32)total_size))) || !(exec_env = wasm_runtime_malloc((uint32)total_size)))
return NULL; return NULL;
memset(exec_env, 0, (uint32)total_size); memset(exec_env, 0, (uint32)total_size);
#if WASM_ENABLE_AOT != 0 #if WASM_ENABLE_AOT != 0
if (!(exec_env->argv_buf = wasm_malloc(sizeof(uint32) * 64))) { if (!(exec_env->argv_buf = wasm_runtime_malloc(sizeof(uint32) * 64))) {
wasm_free(exec_env); wasm_runtime_free(exec_env);
return NULL; return NULL;
} }
#endif #endif
@ -40,9 +39,9 @@ void
wasm_exec_env_destroy(WASMExecEnv *exec_env) wasm_exec_env_destroy(WASMExecEnv *exec_env)
{ {
#if WASM_ENABLE_AOT != 0 #if WASM_ENABLE_AOT != 0
wasm_free(exec_env->argv_buf); wasm_runtime_free(exec_env->argv_buf);
#endif #endif
wasm_free(exec_env); wasm_runtime_free(exec_env);
} }
WASMModuleInstanceCommon * WASMModuleInstanceCommon *

175
core/shared/mem-alloc/bh_memory.c → core/iwasm/common/wasm_memory.c
View File

@ -3,28 +3,26 @@
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/ */
#include "bh_config.h" #include "wasm_runtime_common.h"
#include "bh_platform.h" #include "bh_platform.h"
#include "bh_memory.h"
#include "mem_alloc.h" #include "mem_alloc.h"
#include <stdlib.h> #include "bh_thread.h"
#if BEIHAI_ENABLE_MEMORY_PROFILING != 0 #if BEIHAI_ENABLE_MEMORY_PROFILING != 0
#include "bh_thread.h"
/* Memory profile data of a function */ /* Memory profile data of a function */
typedef struct memory_profile { typedef struct memory_profile {
struct memory_profile *next; struct memory_profile *next;
const char *function_name; const char *function_name;
const char *file_name; const char *file_name;
int line_in_file; int line_in_file;
int malloc_num; int malloc_num;
int free_num; int free_num;
int total_malloc; int total_malloc;
int total_free; int total_free;
} memory_profile_t; } memory_profile_t;
/* Memory in use which grows when bh_malloc was called /* Memory in use which grows when BH_MALLOC was called
* and decreases when bh_free was called */ * and decreases when bh_free was called */
static unsigned int memory_in_use = 0; static unsigned int memory_in_use = 0;
@ -33,7 +31,7 @@ static memory_profile_t *memory_profiles_list = NULL;
/* Lock of the memory profile list */ /* Lock of the memory profile list */
static korp_mutex profile_lock; static korp_mutex profile_lock;
#endif #endif /* end of BEIHAI_ENABLE_MEMORY_PROFILING */
#ifndef MALLOC_MEMORY_FROM_SYSTEM #ifndef MALLOC_MEMORY_FROM_SYSTEM
@ -53,7 +51,8 @@ static void (*free_func)(void *ptr) = NULL;
static unsigned int global_pool_size; static unsigned int global_pool_size;
int bh_memory_init_with_pool(void *mem, unsigned int bytes) static bool
wasm_memory_init_with_pool(void *mem, unsigned int bytes)
{ {
mem_allocator_t _allocator = mem_allocator_create(mem, bytes); mem_allocator_t _allocator = mem_allocator_create(mem, bytes);
@ -64,15 +63,16 @@ int bh_memory_init_with_pool(void *mem, unsigned int bytes)
vm_mutex_init(&profile_lock); vm_mutex_init(&profile_lock);
#endif #endif
global_pool_size = bytes; global_pool_size = bytes;
return 0; return true;
} }
bh_printf("Init memory with pool (%p, %u) failed.\n", mem, bytes); bh_printf("Init memory with pool (%p, %u) failed.\n", mem, bytes);
return -1; return false;
} }
int bh_memory_init_with_allocator_internal(void *_malloc_func, static bool
void *_realloc_func, wasm_memory_init_with_allocator(void *_malloc_func,
void *_free_func) void *_realloc_func,
void *_free_func)
{ {
if (_malloc_func && _free_func && _malloc_func != _free_func) { if (_malloc_func && _free_func && _malloc_func != _free_func) {
memory_mode = MEMORY_MODE_ALLOCATOR; memory_mode = MEMORY_MODE_ALLOCATOR;
@ -82,20 +82,32 @@ int bh_memory_init_with_allocator_internal(void *_malloc_func,
#if BEIHAI_ENABLE_MEMORY_PROFILING != 0 #if BEIHAI_ENABLE_MEMORY_PROFILING != 0
vm_mutex_init(&profile_lock); vm_mutex_init(&profile_lock);
#endif #endif
return 0; return true;
} }
bh_printf("Init memory with allocator (%p, %p) failed.\n", _malloc_func, bh_printf("Init memory with allocator (%p, %p, %p) failed.\n",
_free_func); _malloc_func, _realloc_func, _free_func);
return -1; return false;
} }
int bh_memory_init_with_allocator(void *_malloc_func, void *_free_func) bool
wasm_runtime_memory_init(mem_alloc_type_t mem_alloc_type,
const MemAllocOption *alloc_option)
{ {
return bh_memory_init_with_allocator_internal(_malloc_func, if (mem_alloc_type == Alloc_With_Pool)
NULL, _free_func); return wasm_memory_init_with_pool(alloc_option->pool.heap_buf,
alloc_option->pool.heap_size);
else if (mem_alloc_type == Alloc_With_Allocator)
return wasm_memory_init_with_allocator(alloc_option->allocator.malloc_func,
alloc_option->allocator.realloc_func,
alloc_option->allocator.free_func);
else if (mem_alloc_type == Alloc_With_System_Allocator)
return wasm_memory_init_with_allocator(os_malloc, os_realloc, os_free);
else
return false;
} }
void bh_memory_destroy() void
wasm_runtime_memory_destroy()
{ {
#if BEIHAI_ENABLE_MEMORY_PROFILING != 0 #if BEIHAI_ENABLE_MEMORY_PROFILING != 0
vm_mutex_destroy(&profile_lock); vm_mutex_destroy(&profile_lock);
@ -105,7 +117,8 @@ void bh_memory_destroy()
memory_mode = MEMORY_MODE_UNKNOWN; memory_mode = MEMORY_MODE_UNKNOWN;
} }
unsigned bh_memory_pool_size() unsigned
wasm_runtime_memory_pool_size()
{ {
if (memory_mode == MEMORY_MODE_POOL) if (memory_mode == MEMORY_MODE_POOL)
return global_pool_size; return global_pool_size;
@ -113,10 +126,11 @@ unsigned bh_memory_pool_size()
return 1 * BH_GB; return 1 * BH_GB;
} }
void* bh_malloc_internal(unsigned int size) void *
wasm_runtime_malloc(unsigned int size)
{ {
if (memory_mode == MEMORY_MODE_UNKNOWN) { if (memory_mode == MEMORY_MODE_UNKNOWN) {
bh_printf("bh_malloc failed: memory hasn't been initialize.\n"); bh_printf("wasm_runtime_malloc failed: memory hasn't been initialize.\n");
return NULL; return NULL;
} else if (memory_mode == MEMORY_MODE_POOL) { } else if (memory_mode == MEMORY_MODE_POOL) {
return mem_allocator_malloc(pool_allocator, size); return mem_allocator_malloc(pool_allocator, size);
@ -125,10 +139,11 @@ void* bh_malloc_internal(unsigned int size)
} }
} }
void* bh_realloc_internal(void *ptr, unsigned int size) void *
wasm_runtime_realloc(void *ptr, unsigned int size)
{ {
if (memory_mode == MEMORY_MODE_UNKNOWN) { if (memory_mode == MEMORY_MODE_UNKNOWN) {
bh_printf("bh_realloc failed: memory hasn't been initialize.\n"); bh_printf("wasm_runtime_realloc failed: memory hasn't been initialize.\n");
return NULL; return NULL;
} else if (memory_mode == MEMORY_MODE_POOL) { } else if (memory_mode == MEMORY_MODE_POOL) {
return mem_allocator_realloc(pool_allocator, ptr, size); return mem_allocator_realloc(pool_allocator, ptr, size);
@ -140,10 +155,11 @@ void* bh_realloc_internal(void *ptr, unsigned int size)
} }
} }
void bh_free_internal(void *ptr) void
wasm_runtime_free(void *ptr)
{ {
if (memory_mode == MEMORY_MODE_UNKNOWN) { if (memory_mode == MEMORY_MODE_UNKNOWN) {
bh_printf("bh_free failed: memory hasn't been initialize.\n"); bh_printf("wasm_runtime_free failed: memory hasn't been initialize.\n");
} else if (memory_mode == MEMORY_MODE_POOL) { } else if (memory_mode == MEMORY_MODE_POOL) {
mem_allocator_free(pool_allocator, ptr); mem_allocator_free(pool_allocator, ptr);
} else { } else {
@ -152,12 +168,11 @@ void bh_free_internal(void *ptr)
} }
#if BEIHAI_ENABLE_MEMORY_PROFILING != 0 #if BEIHAI_ENABLE_MEMORY_PROFILING != 0
void* bh_malloc_profile(const char *file, void *
int line, wasm_runtime_malloc_profile(const char *file, int line,
const char *func, const char *func, unsigned int size)
unsigned int size)
{ {
void *p = bh_malloc_internal(size + 8); void *p = wasm_rutime_malloc(size + 8);
if (p) { if (p) {
memory_profile_t *profile; memory_profile_t *profile;
@ -177,7 +192,7 @@ void* bh_malloc_profile(const char *file,
profile->total_malloc += size;/* TODO: overflow check */ profile->total_malloc += size;/* TODO: overflow check */
profile->malloc_num++; profile->malloc_num++;
} else { } else {
profile = bh_malloc_internal(sizeof(memory_profile_t)); profile = wasm_runtime_malloc(sizeof(memory_profile_t));
if (!profile) { if (!profile) {
vm_mutex_unlock(&profile_lock); vm_mutex_unlock(&profile_lock);
bh_memcpy_s(p, size + 8, &size, sizeof(size)); bh_memcpy_s(p, size + 8, &size, sizeof(size));
@ -207,12 +222,14 @@ void* bh_malloc_profile(const char *file,
return NULL; return NULL;
} }
void bh_free_profile(const char *file, int line, const char *func, void *ptr) void
wasm_runtime_free_profile(const char *file, int line,
const char *func, void *ptr)
{ {
unsigned int size = *(unsigned int *)((char *)ptr - 8); unsigned int size = *(unsigned int *)((char *)ptr - 8);
memory_profile_t *profile; memory_profile_t *profile;
bh_free_internal((char *)ptr - 8); wasm_runtime_free((char *)ptr - 8);
if (memory_in_use >= size) if (memory_in_use >= size)
memory_in_use -= size; memory_in_use -= size;
@ -232,7 +249,7 @@ void bh_free_profile(const char *file, int line, const char *func, void *ptr)
profile->total_free += size;/* TODO: overflow check */ profile->total_free += size;/* TODO: overflow check */
profile->free_num++; profile->free_num++;
} else { } else {
profile = bh_malloc_internal(sizeof(memory_profile_t)); profile = wasm_runtime_malloc(sizeof(memory_profile_t));
if (!profile) { if (!profile) {
vm_mutex_unlock(&profile_lock); vm_mutex_unlock(&profile_lock);
return; return;
@ -265,70 +282,53 @@ void memory_usage_summarize()
profile = memory_profiles_list; profile = memory_profiles_list;
while (profile) { while (profile) {
bh_printf("malloc:%d:malloc_num:%d:free:%d:free_num:%d:%s\n", bh_printf("malloc:%d:malloc_num:%d:free:%d:free_num:%d:%s\n",
profile->total_malloc, profile->total_malloc,
profile->malloc_num, profile->malloc_num,
profile->total_free, profile->total_free,
profile->free_num, profile->free_num,
profile->function_name); profile->function_name);
profile = profile->next; profile = profile->next;
} }
vm_mutex_unlock(&profile_lock); vm_mutex_unlock(&profile_lock);
} }
void memory_profile_print(const char *file, void
int line, memory_profile_print(const char *file, int line,
const char *func, const char *func, int alloc)
int alloc)
{ {
bh_printf("location:%s@%d:used:%d:contribution:%d\n", bh_printf("location:%s@%d:used:%d:contribution:%d\n",
func, line, memory_in_use, alloc); func, line, memory_in_use, alloc);
} }
#else #endif /* end of BEIHAI_ENABLE_MEMORY_PROFILING */
void* bh_malloc(unsigned int size)
{
return bh_malloc_internal(size);
}
void* bh_realloc(void *ptr, unsigned int size)
{
return bh_realloc_internal(ptr, size);
}
void bh_free(void *ptr)
{
bh_free_internal(ptr);
}
#endif
#else /* else of MALLOC_MEMORY_FROM_SYSTEM */ #else /* else of MALLOC_MEMORY_FROM_SYSTEM */
#if BEIHAI_ENABLE_MEMORY_PROFILING == 0
void* bh_malloc(unsigned int size) void *
wasm_runtime_malloc(unsigned int size)
{ {
return malloc(size); return malloc(size);
} }
void* bh_realloc(void *ptr, unsigned int size) void *
wasm_runtime_realloc(void *ptr, unsigned int size)
{ {
return realloc(ptr, size); return realloc(ptr, size);
} }
void bh_free(void *ptr) void
wasm_runtime_free(void *ptr)
{ {
if (ptr) if (ptr)
free(ptr); free(ptr);
} }
#else /* else of BEIHAI_ENABLE_MEMORY_PROFILING */ #if BEIHAI_ENABLE_MEMORY_PROFILING != 0
void *
void* bh_malloc_profile(const char *file, wasm_runtime_malloc_profile(const char *file, int line,
int line, const char *func, unsigned int size)
const char *func,
unsigned int size)
{ {
(void)file; (void)file;
(void)line; (void)line;
@ -341,11 +341,9 @@ void* bh_malloc_profile(const char *file,
return malloc(size); return malloc(size);
} }
void* bh_realloc_profile(const char *file, void *
int line, wasm_runtime_realloc_profile(const char *file, int line,
const char *func, const char *func, void *ptr, unsigned int size)
void *ptr,
unsigned int size)
{ {
(void)file; (void)file;
(void)line; (void)line;
@ -358,7 +356,9 @@ void* bh_realloc_profile(const char *file,
return realloc(ptr, size); return realloc(ptr, size);
} }
void bh_free_profile(const char *file, int line, const char *func, void *ptr) void
wasm_runtime_free_profile(const char *file, int line,
const char *func, void *ptr)
{ {
(void)file; (void)file;
(void)line; (void)line;
@ -369,3 +369,4 @@ void bh_free_profile(const char *file, int line, const char *func, void *ptr)
} }
#endif /* end of BEIHAI_ENABLE_MEMORY_PROFILING */ #endif /* end of BEIHAI_ENABLE_MEMORY_PROFILING */
#endif /* end of MALLOC_MEMORY_FROM_SYSTEM*/ #endif /* end of MALLOC_MEMORY_FROM_SYSTEM*/

28
core/iwasm/common/wasm_memory.h Normal file
View File

@ -0,0 +1,28 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#ifndef _WASM_MEMORY_H
#define _WASM_MEMORY_H
#include "bh_common.h"
#include "../include/wasm_export.h"
#ifdef __cplusplus
extern "C" {
#endif
bool
wasm_runtime_memory_init(mem_alloc_type_t mem_alloc_type,
const MemAllocOption *alloc_option);
void
wasm_runtime_memory_destroy();
#ifdef __cplusplus
}
#endif
#endif /* end of _WASM_MEMORY_H */

4
core/iwasm/common/wasm_native.c
View File

@ -184,7 +184,7 @@ wasm_native_register_natives(const char *module_name,
{ {
NativeSymbolsNode *node; NativeSymbolsNode *node;
if (!(node = bh_malloc(sizeof(NativeSymbolsNode)))) if (!(node = wasm_runtime_malloc(sizeof(NativeSymbolsNode))))
return false; return false;
node->module_name = module_name; node->module_name = module_name;
@ -256,7 +256,7 @@ wasm_native_destroy()
node = g_native_symbols_list; node = g_native_symbols_list;
while (node) { while (node) {
node_next = node->next; node_next = node->next;
bh_free(node); wasm_runtime_free(node);
node = node_next; node = node_next;
} }

91
core/iwasm/common/wasm_runtime_common.c
View File

@ -9,6 +9,7 @@
#include "bh_assert.h" #include "bh_assert.h"
#include "bh_log.h" #include "bh_log.h"
#include "wasm_runtime_common.h" #include "wasm_runtime_common.h"
#include "wasm_memory.h"
#if WASM_ENABLE_INTERP != 0 #if WASM_ENABLE_INTERP != 0
#include "../interpreter/wasm_runtime.h" #include "../interpreter/wasm_runtime.h"
#endif #endif
@ -23,8 +24,8 @@ set_error_buf(char *error_buf, uint32 error_buf_size, const char *string)
snprintf(error_buf, error_buf_size, "%s", string); snprintf(error_buf, error_buf_size, "%s", string);
} }
bool static bool
wasm_runtime_init() wasm_runtime_env_init()
{ {
if (bh_platform_init() != 0) if (bh_platform_init() != 0)
return false; return false;
@ -35,8 +36,20 @@ wasm_runtime_init()
if (vm_thread_sys_init() != 0) if (vm_thread_sys_init() != 0)
return false; return false;
if (wasm_native_init() == false) { if (wasm_native_init() == false)
wasm_runtime_destroy(); return false;
return true;
}
bool
wasm_runtime_init()
{
if (!wasm_runtime_memory_init(Alloc_With_System_Allocator, NULL))
return false;
if (!wasm_runtime_env_init()) {
wasm_runtime_memory_destroy();
return false; return false;
} }
@ -48,56 +61,30 @@ wasm_runtime_destroy()
{ {
wasm_native_destroy(); wasm_native_destroy();
vm_thread_sys_destroy(); vm_thread_sys_destroy();
wasm_runtime_memory_destroy();
} }
int bh_memory_init_with_allocator_internal(void *_malloc_func,
void *_realloc_func,
void *_free_func);
bool bool
wasm_runtime_full_init(RuntimeInitArgs *init_args) wasm_runtime_full_init(RuntimeInitArgs *init_args)
{ {
if (init_args->mem_alloc_type == Alloc_With_Pool) { if (!wasm_runtime_memory_init(init_args->mem_alloc_type,
void *heap_buf = init_args->mem_alloc.pool.heap_buf; &init_args->mem_alloc_option))
uint32 heap_size = init_args->mem_alloc.pool.heap_size;
if (bh_memory_init_with_pool(heap_buf, heap_size) != 0)
return false;
}
else if (init_args->mem_alloc_type == Alloc_With_Allocator) {
void *malloc_func = init_args->mem_alloc.allocator.malloc_func;
void *realloc_func = init_args->mem_alloc.allocator.realloc_func;
void *free_func = init_args->mem_alloc.allocator.free_func;
if (bh_memory_init_with_allocator_internal(malloc_func,
realloc_func,
free_func) != 0)
return false;
}
else
return false; return false;
if (!wasm_runtime_init()) if (!wasm_runtime_env_init()) {
goto fail1; wasm_runtime_memory_destroy();
return false;
}
if (init_args->n_native_symbols > 0 if (init_args->n_native_symbols > 0
&& !wasm_runtime_register_natives(init_args->native_module_name, && !wasm_runtime_register_natives(init_args->native_module_name,
init_args->native_symbols, init_args->native_symbols,
init_args->n_native_symbols)) init_args->n_native_symbols)) {
goto fail2; wasm_runtime_destroy();
return false;
}
return true; return true;
fail2:
wasm_runtime_destroy();
fail1:
bh_memory_destroy();
return false;
}
void
wasm_runtime_full_destroy()
{
wasm_runtime_destroy();
bh_memory_destroy();
} }
PackageType PackageType
@ -723,7 +710,7 @@ wasm_runtime_init_wasi(WASMModuleInstanceCommon *module_inst,
uint64 total_size; uint64 total_size;
uint32 i; uint32 i;
if (!(wasi_ctx = wasm_malloc(sizeof(WASIContext)))) { if (!(wasi_ctx = wasm_runtime_malloc(sizeof(WASIContext)))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Init wasi environment failed: allocate memory failed."); "Init wasi environment failed: allocate memory failed.");
return false; return false;
@ -952,7 +939,7 @@ wasm_runtime_destroy_wasi(WASMModuleInstanceCommon *module_inst)
fd_table_destroy(wasi_ctx->curfds); fd_table_destroy(wasi_ctx->curfds);
if (wasi_ctx->prestats) if (wasi_ctx->prestats)
fd_prestats_destroy(wasi_ctx->prestats); fd_prestats_destroy(wasi_ctx->prestats);
bh_free(wasi_ctx); wasm_runtime_free(wasi_ctx);
} }
} }
@ -1272,7 +1259,7 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst,
total_size = sizeof(uint32) * (uint64)(argc1 > 2 ? argc1 : 2); total_size = sizeof(uint32) * (uint64)(argc1 > 2 ? argc1 : 2);
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| (!(argv1 = wasm_malloc((uint32)total_size)))) { || (!(argv1 = wasm_runtime_malloc((uint32)total_size)))) {
wasm_runtime_set_exception(module_inst, "allocate memory failed."); wasm_runtime_set_exception(module_inst, "allocate memory failed.");
goto fail; goto fail;
} }
@ -1417,12 +1404,12 @@ wasm_application_execute_func(WASMModuleInstanceCommon *module_inst,
} }
bh_printf("\n"); bh_printf("\n");
wasm_free(argv1); wasm_runtime_free(argv1);
return true; return true;
fail: fail:
if (argv1) if (argv1)
wasm_free(argv1); wasm_runtime_free(argv1);
exception = wasm_runtime_get_exception(module_inst); exception = wasm_runtime_get_exception(module_inst);
bh_assert(exception); bh_assert(exception);
@ -1551,7 +1538,7 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
if (argc1 > sizeof(argv_buf) / sizeof(uint32)) { if (argc1 > sizeof(argv_buf) / sizeof(uint32)) {
size = sizeof(uint32) * (uint32)argc1; size = sizeof(uint32) * (uint32)argc1;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(argv1 = wasm_malloc((uint32)size))) { || !(argv1 = wasm_runtime_malloc((uint32)size))) {
wasm_runtime_set_exception(exec_env->module_inst, wasm_runtime_set_exception(exec_env->module_inst,
"allocate memory failed."); "allocate memory failed.");
return false; return false;
@ -1679,7 +1666,7 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
fail: fail:
if (argv1 != argv_buf) if (argv1 != argv_buf)
wasm_free(argv1); wasm_runtime_free(argv1);
return ret; return ret;
} }
#endif /* end of defined(BUILD_TARGET_ARM_VFP) || defined(BUILD_TARGET_THUMB_VFP) */ #endif /* end of defined(BUILD_TARGET_ARM_VFP) || defined(BUILD_TARGET_THUMB_VFP) */
@ -1726,7 +1713,7 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
if (argc1 > sizeof(argv_buf) / sizeof(uint32)) { if (argc1 > sizeof(argv_buf) / sizeof(uint32)) {
size = sizeof(uint32) * (uint64)argc1; size = sizeof(uint32) * (uint64)argc1;
if (size >= UINT_MAX if (size >= UINT_MAX
|| !(argv1 = wasm_malloc((uint32)size))) { || !(argv1 = wasm_runtime_malloc((uint32)size))) {
wasm_runtime_set_exception(exec_env->module_inst, wasm_runtime_set_exception(exec_env->module_inst,
"allocate memory failed."); "allocate memory failed.");
return false; return false;
@ -1819,7 +1806,7 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
fail: fail:
if (argv1 != argv_buf) if (argv1 != argv_buf)
wasm_free(argv1); wasm_runtime_free(argv1);
return ret; return ret;
} }
@ -1874,7 +1861,7 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
if (argc1 > sizeof(argv_buf) / sizeof(uint64)) { if (argc1 > sizeof(argv_buf) / sizeof(uint64)) {
size = sizeof(uint64) * (uint64)argc1; size = sizeof(uint64) * (uint64)argc1;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(argv1 = wasm_malloc((uint32)size))) { || !(argv1 = wasm_runtime_malloc((uint32)size))) {
wasm_runtime_set_exception(exec_env->module_inst, wasm_runtime_set_exception(exec_env->module_inst,
"allocate memory failed."); "allocate memory failed.");
return false; return false;
@ -1976,7 +1963,7 @@ wasm_runtime_invoke_native(WASMExecEnv *exec_env, void *func_ptr,
ret = true; ret = true;
fail: fail:
if (argv1 != argv_buf) if (argv1 != argv_buf)
wasm_free(argv1); wasm_runtime_free(argv1);
return ret; return ret;
} }

9
core/iwasm/common/wasm_runtime_common.h
View File

@ -22,9 +22,6 @@
extern "C" { extern "C" {
#endif #endif
#define wasm_malloc bh_malloc
#define wasm_realloc bh_realloc
#define wasm_free bh_free
typedef struct WASMModuleCommon { typedef struct WASMModuleCommon {
/* Module type, for module loaded from WASM bytecode binary, /* Module type, for module loaded from WASM bytecode binary,
@ -63,17 +60,13 @@ typedef wasm_section_t WASMSection, AOTSection;
bool bool
wasm_runtime_init(); wasm_runtime_init();
/* See wasm_export.h for description */
void
wasm_runtime_destroy();
/* See wasm_export.h for description */ /* See wasm_export.h for description */
bool bool
wasm_runtime_full_init(RuntimeInitArgs *init_args); wasm_runtime_full_init(RuntimeInitArgs *init_args);
/* See wasm_export.h for description */ /* See wasm_export.h for description */
void void
wasm_runtime_full_destroy(); wasm_runtime_destroy();
/* See wasm_export.h for description */ /* See wasm_export.h for description */
PackageType PackageType

53
core/iwasm/compilation/aot.c
View File

@ -4,7 +4,6 @@
*/ */
#include "aot.h" #include "aot.h"
#include "bh_memory.h"
static char aot_error[128]; static char aot_error[128];
@ -30,8 +29,8 @@ aot_destroy_mem_init_data_list(AOTMemInitData **data_list, uint32 count)
uint32 i; uint32 i;
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
if (data_list[i]) if (data_list[i])
wasm_free(data_list[i]); wasm_runtime_free(data_list[i]);
wasm_free(data_list); wasm_runtime_free(data_list);
} }
static AOTMemInitData ** static AOTMemInitData **
@ -44,7 +43,7 @@ aot_create_mem_init_data_list(const WASMModule *module)
/* Allocate memory */ /* Allocate memory */
size = sizeof(AOTMemInitData *) * (uint64)module->data_seg_count; size = sizeof(AOTMemInitData *) * (uint64)module->data_seg_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(data_list = wasm_malloc((uint32)size))) { || !(data_list = wasm_runtime_malloc((uint32)size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return NULL; return NULL;
} }
@ -56,7 +55,7 @@ aot_create_mem_init_data_list(const WASMModule *module)
size = offsetof(AOTMemInitData, bytes) + size = offsetof(AOTMemInitData, bytes) +
(uint64)module->data_segments[i]->data_length; (uint64)module->data_segments[i]->data_length;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(data_list[i] = wasm_malloc((uint32)size))) { || !(data_list[i] = wasm_runtime_malloc((uint32)size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
goto fail; goto fail;
} }
@ -80,8 +79,8 @@ aot_destroy_table_init_data_list(AOTTableInitData **data_list, uint32 count)
uint32 i; uint32 i;
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
if (data_list[i]) if (data_list[i])
wasm_free(data_list[i]); wasm_runtime_free(data_list[i]);
wasm_free(data_list); wasm_runtime_free(data_list);
} }
static AOTTableInitData ** static AOTTableInitData **
@ -94,7 +93,7 @@ aot_create_table_init_data_list(const WASMModule *module)
/* Allocate memory */ /* Allocate memory */
size = sizeof(AOTTableInitData *) * (uint64)module->table_seg_count; size = sizeof(AOTTableInitData *) * (uint64)module->table_seg_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(data_list = wasm_malloc((uint32)size))) { || !(data_list = wasm_runtime_malloc((uint32)size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return NULL; return NULL;
} }
@ -106,7 +105,7 @@ aot_create_table_init_data_list(const WASMModule *module)
size = offsetof(AOTTableInitData, func_indexes) + size = offsetof(AOTTableInitData, func_indexes) +
sizeof(uint32) * (uint64)module->table_segments[i].function_count; sizeof(uint32) * (uint64)module->table_segments[i].function_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(data_list[i] = wasm_malloc((uint32)size))) { || !(data_list[i] = wasm_runtime_malloc((uint32)size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
goto fail; goto fail;
} }
@ -135,7 +134,7 @@ aot_create_import_globals(const WASMModule *module,
/* Allocate memory */ /* Allocate memory */
size = sizeof(AOTImportGlobal) * (uint64)module->import_global_count; size = sizeof(AOTImportGlobal) * (uint64)module->import_global_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(import_globals = wasm_malloc((uint32)size))) { || !(import_globals = wasm_runtime_malloc((uint32)size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return NULL; return NULL;
} }
@ -172,7 +171,7 @@ aot_create_globals(const WASMModule *module,
/* Allocate memory */ /* Allocate memory */
size = sizeof(AOTGlobal) * (uint64)module->global_count; size = sizeof(AOTGlobal) * (uint64)module->global_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(globals = wasm_malloc((uint32)size))) { || !(globals = wasm_runtime_malloc((uint32)size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return NULL; return NULL;
} }
@ -202,8 +201,8 @@ aot_destroy_func_types(AOTFuncType **func_types, uint32 count)
uint32 i; uint32 i;
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
if (func_types[i]) if (func_types[i])
wasm_free(func_types[i]); wasm_runtime_free(func_types[i]);
wasm_free(func_types); wasm_runtime_free(func_types);
} }
static AOTFuncType ** static AOTFuncType **
@ -216,7 +215,7 @@ aot_create_func_types(const WASMModule *module)
/* Allocate memory */ /* Allocate memory */
size = sizeof(AOTFuncType*) * (uint64)module->type_count; size = sizeof(AOTFuncType*) * (uint64)module->type_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(func_types = wasm_malloc((uint32)size))) { || !(func_types = wasm_runtime_malloc((uint32)size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return NULL; return NULL;
} }
@ -229,7 +228,7 @@ aot_create_func_types(const WASMModule *module)
(uint64)module->types[i]->param_count + (uint64)module->types[i]->param_count +
(uint64)module->types[i]->result_count; (uint64)module->types[i]->result_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(func_types[i] = wasm_malloc((uint32)size))) { || !(func_types[i] = wasm_runtime_malloc((uint32)size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
goto fail; goto fail;
} }
@ -253,7 +252,7 @@ aot_create_import_funcs(const WASMModule *module)
/* Allocate memory */ /* Allocate memory */
size = sizeof(AOTImportFunc) * (uint64)module->import_function_count; size = sizeof(AOTImportFunc) * (uint64)module->import_function_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(import_funcs = wasm_malloc((uint32)size))) { || !(import_funcs = wasm_runtime_malloc((uint32)size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return NULL; return NULL;
} }
@ -284,8 +283,8 @@ aot_destroy_funcs(AOTFunc **funcs, uint32 count)
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
if (funcs[i]) if (funcs[i])
wasm_free(funcs[i]); wasm_runtime_free(funcs[i]);
wasm_free(funcs); wasm_runtime_free(funcs);
} }
static AOTFunc ** static AOTFunc **
@ -298,7 +297,7 @@ aot_create_funcs(const WASMModule *module)
/* Allocate memory */ /* Allocate memory */
size = sizeof(AOTFunc*) * (uint64)module->function_count; size = sizeof(AOTFunc*) * (uint64)module->function_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(funcs = wasm_malloc((uint32)size))) { || !(funcs = wasm_runtime_malloc((uint32)size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return NULL; return NULL;
} }
@ -309,7 +308,7 @@ aot_create_funcs(const WASMModule *module)
for (i = 0; i < module->function_count; i++) { for (i = 0; i < module->function_count; i++) {
WASMFunction *func = module->functions[i]; WASMFunction *func = module->functions[i];
size = sizeof (AOTFunc); size = sizeof (AOTFunc);
if (!(funcs[i] = wasm_malloc((uint32)size))) { if (!(funcs[i] = wasm_runtime_malloc((uint32)size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
goto fail; goto fail;
} }
@ -348,7 +347,7 @@ aot_create_export_funcs(const WASMModule *module,
/* Allocate memory */ /* Allocate memory */
size = sizeof(AOTExportFunc) * (uint64)export_func_count; size = sizeof(AOTExportFunc) * (uint64)export_func_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(export_funcs = wasm_malloc((uint32)size))) { || !(export_funcs = wasm_runtime_malloc((uint32)size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return NULL; return NULL;
} }
@ -376,7 +375,7 @@ aot_create_comp_data(WASMModule *module)
uint32 import_global_data_size = 0, global_data_size = 0, i; uint32 import_global_data_size = 0, global_data_size = 0, i;
/* Allocate memory */ /* Allocate memory */
if (!(comp_data = wasm_malloc(sizeof(AOTCompData)))) { if (!(comp_data = wasm_runtime_malloc(sizeof(AOTCompData)))) {
aot_set_last_error("create compile data failed.\n"); aot_set_last_error("create compile data failed.\n");
return NULL; return NULL;
} }
@ -492,24 +491,24 @@ aot_destroy_comp_data(AOTCompData *comp_data)
comp_data->table_init_data_count); comp_data->table_init_data_count);
if (comp_data->import_globals) if (comp_data->import_globals)
wasm_free(comp_data->import_globals); wasm_runtime_free(comp_data->import_globals);
if (comp_data->globals) if (comp_data->globals)
wasm_free(comp_data->globals); wasm_runtime_free(comp_data->globals);
if (comp_data->func_types) if (comp_data->func_types)
aot_destroy_func_types(comp_data->func_types, aot_destroy_func_types(comp_data->func_types,
comp_data->func_type_count); comp_data->func_type_count);
if (comp_data->import_funcs) if (comp_data->import_funcs)
wasm_free(comp_data->import_funcs); wasm_runtime_free(comp_data->import_funcs);
if (comp_data->funcs) if (comp_data->funcs)
aot_destroy_funcs(comp_data->funcs, comp_data->func_count); aot_destroy_funcs(comp_data->funcs, comp_data->func_count);
if (comp_data->export_funcs) if (comp_data->export_funcs)
wasm_free(comp_data->export_funcs); wasm_runtime_free(comp_data->export_funcs);
wasm_free(comp_data); wasm_runtime_free(comp_data);
} }

8
core/iwasm/compilation/aot_compiler.c
View File

@ -14,7 +14,6 @@
#include "aot_emit_control.h" #include "aot_emit_control.h"
#include "aot_emit_function.h" #include "aot_emit_function.h"
#include "aot_emit_parametric.h" #include "aot_emit_parametric.h"
#include "bh_memory.h"
#include "../aot/aot_runtime.h" #include "../aot/aot_runtime.h"
#include "../interpreter/wasm_opcode.h" #include "../interpreter/wasm_opcode.h"
#include <errno.h> #include <errno.h>
@ -152,7 +151,8 @@ aot_compile_func(AOTCompContext *comp_ctx, uint32 func_index)
case WASM_OP_BR_TABLE: case WASM_OP_BR_TABLE:
read_leb_uint32(frame_ip, frame_ip_end, br_count); read_leb_uint32(frame_ip, frame_ip_end, br_count);
if (!(br_depths = wasm_malloc((uint32)sizeof(uint32) * (br_count + 1)))) { if (!(br_depths =
wasm_runtime_malloc((uint32)sizeof(uint32) * (br_count + 1)))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
goto fail; goto fail;
} }
@ -161,11 +161,11 @@ aot_compile_func(AOTCompContext *comp_ctx, uint32 func_index)
if (!aot_compile_op_br_table(comp_ctx, func_ctx, if (!aot_compile_op_br_table(comp_ctx, func_ctx,
br_depths, br_count, &frame_ip)) { br_depths, br_count, &frame_ip)) {
wasm_free(br_depths); wasm_runtime_free(br_depths);
return false; return false;
} }
wasm_free(br_depths); wasm_runtime_free(br_depths);
break; break;
case WASM_OP_RETURN: case WASM_OP_RETURN:

15
core/iwasm/compilation/aot_compiler.h
View File

@ -8,7 +8,6 @@
#include "aot.h" #include "aot.h"
#include "aot_llvm.h" #include "aot_llvm.h"
#include "bh_memory.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -103,7 +102,7 @@ typedef enum FloatArithmetic {
&& (aot_value->type != VALUE_TYPE_I32 \ && (aot_value->type != VALUE_TYPE_I32 \
&& aot_value->type != VALUE_TYPE_I1))) { \ && aot_value->type != VALUE_TYPE_I1))) { \
aot_set_last_error("invalid WASM stack data type."); \ aot_set_last_error("invalid WASM stack data type."); \
wasm_free(aot_value); \ wasm_runtime_free(aot_value); \
goto fail; \ goto fail; \
} \ } \
if (aot_value->type == value_type) \ if (aot_value->type == value_type) \
@ -113,11 +112,11 @@ typedef enum FloatArithmetic {
if (!(llvm_value = LLVMBuildZExt(comp_ctx->builder, \ if (!(llvm_value = LLVMBuildZExt(comp_ctx->builder, \
aot_value->value, I32_TYPE, "i1toi32"))) { \ aot_value->value, I32_TYPE, "i1toi32"))) { \
aot_set_last_error("invalid WASM stack data type.");\ aot_set_last_error("invalid WASM stack data type.");\
wasm_free(aot_value); \ wasm_runtime_free(aot_value); \
goto fail; \ goto fail; \
} \ } \
} \ } \
wasm_free(aot_value); \ wasm_runtime_free(aot_value); \
} while (0) } while (0)
#define POP_I32(v) POP(v, VALUE_TYPE_I32) #define POP_I32(v) POP(v, VALUE_TYPE_I32)
@ -133,7 +132,7 @@ typedef enum FloatArithmetic {
if (aot_value->type != VALUE_TYPE_I1 \ if (aot_value->type != VALUE_TYPE_I1 \
&& aot_value->type != VALUE_TYPE_I32) { \ && aot_value->type != VALUE_TYPE_I32) { \
aot_set_last_error("invalid WASM stack data type."); \ aot_set_last_error("invalid WASM stack data type."); \
wasm_free(aot_value); \ wasm_runtime_free(aot_value); \
goto fail; \ goto fail; \
} \ } \
if (aot_value->type == VALUE_TYPE_I1) \ if (aot_value->type == VALUE_TYPE_I1) \
@ -143,11 +142,11 @@ typedef enum FloatArithmetic {
LLVMIntNE, aot_value->value, I32_ZERO, \ LLVMIntNE, aot_value->value, I32_ZERO, \
"i1_cond"))){ \ "i1_cond"))){ \
aot_set_last_error("llvm build trunc failed."); \ aot_set_last_error("llvm build trunc failed."); \
wasm_free(aot_value); \ wasm_runtime_free(aot_value); \
goto fail; \ goto fail; \
} \ } \
} \ } \
wasm_free(aot_value); \ wasm_runtime_free(aot_value); \
} while (0) } while (0)
#define PUSH(llvm_value, value_type) do { \ #define PUSH(llvm_value, value_type) do { \
@ -156,7 +155,7 @@ typedef enum FloatArithmetic {
aot_set_last_error("WASM block stack underflow."); \ aot_set_last_error("WASM block stack underflow."); \
goto fail; \ goto fail; \
} \ } \
aot_value = wasm_malloc(sizeof(AOTValue)); \ aot_value = wasm_runtime_malloc(sizeof(AOTValue)); \
memset(aot_value, 0, sizeof(AOTValue)); \ memset(aot_value, 0, sizeof(AOTValue)); \
if (!aot_value) { \ if (!aot_value) { \
aot_set_last_error("allocate memory failed."); \ aot_set_last_error("allocate memory failed."); \

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

@ -509,7 +509,7 @@ get_relocation_symbol_index(const char *symbol_name,
} }
/* Not found in symbol_list, add it */ /* Not found in symbol_list, add it */
sym = bh_malloc(sizeof(AOTSymbolNode)); sym = wasm_runtime_malloc(sizeof(AOTSymbolNode));
if (!sym) { if (!sym) {
return (uint32)-1; return (uint32)-1;
} }
@ -1492,7 +1492,7 @@ aot_resolve_object_data_sections(AOTObjectData *obj_data)
if (sections_count > 0) { if (sections_count > 0) {
size = (uint32)sizeof(AOTObjectDataSection) * sections_count; size = (uint32)sizeof(AOTObjectDataSection) * sections_count;
if (!(data_section = obj_data->data_sections = bh_malloc(size))) { if (!(data_section = obj_data->data_sections = wasm_runtime_malloc(size))) {
aot_set_last_error("allocate memory for data sections failed."); aot_set_last_error("allocate memory for data sections failed.");
return false; return false;
} }
@ -1531,7 +1531,7 @@ aot_resolve_functions(AOTCompContext *comp_ctx, AOTObjectData *obj_data)
/* allocate memory for aot function */ /* allocate memory for aot function */
obj_data->func_count = comp_ctx->comp_data->func_count; obj_data->func_count = comp_ctx->comp_data->func_count;
if (!(obj_data->funcs if (!(obj_data->funcs
= bh_malloc((uint32)sizeof(AOTObjectFunc) * obj_data->func_count))) { = wasm_runtime_malloc((uint32)sizeof(AOTObjectFunc) * obj_data->func_count))) {
aot_set_last_error("allocate memory for functions failed."); aot_set_last_error("allocate memory for functions failed.");
return false; return false;
} }
@ -1602,7 +1602,7 @@ aot_resolve_object_relocation_group(AOTObjectData *obj_data,
return false; return false;
} }
size = (uint32)sizeof(AOTRelocation) * group->relocation_count; size = (uint32)sizeof(AOTRelocation) * group->relocation_count;
if (!(relocation = group->relocations = bh_malloc(size))) { if (!(relocation = group->relocations = wasm_runtime_malloc(size))) {
aot_set_last_error("allocate memory for relocations failed."); aot_set_last_error("allocate memory for relocations failed.");
return false; return false;
} }
@ -1754,7 +1754,7 @@ aot_resolve_object_relocation_groups(AOTObjectData *obj_data)
return true; return true;
size = (uint32)sizeof(AOTRelocationGroup) * group_count; size = (uint32)sizeof(AOTRelocationGroup) * group_count;
if (!(relocation_group = obj_data->relocation_groups = bh_malloc(size))) { if (!(relocation_group = obj_data->relocation_groups = wasm_runtime_malloc(size))) {
aot_set_last_error("allocate memory for relocation groups failed."); aot_set_last_error("allocate memory for relocation groups failed.");
return false; return false;
} }
@ -1795,8 +1795,8 @@ destroy_relocation_groups(AOTRelocationGroup *relocation_groups,
for (i = 0; i < relocation_group_count; i++, relocation_group++) for (i = 0; i < relocation_group_count; i++, relocation_group++)
if (relocation_group->relocations) if (relocation_group->relocations)
bh_free(relocation_group->relocations); wasm_runtime_free(relocation_group->relocations);
bh_free(relocation_groups); wasm_runtime_free(relocation_groups);
} }
static void static void
@ -1807,7 +1807,7 @@ destroy_relocation_symbol_list(AOTSymbolList *symbol_list)
elem = symbol_list->head; elem = symbol_list->head;
while (elem) { while (elem) {
AOTSymbolNode *next = elem->next; AOTSymbolNode *next = elem->next;
bh_free(elem); wasm_runtime_free(elem);
elem = next; elem = next;
} }
} }
@ -1820,15 +1820,15 @@ aot_obj_data_destroy(AOTObjectData *obj_data)
if (obj_data->mem_buf) if (obj_data->mem_buf)
LLVMDisposeMemoryBuffer(obj_data->mem_buf); LLVMDisposeMemoryBuffer(obj_data->mem_buf);
if (obj_data->funcs) if (obj_data->funcs)
bh_free(obj_data->funcs); wasm_runtime_free(obj_data->funcs);
if (obj_data->data_sections) if (obj_data->data_sections)
bh_free(obj_data->data_sections); wasm_runtime_free(obj_data->data_sections);
if (obj_data->relocation_groups) if (obj_data->relocation_groups)
destroy_relocation_groups(obj_data->relocation_groups, destroy_relocation_groups(obj_data->relocation_groups,
obj_data->relocation_group_count); obj_data->relocation_group_count);
if (obj_data->symbol_list.len) if (obj_data->symbol_list.len)
destroy_relocation_symbol_list(&obj_data->symbol_list); destroy_relocation_symbol_list(&obj_data->symbol_list);
bh_free(obj_data); wasm_runtime_free(obj_data);
} }
static AOTObjectData * static AOTObjectData *
@ -1837,7 +1837,7 @@ aot_obj_data_create(AOTCompContext *comp_ctx)
char *err = NULL; char *err = NULL;
AOTObjectData *obj_data; AOTObjectData *obj_data;
if (!(obj_data = bh_malloc(sizeof(AOTObjectData)))) { if (!(obj_data = wasm_runtime_malloc(sizeof(AOTObjectData)))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return false; return false;
} }
@ -1896,7 +1896,7 @@ aot_emit_aot_file(AOTCompContext *comp_ctx, AOTCompData *comp_data,
aot_file_size = get_aot_file_size(comp_data, obj_data); aot_file_size = get_aot_file_size(comp_data, obj_data);
if (!(buf = aot_file_buf = bh_malloc(aot_file_size))) { if (!(buf = aot_file_buf = wasm_runtime_malloc(aot_file_size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
goto fail1; goto fail1;
} }
@ -1938,7 +1938,7 @@ fail3:
fclose(file); fclose(file);
fail2: fail2:
bh_free(aot_file_buf); wasm_runtime_free(aot_file_buf);
fail1: fail1:
aot_obj_data_destroy(obj_data); aot_obj_data_destroy(obj_data);

7
core/iwasm/compilation/aot_emit_control.c
View File

@ -7,7 +7,6 @@
#include "aot_emit_exception.h" #include "aot_emit_exception.h"
#include "../aot/aot_runtime.h" #include "../aot/aot_runtime.h"
#include "../interpreter/wasm_loader.h" #include "../interpreter/wasm_loader.h"
#include "bh_memory.h"
static char *block_name_prefix[] = { "block", "loop", "if" }; static char *block_name_prefix[] = { "block", "loop", "if" };
static char *block_name_suffix[] = { "begin", "else", "end" }; static char *block_name_suffix[] = { "begin", "else", "end" };
@ -208,7 +207,7 @@ aot_compile_op_block(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
} }
/* Allocate memory */ /* Allocate memory */
if (!(block = wasm_malloc(sizeof(AOTBlock)))) { if (!(block = wasm_runtime_malloc(sizeof(AOTBlock)))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return false; return false;
} }
@ -309,7 +308,7 @@ aot_compile_op_block(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
goto fail; goto fail;
} }
/* skip the block */ /* skip the block */
wasm_free(block); wasm_runtime_free(block);
*p_frame_ip = end_addr + 1; *p_frame_ip = end_addr + 1;
} }
} }
@ -322,7 +321,7 @@ aot_compile_op_block(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
return true; return true;
fail: fail:
wasm_free(block); wasm_runtime_free(block);
return false; return false;
} }

16
core/iwasm/compilation/aot_emit_function.c
View File

@ -247,7 +247,7 @@ aot_compile_op_call(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
param_count = (int32)func_type->param_count; param_count = (int32)func_type->param_count;
total_size = sizeof(LLVMValueRef) * (uint64)(param_count + 1); total_size = sizeof(LLVMValueRef) * (uint64)(param_count + 1);
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(param_values = wasm_malloc((uint32)total_size))) { || !(param_values = wasm_runtime_malloc((uint32)total_size))) {
aot_set_last_error("Allocate memory failed."); aot_set_last_error("Allocate memory failed.");
return false; return false;
} }
@ -268,7 +268,7 @@ aot_compile_op_call(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
/* Initialize parameter types of the LLVM function */ /* Initialize parameter types of the LLVM function */
total_size = sizeof(LLVMTypeRef) * (uint64)(param_count + 1); total_size = sizeof(LLVMTypeRef) * (uint64)(param_count + 1);
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(param_types = wasm_malloc((uint32)total_size))) { || !(param_types = wasm_runtime_malloc((uint32)total_size))) {
aot_set_last_error("Allocate memory failed."); aot_set_last_error("Allocate memory failed.");
goto fail; goto fail;
} }
@ -321,9 +321,9 @@ aot_compile_op_call(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
ret = true; ret = true;
fail: fail:
if (param_types) if (param_types)
wasm_free(param_types); wasm_runtime_free(param_types);
if (param_values) if (param_values)
wasm_free(param_values); wasm_runtime_free(param_values);
return ret; return ret;
} }
@ -548,7 +548,7 @@ aot_compile_op_call_indirect(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
param_count = (int32)func_type->param_count; param_count = (int32)func_type->param_count;
total_size = sizeof(LLVMTypeRef) * (uint64)(param_count + 1); total_size = sizeof(LLVMTypeRef) * (uint64)(param_count + 1);
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(param_types = wasm_malloc((uint32)total_size))) { || !(param_types = wasm_runtime_malloc((uint32)total_size))) {
aot_set_last_error("Allocate memory failed."); aot_set_last_error("Allocate memory failed.");
goto fail; goto fail;
} }
@ -571,7 +571,7 @@ aot_compile_op_call_indirect(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
/* Allocate memory for parameters */ /* Allocate memory for parameters */
total_size = sizeof(LLVMValueRef) * (uint64)(param_count + 1); total_size = sizeof(LLVMValueRef) * (uint64)(param_count + 1);
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(param_values = wasm_malloc((uint32)total_size))) { || !(param_values = wasm_runtime_malloc((uint32)total_size))) {
aot_set_last_error("Allocate memory failed."); aot_set_last_error("Allocate memory failed.");
goto fail; goto fail;
} }
@ -601,9 +601,9 @@ aot_compile_op_call_indirect(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
fail: fail:
if (param_values) if (param_values)
wasm_free(param_values); wasm_runtime_free(param_values);
if (param_types) if (param_types)
wasm_free(param_types); wasm_runtime_free(param_types);
return ret; return ret;
} }

8
core/iwasm/compilation/aot_emit_numberic.c
View File

@ -186,7 +186,7 @@ call_llvm_intrinsic(AOTCompContext *comp_ctx,
/* Create param values */ /* Create param values */
total_size = sizeof(LLVMValueRef) * (uint64)param_count; total_size = sizeof(LLVMValueRef) * (uint64)param_count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(param_values = wasm_malloc((uint32)total_size))) { || !(param_values = wasm_runtime_malloc((uint32)total_size))) {
aot_set_last_error("allocate memory for param values failed."); aot_set_last_error("allocate memory for param values failed.");
return false; return false;
} }
@ -201,7 +201,7 @@ call_llvm_intrinsic(AOTCompContext *comp_ctx,
param_types, param_count, param_types, param_count,
param_values); param_values);
wasm_free(param_values); wasm_runtime_free(param_values);
return ret; return ret;
} }
@ -221,7 +221,7 @@ call_llvm_intrinsic_v(AOTCompContext *comp_ctx,
/* Create param values */ /* Create param values */
total_size = sizeof(LLVMValueRef) * (uint64)param_count; total_size = sizeof(LLVMValueRef) * (uint64)param_count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(param_values = wasm_malloc((uint32)total_size))) { || !(param_values = wasm_runtime_malloc((uint32)total_size))) {
aot_set_last_error("allocate memory for param values failed."); aot_set_last_error("allocate memory for param values failed.");
return false; return false;
} }
@ -234,7 +234,7 @@ call_llvm_intrinsic_v(AOTCompContext *comp_ctx,
param_types, param_count, param_types, param_count,
param_values); param_values);
wasm_free(param_values); wasm_runtime_free(param_values);
return ret; return ret;
} }

2
core/iwasm/compilation/aot_emit_parametric.c
View File

@ -43,7 +43,7 @@ pop_value_from_wasm_stack(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
*p_value = aot_value->value; *p_value = aot_value->value;
} }
wasm_free(aot_value); wasm_runtime_free(aot_value);
if ((is_32 if ((is_32
&& (type != VALUE_TYPE_I32 && type != VALUE_TYPE_F32)) && (type != VALUE_TYPE_I32 && type != VALUE_TYPE_F32))

35
core/iwasm/compilation/aot_llvm.c
View File

@ -4,7 +4,6 @@
*/ */
#include "aot_llvm.h" #include "aot_llvm.h"
#include "bh_memory.h"
#include "aot_compiler.h" #include "aot_compiler.h"
#include "../aot/aot_runtime.h" #include "../aot/aot_runtime.h"
@ -47,7 +46,7 @@ aot_add_llvm_func(AOTCompContext *comp_ctx, AOTFuncType *aot_func_type,
/* Initialize parameter types of the LLVM function */ /* Initialize parameter types of the LLVM function */
size = sizeof(LLVMTypeRef) * ((uint64)param_count); size = sizeof(LLVMTypeRef) * ((uint64)param_count);
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(param_types = wasm_malloc((uint32)size))) { || !(param_types = wasm_runtime_malloc((uint32)size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return NULL; return NULL;
} }
@ -88,7 +87,7 @@ aot_add_llvm_func(AOTCompContext *comp_ctx, AOTFuncType *aot_func_type,
} }
fail: fail:
wasm_free(param_types); wasm_runtime_free(param_types);
return func; return func;
} }
@ -102,7 +101,7 @@ aot_create_func_block(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
AOTBlock *aot_block; AOTBlock *aot_block;
/* Allocate memory */ /* Allocate memory */
if (!(aot_block = wasm_malloc(sizeof(AOTBlock)))) { if (!(aot_block = wasm_runtime_malloc(sizeof(AOTBlock)))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return NULL; return NULL;
} }
@ -129,7 +128,7 @@ aot_create_func_block(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
return aot_block; return aot_block;
fail: fail:
wasm_free(aot_block); wasm_runtime_free(aot_block);
return NULL; return NULL;
} }
@ -137,7 +136,7 @@ static bool
create_exception_blocks(AOTFuncContext *func_ctx) create_exception_blocks(AOTFuncContext *func_ctx)
{ {
if (!(func_ctx->exception_blocks = if (!(func_ctx->exception_blocks =
wasm_malloc(sizeof(LLVMBasicBlockRef) * EXCE_NUM))) { wasm_runtime_malloc(sizeof(LLVMBasicBlockRef) * EXCE_NUM))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return false;; return false;;
} }
@ -451,7 +450,7 @@ aot_create_func_context(AOTCompData *comp_data, AOTCompContext *comp_ctx,
size = offsetof(AOTFuncContext, locals) + sizeof(LLVMValueRef) * size = offsetof(AOTFuncContext, locals) + sizeof(LLVMValueRef) *
((uint64)aot_func_type->param_count + func->local_count); ((uint64)aot_func_type->param_count + func->local_count);
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(func_ctx = wasm_malloc((uint32)size))) { || !(func_ctx = wasm_runtime_malloc((uint32)size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return NULL; return NULL;
} }
@ -605,9 +604,9 @@ aot_create_func_context(AOTCompData *comp_data, AOTCompContext *comp_ctx,
fail: fail:
if (func_ctx->exception_blocks) if (func_ctx->exception_blocks)
wasm_free(func_ctx->exception_blocks); wasm_runtime_free(func_ctx->exception_blocks);
aot_block_stack_destroy(&func_ctx->block_stack); aot_block_stack_destroy(&func_ctx->block_stack);
wasm_free(func_ctx); wasm_runtime_free(func_ctx);
return NULL; return NULL;
} }
@ -619,11 +618,11 @@ aot_destroy_func_contexts(AOTFuncContext **func_ctxes, uint32 count)
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
if (func_ctxes[i]) { if (func_ctxes[i]) {
if (func_ctxes[i]->exception_blocks) if (func_ctxes[i]->exception_blocks)
wasm_free(func_ctxes[i]->exception_blocks); wasm_runtime_free(func_ctxes[i]->exception_blocks);
aot_block_stack_destroy(&func_ctxes[i]->block_stack); aot_block_stack_destroy(&func_ctxes[i]->block_stack);
wasm_free(func_ctxes[i]); wasm_runtime_free(func_ctxes[i]);
} }
wasm_free(func_ctxes); wasm_runtime_free(func_ctxes);
} }
/** /**
@ -639,7 +638,7 @@ aot_create_func_contexts(AOTCompData *comp_data, AOTCompContext *comp_ctx)
/* Allocate memory */ /* Allocate memory */
size = sizeof(AOTFuncContext*) * (uint64)comp_data->func_count; size = sizeof(AOTFuncContext*) * (uint64)comp_data->func_count;
if (size >= UINT32_MAX if (size >= UINT32_MAX
|| !(func_ctxes = wasm_malloc((uint32)size))) { || !(func_ctxes = wasm_runtime_malloc((uint32)size))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return NULL; return NULL;
} }
@ -877,7 +876,7 @@ aot_create_comp_context(AOTCompData *comp_data,
LLVMLinkInMCJIT(); LLVMLinkInMCJIT();
/* Allocate memory */ /* Allocate memory */
if (!(comp_ctx = wasm_malloc(sizeof(AOTCompContext)))) { if (!(comp_ctx = wasm_runtime_malloc(sizeof(AOTCompContext)))) {
aot_set_last_error("allocate memory failed."); aot_set_last_error("allocate memory failed.");
return NULL; return NULL;
} }
@ -1176,7 +1175,7 @@ aot_destroy_comp_context(AOTCompContext *comp_ctx)
if (comp_ctx->func_ctxes) if (comp_ctx->func_ctxes)
aot_destroy_func_contexts(comp_ctx->func_ctxes, comp_ctx->func_ctx_count); aot_destroy_func_contexts(comp_ctx->func_ctxes, comp_ctx->func_ctx_count);
wasm_free(comp_ctx); wasm_runtime_free(comp_ctx);
} }
void void
@ -1216,7 +1215,7 @@ aot_value_stack_destroy(AOTValueStack *stack)
while (value) { while (value) {
p = value->next; p = value->next;
wasm_free(value); wasm_runtime_free(value);
value = p; value = p;
} }
} }
@ -1259,7 +1258,7 @@ aot_block_stack_destroy(AOTBlockStack *stack)
while (block) { while (block) {
p = block->next; p = block->next;
aot_value_stack_destroy(&block->value_stack); aot_value_stack_destroy(&block->value_stack);
wasm_free(block); wasm_runtime_free(block);
block = p; block = p;
} }
} }
@ -1268,5 +1267,5 @@ void
aot_block_destroy(AOTBlock *block) aot_block_destroy(AOTBlock *block)
{ {
aot_value_stack_destroy(&block->value_stack); aot_value_stack_destroy(&block->value_stack);
wasm_free(block); wasm_runtime_free(block);
} }

99
core/iwasm/include/bh_memory.h
View File

@ -1,99 +0,0 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#ifndef _BH_MEMORY_H
#define _BH_MEMORY_H
#ifdef __cplusplus
extern "C" {
#endif
#define BH_KB (1024)
#define BH_MB ((BH_KB)*1024)
#define BH_GB ((BH_MB)*1024)
/**
* Initialize memory allocator with a pool, the bh_malloc/bh_free function
* will malloc/free memory from the pool
*
* @param mem the pool buffer
* @param bytes the size bytes of the buffer
*
* @return 0 if success, -1 otherwise
*/
int bh_memory_init_with_pool(void *mem, unsigned int bytes);
/**
* Initialize memory allocator with memory allocator, the bh_malloc/bh_free
* function will malloc/free memory with the allocator passed
*
* @param malloc_func the malloc function
* @param free_func the free function
*
* @return 0 if success, -1 otherwise
*/
int bh_memory_init_with_allocator(void *malloc_func, void *free_func);
/**
* Destroy memory
*/
void bh_memory_destroy();
/**
* Get the pool size of memory, if memory is initialized with allocator,
* return 1GB by default.
*/
unsigned bh_memory_pool_size();
#if BEIHAI_ENABLE_MEMORY_PROFILING == 0
/**
* This function allocates a memory chunk from system
*
* @param size bytes need allocate
*
* @return the pointer to memory allocated
*/
void* bh_malloc(unsigned int size);
/**
* This function frees memory chunk
*
* @param ptr the pointer to memory need free
*/
void bh_free(void *ptr);
#else
void* bh_malloc_profile(const char *file, int line, const char *func, unsigned int size);
void bh_free_profile(const char *file, int line, const char *func, void *ptr);
#define bh_malloc(size) bh_malloc_profile(__FILE__, __LINE__, __func__, size)
#define bh_free(ptr) bh_free_profile(__FILE__, __LINE__, __func__, ptr)
/**
* Print current memory profiling data
*
* @param file file name of the caller
* @param line line of the file of the caller
* @param func function name of the caller
*/
void memory_profile_print(const char *file, int line, const char *func, int alloc);
/**
* Summarize memory usage and print it out
* Can use awk to analyze the output like below:
* awk -F: '{print $2,$4,$6,$8,$9}' OFS="\t" ./out.txt | sort -n -r -k 1
*/
void memory_usage_summarize();
#endif
#ifdef __cplusplus
}
#endif
#endif /* #ifndef _BH_MEMORY_H */

75
core/iwasm/include/wasm_export.h
View File

@ -9,7 +9,6 @@
#include <inttypes.h> #include <inttypes.h>
#include <stdbool.h> #include <stdbool.h>
#include "lib_export.h" #include "lib_export.h"
#include "bh_memory.h"
#ifdef __cplusplus #ifdef __cplusplus
@ -53,24 +52,33 @@ typedef enum {
/* Memory allocator type */ /* Memory allocator type */
typedef enum { typedef enum {
/* pool mode, allocate memory from user defined heap buffer */
Alloc_With_Pool = 0, Alloc_With_Pool = 0,
Alloc_With_Allocator /* user allocator mode, allocate memory from user defined
malloc function */
Alloc_With_Allocator,
/* system allocator mode, allocate memory from system allocator,
or, platform's os_malloc function */
Alloc_With_System_Allocator,
} mem_alloc_type_t; } mem_alloc_type_t;
/* Memory allocator option */
typedef union MemAllocOption {
struct {
void *heap_buf;
uint32_t heap_size;
} pool;
struct {
void *malloc_func;
void *realloc_func;
void *free_func;
} allocator;
} MemAllocOption;
/* WASM runtime initialize arguments */ /* WASM runtime initialize arguments */
typedef struct RuntimeInitArgs { typedef struct RuntimeInitArgs {
mem_alloc_type_t mem_alloc_type; mem_alloc_type_t mem_alloc_type;
union { MemAllocOption mem_alloc_option;
struct {
void *heap_buf;
uint32_t heap_size;
} pool;
struct {
void *malloc_func;
void *realloc_func;
void *free_func;
} allocator;
} mem_alloc;
const char *native_module_name; const char *native_module_name;
NativeSymbol *native_symbols; NativeSymbol *native_symbols;
@ -78,19 +86,15 @@ typedef struct RuntimeInitArgs {
} RuntimeInitArgs; } RuntimeInitArgs;
/** /**
* Initialize the WASM runtime environment. * Initialize the WASM runtime environment, and also initialize
* the memory allocator with system allocator, which calls os_malloc
* to allocate memory
* *
* @return true if success, false otherwise * @return true if success, false otherwise
*/ */
bool bool
wasm_runtime_init(); wasm_runtime_init();
/**
* Destroy the WASM runtime environment.
*/
void
wasm_runtime_destroy();
/** /**
* Initialize the WASM runtime environment, and also initialize * Initialize the WASM runtime environment, and also initialize
* the memory allocator and register native symbols, which are specified * the memory allocator and register native symbols, which are specified
@ -104,11 +108,36 @@ bool
wasm_runtime_full_init(RuntimeInitArgs *init_args); wasm_runtime_full_init(RuntimeInitArgs *init_args);
/** /**
* Destroy the wasm runtime environment, and also destroy * Destroy the WASM runtime environment.
* the memory allocator and registered native symbols
*/ */
void void
wasm_runtime_full_destroy(); wasm_runtime_destroy();
/**
* Allocate memory from runtime memory environment.
*
* @param size bytes need to allocate
*
* @return the pointer to memory allocated
*/
void *
wasm_runtime_malloc(unsigned int size);
/**
* Reallocate memory from runtime memory environment
*
* @param ptr the original memory
* @param size bytes need to reallocate
*
* @return the pointer to memory reallocated
*/
void *
wasm_runtime_realloc(void *ptr, unsigned int size);
/*
* Free memory to runtime memory environment.
*/
void wasm_runtime_free(void *ptr);
/** /**
* Get the package type of a buffer. * Get the package type of a buffer.

5
core/iwasm/interpreter/wasm_interp.c
View File

@ -4,7 +4,6 @@
*/ */
#include "wasm_interp.h" #include "wasm_interp.h"
#include "bh_memory.h"
#include "bh_log.h" #include "bh_log.h"
#include "wasm_runtime.h" #include "wasm_runtime.h"
#include "wasm_opcode.h" #include "wasm_opcode.h"
@ -948,7 +947,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
else { else {
uint64 total_size = sizeof(uint32) * (uint64)count; uint64 total_size = sizeof(uint32) * (uint64)count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(depths = wasm_malloc((uint32)total_size))) { || !(depths = wasm_runtime_malloc((uint32)total_size))) {
wasm_set_exception(module, wasm_set_exception(module,
"WASM interp failed: allocate memory failed."); "WASM interp failed: allocate memory failed.");
goto got_exception; goto got_exception;
@ -963,7 +962,7 @@ wasm_interp_call_func_bytecode(WASMModuleInstance *module,
depth = depths[didx]; depth = depths[didx];
} }
if (depths != depth_buf) { if (depths != depth_buf) {
wasm_free(depths); wasm_runtime_free(depths);
depths = NULL; depths = NULL;
} }
POP_CSP_N(depth); POP_CSP_N(depth);

1
core/iwasm/interpreter/wasm_interp_fast.c
View File

@ -4,7 +4,6 @@
*/ */
#include "wasm_interp.h" #include "wasm_interp.h"
#include "bh_memory.h"
#include "bh_log.h" #include "bh_log.h"
#include "wasm_runtime.h" #include "wasm_runtime.h"
#include "wasm_opcode.h" #include "wasm_opcode.h"

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

@ -5,7 +5,6 @@
#include "wasm_loader.h" #include "wasm_loader.h"
#include "bh_common.h" #include "bh_common.h"
#include "bh_memory.h"
#include "bh_log.h" #include "bh_log.h"
#include "wasm.h" #include "wasm.h"
#include "wasm_opcode.h" #include "wasm_opcode.h"
@ -295,7 +294,7 @@ const_str_list_insert(const uint8 *str, uint32 len, WASMModule *module,
if (node) if (node)
return node->str; return node->str;
if (!(node = wasm_malloc(sizeof(StringNode) + len + 1))) { if (!(node = wasm_runtime_malloc(sizeof(StringNode) + len + 1))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"WASM module load failed: " "WASM module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -394,7 +393,7 @@ load_type_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
module->type_count = type_count; module->type_count = type_count;
total_size = sizeof(WASMType*) * (uint64)type_count; total_size = sizeof(WASMType*) * (uint64)type_count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(module->types = wasm_malloc((uint32)total_size))) { || !(module->types = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Load type section failed: allocate memory failed."); "Load type section failed: allocate memory failed.");
return false; return false;
@ -429,7 +428,8 @@ load_type_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
total_size = offsetof(WASMType, types) + total_size = offsetof(WASMType, types) +
sizeof(uint8) * (uint64)(param_count + result_count); sizeof(uint8) * (uint64)(param_count + result_count);
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(type = module->types[i] = wasm_malloc((uint32)total_size))) { || !(type = module->types[i] =
wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Load type section failed: allocate memory failed."); "Load type section failed: allocate memory failed.");
return false; return false;
@ -482,13 +482,16 @@ load_table_import(const uint8 **p_buf, const uint8 *buf_end,
return true; return true;
} }
unsigned
wasm_runtime_memory_pool_size();
static bool static bool
load_memory_import(const uint8 **p_buf, const uint8 *buf_end, load_memory_import(const uint8 **p_buf, const uint8 *buf_end,
WASMMemoryImport *memory, WASMMemoryImport *memory,
char *error_buf, uint32 error_buf_size) char *error_buf, uint32 error_buf_size)
{ {
const uint8 *p = *p_buf, *p_end = buf_end; const uint8 *p = *p_buf, *p_end = buf_end;
uint32 pool_size = bh_memory_pool_size(); uint32 pool_size = wasm_runtime_memory_pool_size();
uint32 max_page_count = pool_size * APP_MEMORY_MAX_GLOBAL_HEAP_PERCENT uint32 max_page_count = pool_size * APP_MEMORY_MAX_GLOBAL_HEAP_PERCENT
/ DEFAULT_NUM_BYTES_PER_PAGE; / DEFAULT_NUM_BYTES_PER_PAGE;
@ -535,7 +538,7 @@ load_memory(const uint8 **p_buf, const uint8 *buf_end, WASMMemory *memory,
char *error_buf, uint32 error_buf_size) char *error_buf, uint32 error_buf_size)
{ {
const uint8 *p = *p_buf, *p_end = buf_end; const uint8 *p = *p_buf, *p_end = buf_end;
uint32 pool_size = bh_memory_pool_size(); uint32 pool_size = wasm_runtime_memory_pool_size();
uint32 max_page_count = pool_size * APP_MEMORY_MAX_GLOBAL_HEAP_PERCENT uint32 max_page_count = pool_size * APP_MEMORY_MAX_GLOBAL_HEAP_PERCENT
/ DEFAULT_NUM_BYTES_PER_PAGE; / DEFAULT_NUM_BYTES_PER_PAGE;
@ -575,7 +578,7 @@ load_import_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
module->import_count = import_count; module->import_count = import_count;
total_size = sizeof(WASMImport) * (uint64)import_count; total_size = sizeof(WASMImport) * (uint64)import_count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(module->imports = wasm_malloc((uint32)total_size))) { || !(module->imports = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Load import section failed: allocate memory failed."); "Load import section failed: allocate memory failed.");
return false; return false;
@ -817,7 +820,7 @@ init_function_local_offsets(WASMFunction *func,
uint64 total_size = sizeof(uint16) * ((uint64)param_count + local_count); uint64 total_size = sizeof(uint16) * ((uint64)param_count + local_count);
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(func->local_offsets = wasm_malloc((uint32)total_size))) { || !(func->local_offsets = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Load function section failed: allocate memory failed."); "Load function section failed: allocate memory failed.");
return false; return false;
@ -868,7 +871,7 @@ load_function_section(const uint8 *buf, const uint8 *buf_end,
module->function_count = func_count; module->function_count = func_count;
total_size = sizeof(WASMFunction*) * (uint64)func_count; total_size = sizeof(WASMFunction*) * (uint64)func_count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(module->functions = wasm_malloc((uint32)total_size))) { || !(module->functions = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Load function section failed: allocate memory failed."); "Load function section failed: allocate memory failed.");
return false; return false;
@ -921,7 +924,8 @@ load_function_section(const uint8 *buf, const uint8 *buf_end,
total_size = sizeof(WASMFunction) + (uint64)local_count; total_size = sizeof(WASMFunction) + (uint64)local_count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(func = module->functions[i] = wasm_malloc((uint32)total_size))) { || !(func = module->functions[i] =
wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Load function section failed: " "Load function section failed: "
"allocate memory failed."); "allocate memory failed.");
@ -1006,7 +1010,7 @@ load_table_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
module->table_count = table_count; module->table_count = table_count;
total_size = sizeof(WASMTable) * (uint64)table_count; total_size = sizeof(WASMTable) * (uint64)table_count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(module->tables = wasm_malloc((uint32)total_size))) { || !(module->tables = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Load table section failed: allocate memory failed."); "Load table section failed: allocate memory failed.");
return false; return false;
@ -1052,7 +1056,7 @@ load_memory_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
module->memory_count = memory_count; module->memory_count = memory_count;
total_size = sizeof(WASMMemory) * (uint64)memory_count; total_size = sizeof(WASMMemory) * (uint64)memory_count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(module->memories = wasm_malloc((uint32)total_size))) { || !(module->memories = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Load memory section failed: allocate memory failed."); "Load memory section failed: allocate memory failed.");
return false; return false;
@ -1093,7 +1097,7 @@ load_global_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
module->global_count = global_count; module->global_count = global_count;
total_size = sizeof(WASMGlobal) * (uint64)global_count; total_size = sizeof(WASMGlobal) * (uint64)global_count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(module->globals = wasm_malloc((uint32)total_size))) { || !(module->globals = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Load global section failed: " "Load global section failed: "
"allocate memory failed."); "allocate memory failed.");
@ -1148,7 +1152,7 @@ load_export_section(const uint8 *buf, const uint8 *buf_end, WASMModule *module,
module->export_count = export_count; module->export_count = export_count;
total_size = sizeof(WASMExport) * (uint64)export_count; total_size = sizeof(WASMExport) * (uint64)export_count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(module->exports = wasm_malloc((uint32)total_size))) { || !(module->exports = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Load export section failed: " "Load export section failed: "
"allocate memory failed."); "allocate memory failed.");
@ -1242,7 +1246,7 @@ load_table_segment_section(const uint8 *buf, const uint8 *buf_end, WASMModule *m
module->table_seg_count = table_segment_count; module->table_seg_count = table_segment_count;
total_size = sizeof(WASMTableSeg) * (uint64)table_segment_count; total_size = sizeof(WASMTableSeg) * (uint64)table_segment_count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(module->table_segments = wasm_malloc((uint32)total_size))) { || !(module->table_segments = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Load table segment section failed: " "Load table segment section failed: "
"allocate memory failed."); "allocate memory failed.");
@ -1272,7 +1276,7 @@ load_table_segment_section(const uint8 *buf, const uint8 *buf_end, WASMModule *m
total_size = sizeof(uint32) * (uint64)function_count; total_size = sizeof(uint32) * (uint64)function_count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(table_segment->func_indexes = (uint32 *) || !(table_segment->func_indexes = (uint32 *)
wasm_malloc((uint32)total_size))) { wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Load table segment section failed: " "Load table segment section failed: "
"allocate memory failed."); "allocate memory failed.");
@ -1312,7 +1316,7 @@ load_data_segment_section(const uint8 *buf, const uint8 *buf_end,
module->data_seg_count = data_seg_count; module->data_seg_count = data_seg_count;
total_size = sizeof(WASMDataSeg*) * (uint64)data_seg_count; total_size = sizeof(WASMDataSeg*) * (uint64)data_seg_count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(module->data_segments = wasm_malloc((uint32)total_size))) { || !(module->data_segments = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Load data segment section failed: " "Load data segment section failed: "
"allocate memory failed."); "allocate memory failed.");
@ -1330,7 +1334,7 @@ load_data_segment_section(const uint8 *buf, const uint8 *buf_end,
read_leb_uint32(p, p_end, data_seg_len); read_leb_uint32(p, p_end, data_seg_len);
if (!(dataseg = module->data_segments[i] = if (!(dataseg = module->data_segments[i] =
wasm_malloc((uint32)sizeof(WASMDataSeg)))) { wasm_runtime_malloc((uint32)sizeof(WASMDataSeg)))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Load data segment section failed: " "Load data segment section failed: "
"allocate memory failed."); "allocate memory failed.");
@ -1564,7 +1568,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
total_size = sizeof(BlockAddr) * (uint64)BLOCK_ADDR_CACHE_SIZE * BLOCK_ADDR_CONFLICT_SIZE; total_size = sizeof(BlockAddr) * (uint64)BLOCK_ADDR_CACHE_SIZE * BLOCK_ADDR_CONFLICT_SIZE;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(block_addr_cache = wasm_malloc((uint32)total_size))) { || !(block_addr_cache = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"WASM module load failed: allocate memory failed"); "WASM module load failed: allocate memory failed");
return false; return false;
@ -1576,7 +1580,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
if (!wasm_loader_prepare_bytecode(module, func, block_addr_cache, error_buf, error_buf_size)) if (!wasm_loader_prepare_bytecode(module, func, block_addr_cache, error_buf, error_buf_size))
return false; return false;
} }
wasm_free(block_addr_cache); wasm_runtime_free(block_addr_cache);
/* Resolve llvm auxiliary data/stack/heap info and reset memory info */ /* Resolve llvm auxiliary data/stack/heap info and reset memory info */
if (!module->possible_memory_grow) { if (!module->possible_memory_grow) {
@ -1693,7 +1697,7 @@ load_from_sections(WASMModule *module, WASMSection *sections,
#if BEIHAI_ENABLE_MEMORY_PROFILING != 0 #if BEIHAI_ENABLE_MEMORY_PROFILING != 0
static void wasm_loader_free(void *ptr) static void wasm_loader_free(void *ptr)
{ {
wasm_free(ptr); wasm_runtime_free(ptr);
} }
#else #else
#define wasm_loader_free wasm_free #define wasm_loader_free wasm_free
@ -1702,7 +1706,7 @@ static void wasm_loader_free(void *ptr)
static WASMModule* static WASMModule*
create_module(char *error_buf, uint32 error_buf_size) create_module(char *error_buf, uint32 error_buf_size)
{ {
WASMModule *module = wasm_malloc(sizeof(WASMModule)); WASMModule *module = wasm_runtime_malloc(sizeof(WASMModule));
if (!module) { if (!module) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
@ -1744,7 +1748,7 @@ destroy_sections(WASMSection *section_list)
WASMSection *section = section_list, *next; WASMSection *section = section_list, *next;
while (section) { while (section) {
next = section->next; next = section->next;
wasm_free(section); wasm_runtime_free(section);
section = next; section = next;
} }
} }
@ -1783,7 +1787,7 @@ create_sections(const uint8 *buf, uint32 size,
read_leb_uint32(p, p_end, section_size); read_leb_uint32(p, p_end, section_size);
CHECK_BUF1(p, p_end, section_size); CHECK_BUF1(p, p_end, section_size);
if (!(section = wasm_malloc(sizeof(WASMSection)))) { if (!(section = wasm_runtime_malloc(sizeof(WASMSection)))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"WASM module load failed: " "WASM module load failed: "
"allocate memory failed."); "allocate memory failed.");
@ -1877,7 +1881,7 @@ load(const uint8 *buf, uint32 size, WASMModule *module,
WASMModule* WASMModule*
wasm_loader_load(const uint8 *buf, uint32 size, char *error_buf, uint32 error_buf_size) wasm_loader_load(const uint8 *buf, uint32 size, char *error_buf, uint32 error_buf_size)
{ {
WASMModule *module = wasm_malloc(sizeof(WASMModule)); WASMModule *module = wasm_runtime_malloc(sizeof(WASMModule));
if (!module) { if (!module) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
@ -1914,69 +1918,69 @@ wasm_loader_unload(WASMModule *module)
if (module->types) { if (module->types) {
for (i = 0; i < module->type_count; i++) { for (i = 0; i < module->type_count; i++) {
if (module->types[i]) if (module->types[i])
wasm_free(module->types[i]); wasm_runtime_free(module->types[i]);
} }
wasm_free(module->types); wasm_runtime_free(module->types);
} }
if (module->imports) if (module->imports)
wasm_free(module->imports); wasm_runtime_free(module->imports);
if (module->functions) { if (module->functions) {
for (i = 0; i < module->function_count; i++) { for (i = 0; i < module->function_count; i++) {
if (module->functions[i]) { if (module->functions[i]) {
if (module->functions[i]->local_offsets) if (module->functions[i]->local_offsets)
wasm_free(module->functions[i]->local_offsets); wasm_runtime_free(module->functions[i]->local_offsets);
#if WASM_ENABLE_FAST_INTERP != 0 #if WASM_ENABLE_FAST_INTERP != 0
if (module->functions[i]->code_compiled) if (module->functions[i]->code_compiled)
wasm_free(module->functions[i]->code_compiled); wasm_runtime_free(module->functions[i]->code_compiled);
if (module->functions[i]->consts) if (module->functions[i]->consts)
wasm_free(module->functions[i]->consts); wasm_runtime_free(module->functions[i]->consts);
#endif #endif
wasm_free(module->functions[i]); wasm_runtime_free(module->functions[i]);
} }
} }
wasm_free(module->functions); wasm_runtime_free(module->functions);
} }
if (module->tables) if (module->tables)
wasm_free(module->tables); wasm_runtime_free(module->tables);
if (module->memories) if (module->memories)
wasm_free(module->memories); wasm_runtime_free(module->memories);
if (module->globals) if (module->globals)
wasm_free(module->globals); wasm_runtime_free(module->globals);
if (module->exports) if (module->exports)
wasm_free(module->exports); wasm_runtime_free(module->exports);
if (module->table_segments) { if (module->table_segments) {
for (i = 0; i < module->table_seg_count; i++) { for (i = 0; i < module->table_seg_count; i++) {
if (module->table_segments[i].func_indexes) if (module->table_segments[i].func_indexes)
wasm_free(module->table_segments[i].func_indexes); wasm_runtime_free(module->table_segments[i].func_indexes);
} }
wasm_free(module->table_segments); wasm_runtime_free(module->table_segments);
} }
if (module->data_segments) { if (module->data_segments) {
for (i = 0; i < module->data_seg_count; i++) { for (i = 0; i < module->data_seg_count; i++) {
if (module->data_segments[i]) if (module->data_segments[i])
wasm_free(module->data_segments[i]); wasm_runtime_free(module->data_segments[i]);
} }
wasm_free(module->data_segments); wasm_runtime_free(module->data_segments);
} }
if (module->const_str_list) { if (module->const_str_list) {
StringNode *node = module->const_str_list, *node_next; StringNode *node = module->const_str_list, *node_next;
while (node) { while (node) {
node_next = node->next; node_next = node->next;
wasm_free(node); wasm_runtime_free(node);
node = node_next; node = node_next;
} }
} }
wasm_free(module); wasm_runtime_free(module);
} }
bool bool
@ -2388,10 +2392,10 @@ memory_realloc(void *mem_old, uint32 size_old, uint32 size_new,
{ {
uint8 *mem_new; uint8 *mem_new;
bh_assert(size_new > size_old); bh_assert(size_new > size_old);
if ((mem_new = wasm_malloc(size_new))) { if ((mem_new = wasm_runtime_malloc(size_new))) {
bh_memcpy_s(mem_new, size_new, mem_old, size_old); bh_memcpy_s(mem_new, size_new, mem_old, size_old);
memset(mem_new + size_old, 0, size_new - size_old); memset(mem_new + size_old, 0, size_new - size_old);
wasm_free(mem_old); wasm_runtime_free(mem_old);
} }
else { else {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
@ -2454,7 +2458,7 @@ static void free_label_patch_list(BranchBlock *frame_csp)
BranchBlockPatch *next; BranchBlockPatch *next;
while (label_patch != NULL) { while (label_patch != NULL) {
next = label_patch->next; next = label_patch->next;
wasm_free(label_patch); wasm_runtime_free(label_patch);
label_patch = next; label_patch = next;
} }
frame_csp->patch_list = NULL; frame_csp->patch_list = NULL;
@ -2524,20 +2528,20 @@ static void wasm_loader_ctx_destroy(WASMLoaderContext *ctx)
{ {
if (ctx) { if (ctx) {
if (ctx->frame_ref_bottom) if (ctx->frame_ref_bottom)
wasm_free(ctx->frame_ref_bottom); wasm_runtime_free(ctx->frame_ref_bottom);
if (ctx->frame_csp_bottom) { if (ctx->frame_csp_bottom) {
#if WASM_ENABLE_FAST_INTERP != 0 #if WASM_ENABLE_FAST_INTERP != 0
free_all_label_patch_lists(ctx->frame_csp_bottom, ctx->csp_num); free_all_label_patch_lists(ctx->frame_csp_bottom, ctx->csp_num);
#endif #endif
wasm_free(ctx->frame_csp_bottom); wasm_runtime_free(ctx->frame_csp_bottom);
} }
#if WASM_ENABLE_FAST_INTERP != 0 #if WASM_ENABLE_FAST_INTERP != 0
if (ctx->frame_offset_bottom) if (ctx->frame_offset_bottom)
wasm_free(ctx->frame_offset_bottom); wasm_runtime_free(ctx->frame_offset_bottom);
if (ctx->const_buf) if (ctx->const_buf)
wasm_free(ctx->const_buf); wasm_runtime_free(ctx->const_buf);
#endif #endif
wasm_free(ctx); wasm_runtime_free(ctx);
} }
} }
@ -2545,14 +2549,14 @@ static WASMLoaderContext*
wasm_loader_ctx_init(WASMFunction *func) wasm_loader_ctx_init(WASMFunction *func)
{ {
WASMLoaderContext *loader_ctx = WASMLoaderContext *loader_ctx =
wasm_malloc(sizeof(WASMLoaderContext)); wasm_runtime_malloc(sizeof(WASMLoaderContext));
if (!loader_ctx) if (!loader_ctx)
return false; return false;
memset(loader_ctx, 0, sizeof(WASMLoaderContext)); memset(loader_ctx, 0, sizeof(WASMLoaderContext));
loader_ctx->frame_ref_size = 32; loader_ctx->frame_ref_size = 32;
if (!(loader_ctx->frame_ref_bottom = loader_ctx->frame_ref = if (!(loader_ctx->frame_ref_bottom = loader_ctx->frame_ref =
wasm_malloc(loader_ctx->frame_ref_size))) wasm_runtime_malloc(loader_ctx->frame_ref_size)))
goto fail; goto fail;
memset(loader_ctx->frame_ref_bottom, 0, loader_ctx->frame_ref_size); 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_boundary = loader_ctx->frame_ref_bottom +
@ -2560,7 +2564,7 @@ wasm_loader_ctx_init(WASMFunction *func)
loader_ctx->frame_csp_size = sizeof(BranchBlock) * 8; loader_ctx->frame_csp_size = sizeof(BranchBlock) * 8;
if (!(loader_ctx->frame_csp_bottom = loader_ctx->frame_csp = if (!(loader_ctx->frame_csp_bottom = loader_ctx->frame_csp =
wasm_malloc(loader_ctx->frame_csp_size))) wasm_runtime_malloc(loader_ctx->frame_csp_size)))
goto fail; goto fail;
memset(loader_ctx->frame_csp_bottom, 0, loader_ctx->frame_csp_size); memset(loader_ctx->frame_csp_bottom, 0, loader_ctx->frame_csp_size);
loader_ctx->frame_csp_boundary = loader_ctx->frame_csp_bottom + 8; loader_ctx->frame_csp_boundary = loader_ctx->frame_csp_bottom + 8;
@ -2568,7 +2572,7 @@ wasm_loader_ctx_init(WASMFunction *func)
#if WASM_ENABLE_FAST_INTERP != 0 #if WASM_ENABLE_FAST_INTERP != 0
loader_ctx->frame_offset_size = sizeof(int16) * 32; loader_ctx->frame_offset_size = sizeof(int16) * 32;
if (!(loader_ctx->frame_offset_bottom = loader_ctx->frame_offset = if (!(loader_ctx->frame_offset_bottom = loader_ctx->frame_offset =
wasm_malloc(loader_ctx->frame_offset_size))) wasm_runtime_malloc(loader_ctx->frame_offset_size)))
goto fail; goto fail;
memset(loader_ctx->frame_offset_bottom, 0, memset(loader_ctx->frame_offset_bottom, 0,
loader_ctx->frame_offset_size); loader_ctx->frame_offset_size);
@ -2576,7 +2580,7 @@ wasm_loader_ctx_init(WASMFunction *func)
loader_ctx->num_const = 0; loader_ctx->num_const = 0;
loader_ctx->const_buf_size = sizeof(Const) * 8; loader_ctx->const_buf_size = sizeof(Const) * 8;
if (!(loader_ctx->const_buf = wasm_malloc(loader_ctx->const_buf_size))) if (!(loader_ctx->const_buf = wasm_runtime_malloc(loader_ctx->const_buf_size)))
goto fail; goto fail;
memset(loader_ctx->const_buf, 0, loader_ctx->const_buf_size); memset(loader_ctx->const_buf, 0, loader_ctx->const_buf_size);
@ -2715,7 +2719,7 @@ wasm_loader_check_br(WASMLoaderContext *ctx, uint32 depth,
static bool static bool
wasm_loader_ctx_reinit(WASMLoaderContext *ctx) wasm_loader_ctx_reinit(WASMLoaderContext *ctx)
{ {
if (!(ctx->p_code_compiled = wasm_malloc(ctx->code_compiled_size))) if (!(ctx->p_code_compiled = wasm_runtime_malloc(ctx->code_compiled_size)))
return false; return false;
memset(ctx->p_code_compiled, 0, ctx->code_compiled_size); memset(ctx->p_code_compiled, 0, ctx->code_compiled_size);
ctx->p_code_compiled_end = ctx->p_code_compiled + ctx->p_code_compiled_end = ctx->p_code_compiled +
@ -2804,7 +2808,7 @@ add_label_patch_to_list(BranchBlock *frame_csp,
uint8 patch_type, uint8 *p_code_compiled, uint8 patch_type, uint8 *p_code_compiled,
char *error_buf, uint32 error_buf_size) char *error_buf, uint32 error_buf_size)
{ {
BranchBlockPatch *patch = wasm_malloc(sizeof(BranchBlockPatch)); BranchBlockPatch *patch = wasm_runtime_malloc(sizeof(BranchBlockPatch));
if (!patch) { if (!patch) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"WASM loader prepare bytecode failed: " "WASM loader prepare bytecode failed: "
@ -2845,7 +2849,7 @@ apply_label_patch(WASMLoaderContext *ctx, uint8 depth,
else { else {
node_prev->next = node_next; node_prev->next = node_next;
} }
wasm_free(node); wasm_runtime_free(node);
} }
else { else {
node_prev = node; node_prev = node;
@ -4589,7 +4593,8 @@ handle_next_reachable_block:
goto re_scan; goto re_scan;
func->const_cell_num = loader_ctx->const_cell_num; func->const_cell_num = loader_ctx->const_cell_num;
if (!(func->consts = func_const = wasm_malloc(func->const_cell_num * 4))) { if (!(func->consts = func_const =
wasm_runtime_malloc(func->const_cell_num * 4))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"WASM loader prepare bytecode failed: " "WASM loader prepare bytecode failed: "
"allocate memory failed"); "allocate memory failed");

50
core/iwasm/interpreter/wasm_runtime.c
View File

@ -51,10 +51,10 @@ memories_deinstantiate(WASMMemoryInstance **memories, uint32 count)
if (memories[i]) { if (memories[i]) {
if (memories[i]->heap_handle) if (memories[i]->heap_handle)
mem_allocator_destroy(memories[i]->heap_handle); mem_allocator_destroy(memories[i]->heap_handle);
wasm_free(memories[i]->heap_data); wasm_runtime_free(memories[i]->heap_data);
wasm_free(memories[i]); wasm_runtime_free(memories[i]);
} }
wasm_free(memories); wasm_runtime_free(memories);
} }
} }
@ -72,7 +72,7 @@ memory_instantiate(uint32 num_bytes_per_page,
/* Allocate memory space, addr data and global data */ /* Allocate memory space, addr data and global data */
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(memory = wasm_malloc((uint32)total_size))) { || !(memory = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Instantiate memory failed: allocate memory failed."); "Instantiate memory failed: allocate memory failed.");
return NULL; return NULL;
@ -92,7 +92,7 @@ memory_instantiate(uint32 num_bytes_per_page,
memory->end_addr = memory->global_data + global_data_size; memory->end_addr = memory->global_data + global_data_size;
/* Allocate heap space */ /* Allocate heap space */
if (!(memory->heap_data = wasm_malloc(heap_size))) { if (!(memory->heap_data = wasm_runtime_malloc(heap_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Instantiate memory failed: allocate memory failed."); "Instantiate memory failed: allocate memory failed.");
goto fail1; goto fail1;
@ -114,10 +114,10 @@ memory_instantiate(uint32 num_bytes_per_page,
return memory; return memory;
fail2: fail2:
wasm_free(memory->heap_data); wasm_runtime_free(memory->heap_data);
fail1: fail1:
wasm_free(memory); wasm_runtime_free(memory);
return NULL; return NULL;
} }
@ -141,7 +141,7 @@ memories_instantiate(const WASMModule *module,
total_size = sizeof(WASMMemoryInstance*) * (uint64)memory_count; total_size = sizeof(WASMMemoryInstance*) * (uint64)memory_count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(memories = wasm_malloc((uint32)total_size))) { || !(memories = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Instantiate memory failed: " "Instantiate memory failed: "
"allocate memory failed."); "allocate memory failed.");
@ -210,8 +210,8 @@ tables_deinstantiate(WASMTableInstance **tables, uint32 count)
if (tables) { if (tables) {
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
if (tables[i]) if (tables[i])
wasm_free(tables[i]); wasm_runtime_free(tables[i]);
wasm_free(tables); wasm_runtime_free(tables);
} }
} }
@ -229,7 +229,7 @@ tables_instantiate(const WASMModule *module,
WASMTableInstance **tables, *table; WASMTableInstance **tables, *table;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(tables = wasm_malloc((uint32)total_size))) { || !(tables = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Instantiate table failed: " "Instantiate table failed: "
"allocate memory failed."); "allocate memory failed.");
@ -244,7 +244,8 @@ tables_instantiate(const WASMModule *module,
total_size = offsetof(WASMTableInstance, base_addr) + total_size = offsetof(WASMTableInstance, base_addr) +
sizeof(uint32) * (uint64)import->u.table.init_size; sizeof(uint32) * (uint64)import->u.table.init_size;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(table = tables[table_index++] = wasm_malloc((uint32)total_size))) { || !(table = tables[table_index++] =
wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Instantiate table failed: " "Instantiate table failed: "
"allocate memory failed."); "allocate memory failed.");
@ -264,7 +265,8 @@ tables_instantiate(const WASMModule *module,
total_size = offsetof(WASMTableInstance, base_addr) + total_size = offsetof(WASMTableInstance, base_addr) +
sizeof(uint32) * (uint64)module->tables[i].init_size; sizeof(uint32) * (uint64)module->tables[i].init_size;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(table = tables[table_index++] = wasm_malloc((uint32)total_size))) { || !(table = tables[table_index++] =
wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Instantiate table failed: " "Instantiate table failed: "
"allocate memory failed."); "allocate memory failed.");
@ -290,7 +292,7 @@ static void
functions_deinstantiate(WASMFunctionInstance *functions, uint32 count) functions_deinstantiate(WASMFunctionInstance *functions, uint32 count)
{ {
if (functions) { if (functions) {
wasm_free(functions); wasm_runtime_free(functions);
} }
} }
@ -308,7 +310,7 @@ functions_instantiate(const WASMModule *module,
WASMFunctionInstance *functions, *function; WASMFunctionInstance *functions, *function;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(functions = wasm_malloc((uint32)total_size))) { || !(functions = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Instantiate function failed: " "Instantiate function failed: "
"allocate memory failed."); "allocate memory failed.");
@ -373,7 +375,7 @@ static void
globals_deinstantiate(WASMGlobalInstance *globals) globals_deinstantiate(WASMGlobalInstance *globals)
{ {
if (globals) if (globals)
wasm_free(globals); wasm_runtime_free(globals);
} }
/** /**
@ -392,7 +394,7 @@ globals_instantiate(const WASMModule *module,
WASMGlobalInstance *globals, *global; WASMGlobalInstance *globals, *global;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(globals = wasm_malloc((uint32)total_size))) { || !(globals = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Instantiate global failed: " "Instantiate global failed: "
"allocate memory failed."); "allocate memory failed.");
@ -505,7 +507,7 @@ static void
export_functions_deinstantiate(WASMExportFuncInstance *functions) export_functions_deinstantiate(WASMExportFuncInstance *functions)
{ {
if (functions) if (functions)
wasm_free(functions); wasm_runtime_free(functions);
} }
/** /**
@ -523,7 +525,7 @@ export_functions_instantiate(const WASMModule *module,
uint64 total_size = sizeof(WASMExportFuncInstance) * (uint64)export_func_count; uint64 total_size = sizeof(WASMExportFuncInstance) * (uint64)export_func_count;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(export_func = export_funcs = wasm_malloc((uint32)total_size))) { || !(export_func = export_funcs = wasm_runtime_malloc((uint32)total_size))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Instantiate export function failed: " "Instantiate export function failed: "
"allocate memory failed."); "allocate memory failed.");
@ -623,7 +625,7 @@ wasm_instantiate(WASMModule *module,
return NULL; return NULL;
/* Allocate the memory */ /* Allocate the memory */
if (!(module_inst = wasm_malloc((uint32)sizeof(WASMModuleInstance)))) { if (!(module_inst = wasm_runtime_malloc((uint32)sizeof(WASMModuleInstance)))) {
set_error_buf(error_buf, error_buf_size, set_error_buf(error_buf, error_buf_size,
"Instantiate module failed: allocate memory failed."); "Instantiate module failed: allocate memory failed.");
globals_deinstantiate(globals); globals_deinstantiate(globals);
@ -850,7 +852,7 @@ wasm_deinstantiate(WASMModuleInstance *module_inst)
globals_deinstantiate(module_inst->globals); globals_deinstantiate(module_inst->globals);
export_functions_deinstantiate(module_inst->export_functions); export_functions_deinstantiate(module_inst->export_functions);
wasm_free(module_inst); wasm_runtime_free(module_inst);
} }
WASMFunctionInstance* WASMFunctionInstance*
@ -1128,8 +1130,8 @@ wasm_enlarge_memory(WASMModuleInstance *module, uint32 inc_page_count)
return false; return false;
} }
if (!(new_memory = wasm_realloc(memory, (uint32)total_size))) { if (!(new_memory = wasm_runtime_realloc(memory, (uint32)total_size))) {
if (!(new_memory = wasm_malloc((uint32)total_size))) { if (!(new_memory = wasm_runtime_malloc((uint32)total_size))) {
wasm_set_exception(module, "fail to enlarge memory."); wasm_set_exception(module, "fail to enlarge memory.");
return false; return false;
} }
@ -1138,7 +1140,7 @@ wasm_enlarge_memory(WASMModuleInstance *module, uint32 inc_page_count)
(uint8*)memory, total_size_old); (uint8*)memory, total_size_old);
memset((uint8*)new_memory + total_size_old, memset((uint8*)new_memory + total_size_old,
0, (uint32)total_size - total_size_old); 0, (uint32)total_size - total_size_old);
wasm_free(memory); wasm_runtime_free(memory);
} }
new_memory->cur_page_count = total_page_count; new_memory->cur_page_count = total_page_count;

12
core/iwasm/libraries/libc-wasi/libc_wasi_wrapper.c
View File

@ -78,12 +78,12 @@ wasi_args_get(wasm_exec_env_t exec_env, int32 *argv_offsets, char *argv_buf)
total_size = sizeof(char*) * ((uint64)argc + 1); total_size = sizeof(char*) * ((uint64)argc + 1);
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(argv = bh_malloc((uint32)total_size))) || !(argv = wasm_runtime_malloc((uint32)total_size)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = wasmtime_ssp_args_get(wasi_ctx->argv_environ, argv, argv_buf); err = wasmtime_ssp_args_get(wasi_ctx->argv_environ, argv, argv_buf);
if (err) { if (err) {
bh_free(argv); wasm_runtime_free(argv);
return err; return err;
} }
@ -91,7 +91,7 @@ wasi_args_get(wasm_exec_env_t exec_env, int32 *argv_offsets, char *argv_buf)
argv_offsets[i] = addr_native_to_app(argv[i]); argv_offsets[i] = addr_native_to_app(argv[i]);
argv_offsets[argc] = 0; argv_offsets[argc] = 0;
bh_free(argv); wasm_runtime_free(argv);
return 0; return 0;
} }
@ -171,12 +171,12 @@ wasi_environ_get(wasm_exec_env_t exec_env,
total_size = sizeof(char*) * (((uint64)environ_count + 1)); total_size = sizeof(char*) * (((uint64)environ_count + 1));
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(environs = bh_malloc((uint32)total_size))) || !(environs = wasm_runtime_malloc((uint32)total_size)))
return (wasi_errno_t)-1; return (wasi_errno_t)-1;
err = wasmtime_ssp_environ_get(wasi_ctx->argv_environ, environs, environ_buf); err = wasmtime_ssp_environ_get(wasi_ctx->argv_environ, environs, environ_buf);
if (err) { if (err) {
bh_free(environs); wasm_runtime_free(environs);
return err; return err;
} }
@ -184,7 +184,7 @@ wasi_environ_get(wasm_exec_env_t exec_env,
environ_offsets[i] = addr_native_to_app(environs[i]); environ_offsets[i] = addr_native_to_app(environs[i]);
environ_offsets[environ_count] = 0; environ_offsets[environ_count] = 0;
bh_free(environs); wasm_runtime_free(environs);
return 0; return 0;
} }

95
core/iwasm/libraries/libc-wasi/sandboxed-system-primitives/src/posix.c
View File

@ -47,7 +47,6 @@
#include "str.h" #include "str.h"
#include "bh_common.h" #include "bh_common.h"
#include "bh_memory.h"
#if 0 /* TODO: -std=gnu99 causes compile error, comment them first */ #if 0 /* TODO: -std=gnu99 causes compile error, comment them first */
// struct iovec must have the same layout as __wasi_iovec_t. // struct iovec must have the same layout as __wasi_iovec_t.
@ -278,7 +277,7 @@ static bool fd_prestats_grow(
size *= 2; size *= 2;
// Grow the file descriptor table's allocation. // Grow the file descriptor table's allocation.
struct fd_prestat *prestats = bh_malloc((uint32)(sizeof(*prestats) * size)); struct fd_prestat *prestats = wasm_runtime_malloc((uint32)(sizeof(*prestats) * size));
if (prestats == NULL) if (prestats == NULL)
return false; return false;
@ -288,7 +287,7 @@ static bool fd_prestats_grow(
} }
if (pt->prestats) if (pt->prestats)
bh_free(pt->prestats); wasm_runtime_free(pt->prestats);
// Mark all new file descriptors as unused. // Mark all new file descriptors as unused.
for (size_t i = pt->size; i < size; ++i) for (size_t i = pt->size; i < size; ++i)
@ -408,7 +407,7 @@ static bool fd_table_grow(
size *= 2; size *= 2;
// Grow the file descriptor table's allocation. // Grow the file descriptor table's allocation.
struct fd_entry *entries = bh_malloc((uint32)(sizeof(*entries) * size)); struct fd_entry *entries = wasm_runtime_malloc((uint32)(sizeof(*entries) * size));
if (entries == NULL) if (entries == NULL)
return false; return false;
@ -418,7 +417,7 @@ static bool fd_table_grow(
} }
if (ft->entries) if (ft->entries)
bh_free(ft->entries); wasm_runtime_free(ft->entries);
// Mark all new file descriptors as unused. // Mark all new file descriptors as unused.
for (size_t i = ft->size; i < size; ++i) for (size_t i = ft->size; i < size; ++i)
@ -434,7 +433,7 @@ static __wasi_errno_t fd_object_new(
__wasi_filetype_t type, __wasi_filetype_t type,
struct fd_object **fo struct fd_object **fo
) TRYLOCKS_SHARED(0, (*fo)->refcount) { ) TRYLOCKS_SHARED(0, (*fo)->refcount) {
*fo = bh_malloc(sizeof(**fo)); *fo = wasm_runtime_malloc(sizeof(**fo));
if (*fo == NULL) if (*fo == NULL)
return __WASI_ENOMEM; return __WASI_ENOMEM;
refcount_init(&(*fo)->refcount, 1); refcount_init(&(*fo)->refcount, 1);
@ -585,7 +584,7 @@ static void fd_object_release(
CLOSE_NON_STD_FD(fd_number(fo)); CLOSE_NON_STD_FD(fd_number(fo));
break; break;
} }
bh_free(fo); wasm_runtime_free(fo);
} }
} }
@ -878,7 +877,7 @@ __wasi_errno_t wasmtime_ssp_fd_pread(
size_t totalsize = 0; size_t totalsize = 0;
for (size_t i = 0; i < iovcnt; ++i) for (size_t i = 0; i < iovcnt; ++i)
totalsize += iov[i].buf_len; totalsize += iov[i].buf_len;
char *buf = bh_malloc(totalsize); char *buf = wasm_runtime_malloc(totalsize);
if (buf == NULL) { if (buf == NULL) {
fd_object_release(fo); fd_object_release(fo);
return __WASI_ENOMEM; return __WASI_ENOMEM;
@ -888,7 +887,7 @@ __wasi_errno_t wasmtime_ssp_fd_pread(
ssize_t len = pread(fd_number(fo), buf, totalsize, offset); ssize_t len = pread(fd_number(fo), buf, totalsize, offset);
fd_object_release(fo); fd_object_release(fo);
if (len < 0) { if (len < 0) {
bh_free(buf); wasm_runtime_free(buf);
return convert_errno(errno); return convert_errno(errno);
} }
@ -903,7 +902,7 @@ __wasi_errno_t wasmtime_ssp_fd_pread(
break; break;
} }
} }
bh_free(buf); wasm_runtime_free(buf);
*nread = len; *nread = len;
return 0; return 0;
} }
@ -940,7 +939,7 @@ __wasi_errno_t wasmtime_ssp_fd_pwrite(
size_t totalsize = 0; size_t totalsize = 0;
for (size_t i = 0; i < iovcnt; ++i) for (size_t i = 0; i < iovcnt; ++i)
totalsize += iov[i].buf_len; totalsize += iov[i].buf_len;
char *buf = bh_malloc(totalsize); char *buf = wasm_runtime_malloc(totalsize);
if (buf == NULL) { if (buf == NULL) {
fd_object_release(fo); fd_object_release(fo);
return __WASI_ENOMEM; return __WASI_ENOMEM;
@ -954,7 +953,7 @@ __wasi_errno_t wasmtime_ssp_fd_pwrite(
// Perform a single write operation. // Perform a single write operation.
len = pwrite(fd_number(fo), buf, totalsize, offset); len = pwrite(fd_number(fo), buf, totalsize, offset);
bh_free(buf); wasm_runtime_free(buf);
} }
#endif #endif
fd_object_release(fo); fd_object_release(fo);
@ -1377,23 +1376,23 @@ static char *readlinkat_dup(
size_t len_org = len; size_t len_org = len;
for (;;) { for (;;) {
char *newbuf = bh_malloc((uint32)len); char *newbuf = wasm_runtime_malloc((uint32)len);
if (newbuf == NULL) { if (newbuf == NULL) {
if (buf) if (buf)
bh_free(buf); wasm_runtime_free(buf);
return NULL; return NULL;
} }
if (buf != NULL) { if (buf != NULL) {
bh_memcpy_s(newbuf, (uint32)len, buf, (uint32)len_org); bh_memcpy_s(newbuf, (uint32)len, buf, (uint32)len_org);
bh_free(buf); wasm_runtime_free(buf);
} }
buf = newbuf; buf = newbuf;
ssize_t ret = readlinkat(fd, path, buf, len); ssize_t ret = readlinkat(fd, path, buf, len);
if (ret < 0) { if (ret < 0) {
bh_free(buf); wasm_runtime_free(buf);
return NULL; return NULL;
} }
if ((size_t)ret + 1 < len) { if ((size_t)ret + 1 < len) {
@ -1444,7 +1443,7 @@ static __wasi_errno_t path_get(
__wasi_errno_t error = __wasi_errno_t error =
fd_object_get(curfds, &fo, fd, rights_base, rights_inheriting); fd_object_get(curfds, &fo, fd, rights_base, rights_inheriting);
if (error != 0) { if (error != 0) {
bh_free(path); wasm_runtime_free(path);
return error; return error;
} }
@ -1585,7 +1584,7 @@ static __wasi_errno_t path_get(
// when called on paths like ".", "a/..", but also if the path // when called on paths like ".", "a/..", but also if the path
// had trailing slashes and the caller is not interested in the // had trailing slashes and the caller is not interested in the
// name of the pathname component. // name of the pathname component.
bh_free(paths_start[0]); wasm_runtime_free(paths_start[0]);
pa->path = "."; pa->path = ".";
pa->path_start = NULL; pa->path_start = NULL;
goto success; goto success;
@ -1593,7 +1592,7 @@ static __wasi_errno_t path_get(
// Finished expanding symlink. Continue processing along the // Finished expanding symlink. Continue processing along the
// original path. // original path.
bh_free(paths_start[curpath--]); wasm_runtime_free(paths_start[curpath--]);
} }
continue; continue;
@ -1601,7 +1600,7 @@ static __wasi_errno_t path_get(
// Prevent infinite loops by placing an upper limit on the number of // Prevent infinite loops by placing an upper limit on the number of
// symlink expansions. // symlink expansions.
if (++expansions == 128) { if (++expansions == 128) {
bh_free(symlink); wasm_runtime_free(symlink);
error = __WASI_ELOOP; error = __WASI_ELOOP;
goto fail; goto fail;
} }
@ -1609,10 +1608,10 @@ static __wasi_errno_t path_get(
if (*paths[curpath] == '\0') { if (*paths[curpath] == '\0') {
// The original path already finished processing. Replace it by // The original path already finished processing. Replace it by
// this symlink entirely. // this symlink entirely.
bh_free(paths_start[curpath]); wasm_runtime_free(paths_start[curpath]);
} else if (curpath + 1 == sizeof(paths) / sizeof(paths[0])) { } else if (curpath + 1 == sizeof(paths) / sizeof(paths[0])) {
// Too many nested symlinks. Stop processing. // Too many nested symlinks. Stop processing.
bh_free(symlink); wasm_runtime_free(symlink);
error = __WASI_ELOOP; error = __WASI_ELOOP;
goto fail; goto fail;
} else { } else {
@ -1644,7 +1643,7 @@ fail:
for (size_t i = 1; i <= curfd; ++i) for (size_t i = 1; i <= curfd; ++i)
close(fds[i]); close(fds[i]);
for (size_t i = 0; i <= curpath; ++i) for (size_t i = 0; i <= curpath; ++i)
bh_free(paths_start[i]); wasm_runtime_free(paths_start[i]);
fd_object_release(fo); fd_object_release(fo);
return error; return error;
#endif #endif
@ -1668,7 +1667,7 @@ static __wasi_errno_t path_get_nofollow(
static void path_put( static void path_put(
struct path_access *pa struct path_access *pa
) UNLOCKS(pa->fd_object->refcount) { ) UNLOCKS(pa->fd_object->refcount) {
bh_free(pa->path_start); wasm_runtime_free(pa->path_start);
if (fd_number(pa->fd_object) != pa->fd) if (fd_number(pa->fd_object) != pa->fd)
close(pa->fd); close(pa->fd);
fd_object_release(pa->fd_object); fd_object_release(pa->fd_object);
@ -1770,12 +1769,12 @@ __wasi_errno_t wasmtime_ssp_path_link(
rwlock_rdlock(&prestats->lock); rwlock_rdlock(&prestats->lock);
if (!validate_path(target, prestats)) { if (!validate_path(target, prestats)) {
rwlock_unlock(&prestats->lock); rwlock_unlock(&prestats->lock);
bh_free(target); wasm_runtime_free(target);
return __WASI_EBADF; return __WASI_EBADF;
} }
rwlock_unlock(&prestats->lock); rwlock_unlock(&prestats->lock);
ret = symlinkat(target, new_pa.fd, new_pa.path); ret = symlinkat(target, new_pa.fd, new_pa.path);
bh_free(target); wasm_runtime_free(target);
} }
} }
path_put(&old_pa); path_put(&old_pa);
@ -2312,21 +2311,21 @@ __wasi_errno_t wasmtime_ssp_path_symlink(
__wasi_errno_t error = path_get_nofollow(curfds, __wasi_errno_t error = path_get_nofollow(curfds,
&pa, fd, new_path, new_path_len, __WASI_RIGHT_PATH_SYMLINK, 0, true); &pa, fd, new_path, new_path_len, __WASI_RIGHT_PATH_SYMLINK, 0, true);
if (error != 0) { if (error != 0) {
bh_free(target); wasm_runtime_free(target);
return error; return error;
} }
rwlock_rdlock(&prestats->lock); rwlock_rdlock(&prestats->lock);
if (!validate_path(target, prestats)) { if (!validate_path(target, prestats)) {
rwlock_unlock(&prestats->lock); rwlock_unlock(&prestats->lock);
bh_free(target); wasm_runtime_free(target);
return __WASI_EBADF; return __WASI_EBADF;
} }
rwlock_unlock(&prestats->lock); rwlock_unlock(&prestats->lock);
int ret = symlinkat(target, pa.fd, pa.path); int ret = symlinkat(target, pa.fd, pa.path);
path_put(&pa); path_put(&pa);
bh_free(target); wasm_runtime_free(target);
if (ret < 0) if (ret < 0)
return convert_errno(errno); return convert_errno(errno);
return 0; return 0;
@ -2479,12 +2478,12 @@ __wasi_errno_t wasmtime_ssp_poll_oneoff(
// __WASI_EVENTTYPE_FD_WRITE entries. There may be up to one // __WASI_EVENTTYPE_FD_WRITE entries. There may be up to one
// __WASI_EVENTTYPE_CLOCK entry to act as a timeout. These are also // __WASI_EVENTTYPE_CLOCK entry to act as a timeout. These are also
// the subscriptions generate by cloudlibc's poll() and select(). // the subscriptions generate by cloudlibc's poll() and select().
struct fd_object **fos = bh_malloc((uint32)(nsubscriptions * sizeof(*fos))); struct fd_object **fos = wasm_runtime_malloc((uint32)(nsubscriptions * sizeof(*fos)));
if (fos == NULL) if (fos == NULL)
return __WASI_ENOMEM; return __WASI_ENOMEM;
struct pollfd *pfds = bh_malloc((uint32)(nsubscriptions * sizeof(*pfds))); struct pollfd *pfds = wasm_runtime_malloc((uint32)(nsubscriptions * sizeof(*pfds)));
if (pfds == NULL) { if (pfds == NULL) {
bh_free(fos); wasm_runtime_free(fos);
return __WASI_ENOMEM; return __WASI_ENOMEM;
} }
@ -2623,8 +2622,8 @@ __wasi_errno_t wasmtime_ssp_poll_oneoff(
for (size_t i = 0; i < nsubscriptions; ++i) for (size_t i = 0; i < nsubscriptions; ++i)
if (fos[i] != NULL) if (fos[i] != NULL)
fd_object_release(fos[i]); fd_object_release(fos[i]);
bh_free(fos); wasm_runtime_free(fos);
bh_free(pfds); wasm_runtime_free(pfds);
return error; return error;
} }
@ -2866,12 +2865,12 @@ bool argv_environ_init(struct argv_environ_values *argv_environ,
total_size = sizeof(char *) * (uint64)argv_offsets_len; total_size = sizeof(char *) * (uint64)argv_offsets_len;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(argv_environ->argv = bh_malloc((uint32)total_size))) || !(argv_environ->argv = wasm_runtime_malloc((uint32)total_size)))
return false; return false;
if (argv_buf_len >= UINT32_MAX if (argv_buf_len >= UINT32_MAX
|| !(argv_environ->argv_buf = bh_malloc((uint32)argv_buf_len))) || !(argv_environ->argv_buf = wasm_runtime_malloc((uint32)argv_buf_len)))
goto fail1; goto fail1;
for (i = 0; i < argv_offsets_len; ++i) { for (i = 0; i < argv_offsets_len; ++i) {
@ -2885,11 +2884,11 @@ bool argv_environ_init(struct argv_environ_values *argv_environ,
total_size = sizeof(char *) * (uint64)environ_offsets_len; total_size = sizeof(char *) * (uint64)environ_offsets_len;
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(argv_environ->environ = bh_malloc((uint32)total_size))) || !(argv_environ->environ = wasm_runtime_malloc((uint32)total_size)))
goto fail2; goto fail2;
if (environ_buf_len >= UINT32_MAX if (environ_buf_len >= UINT32_MAX
|| !(argv_environ->environ_buf = bh_malloc((uint32)environ_buf_len))) || !(argv_environ->environ_buf = wasm_runtime_malloc((uint32)environ_buf_len)))
goto fail3; goto fail3;
for (i = 0; i < environ_offsets_len; ++i) { for (i = 0; i < environ_offsets_len; ++i) {
@ -2901,11 +2900,11 @@ bool argv_environ_init(struct argv_environ_values *argv_environ,
return true; return true;
fail3: fail3:
bh_free(argv_environ->environ); wasm_runtime_free(argv_environ->environ);
fail2: fail2:
bh_free(argv_environ->argv_buf); wasm_runtime_free(argv_environ->argv_buf);
fail1: fail1:
bh_free(argv_environ->argv); wasm_runtime_free(argv_environ->argv);
memset(argv_environ, 0, sizeof(struct argv_environ_values)); memset(argv_environ, 0, sizeof(struct argv_environ_values));
return false; return false;
@ -2914,13 +2913,13 @@ fail1:
void argv_environ_destroy(struct argv_environ_values *argv_environ) void argv_environ_destroy(struct argv_environ_values *argv_environ)
{ {
if (argv_environ->argv_buf) if (argv_environ->argv_buf)
bh_free(argv_environ->argv_buf); wasm_runtime_free(argv_environ->argv_buf);
if (argv_environ->argv) if (argv_environ->argv)
bh_free(argv_environ->argv); wasm_runtime_free(argv_environ->argv);
if (argv_environ->environ_buf) if (argv_environ->environ_buf)
bh_free(argv_environ->environ_buf); wasm_runtime_free(argv_environ->environ_buf);
if (argv_environ->environ) if (argv_environ->environ)
bh_free(argv_environ->environ); wasm_runtime_free(argv_environ->environ);
} }
void fd_table_destroy(struct fd_table *ft) void fd_table_destroy(struct fd_table *ft)
@ -2931,7 +2930,7 @@ void fd_table_destroy(struct fd_table *ft)
fd_object_release(ft->entries[i].object); fd_object_release(ft->entries[i].object);
} }
} }
bh_free(ft->entries); wasm_runtime_free(ft->entries);
} }
} }
@ -2940,9 +2939,9 @@ void fd_prestats_destroy(struct fd_prestats *pt)
if (pt->prestats) { if (pt->prestats) {
for (uint32 i = 0; i < pt->size; i++) { for (uint32 i = 0; i < pt->size; i++) {
if (pt->prestats[i].dir != NULL) { if (pt->prestats[i].dir != NULL) {
bh_free((void*)pt->prestats[i].dir); wasm_runtime_free((void*)pt->prestats[i].dir);
} }
} }
bh_free(pt->prestats); wasm_runtime_free(pt->prestats);
} }
} }

15
core/shared/include/bh_common.h
View File

@ -6,12 +6,7 @@
#ifndef _BH_COMMON_H #ifndef _BH_COMMON_H
#define _BH_COMMON_H #define _BH_COMMON_H
#include "bh_assert.h"
#include "bh_platform.h" #include "bh_platform.h"
#include "bh_list.h"
typedef void (*bh_print_function_t)(const char* message);
void bh_set_print_function(bh_print_function_t pf);
#define bh_memcpy_s(dest, dlen, src, slen) do { \ #define bh_memcpy_s(dest, dlen, src, slen) do { \
int _ret = slen == 0 ? 0 : b_memcpy_s (dest, dlen, src, slen); \ int _ret = slen == 0 ? 0 : b_memcpy_s (dest, dlen, src, slen); \
@ -31,4 +26,14 @@ void bh_set_print_function(bh_print_function_t pf);
bh_assert (_ret == 0); \ bh_assert (_ret == 0); \
} while (0) } while (0)
int b_memcpy_s(void * s1, unsigned int s1max, const void * s2, unsigned int n);
int b_strcat_s(char * s1, size_t s1max, const char * s2);
int b_strcpy_s(char * s1, size_t s1max, const char * s2);
/* strdup with string allocated by BH_MALLOC */
char *bh_strdup(const char *s);
/* strdup with string allocated by WA_MALLOC */
char *wa_strdup(const char *s);
#endif #endif

111
core/shared/include/bh_memory.h
View File

@ -1,111 +0,0 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#ifndef _BH_MEMORY_H
#define _BH_MEMORY_H
#ifdef __cplusplus
extern "C" {
#endif
#define BH_KB (1024)
#define BH_MB ((BH_KB)*1024)
#define BH_GB ((BH_MB)*1024)
/**
* Initialize memory allocator with a pool, the bh_malloc/bh_free function
* will malloc/free memory from the pool
*
* @param mem the pool buffer
* @param bytes the size bytes of the buffer
*
* @return 0 if success, -1 otherwise
*/
int bh_memory_init_with_pool(void *mem, unsigned int bytes);
/**
* Initialize memory allocator with memory allocator, the bh_malloc/bh_free
* function will malloc/free memory with the allocator passed
*
* @param malloc_func the malloc function
* @param free_func the free function
*
* @return 0 if success, -1 otherwise
*/
int bh_memory_init_with_allocator(void *malloc_func, void *free_func);
/**
* Destroy memory
*/
void bh_memory_destroy();
/**
* Get the pool size of memory, if memory is initialized with allocator,
* return 1GB by default.
*/
unsigned bh_memory_pool_size();
#if BEIHAI_ENABLE_MEMORY_PROFILING == 0
/**
* This function allocates a memory chunk from system
*
* @param size bytes need allocate
*
* @return the pointer to memory allocated
*/
void* bh_malloc(unsigned int size);
/**
* This function reallocates a memory chunk from system
*
* @param ptr the original memory
* @param size bytes need allocate
*
* @return the pointer to memory allocated
*/
void* bh_realloc(void *ptr, unsigned int size);
/**
* This function frees memory chunk
*
* @param ptr the pointer to memory need free
*/
void bh_free(void *ptr);
#else
void* bh_malloc_profile(const char *file, int line, const char *func, unsigned int size);
void* bh_realloc_profile(const char *file, int line, const char *func, void *ptr, unsigned int size);
void bh_free_profile(const char *file, int line, const char *func, void *ptr);
#define bh_malloc(size) bh_malloc_profile(__FILE__, __LINE__, __func__, size)
#define bh_realloc(ptr, size) bh_malloc_profile(__FILE__, __LINE__, __func__, ptr, size)
#define bh_free(ptr) bh_free_profile(__FILE__, __LINE__, __func__, ptr)
/**
* Print current memory profiling data
*
* @param file file name of the caller
* @param line line of the file of the caller
* @param func function name of the caller
*/
void memory_profile_print(const char *file, int line, const char *func, int alloc);
/**
* Summarize memory usage and print it out
* Can use awk to analyze the output like below:
* awk -F: '{print $2,$4,$6,$8,$9}' OFS="\t" ./out.txt | sort -n -r -k 1
*/
void memory_usage_summarize();
#endif
#ifdef __cplusplus
}
#endif
#endif /* #ifndef _BH_MEMORY_H */

4
core/shared/include/bh_queue.h
View File

@ -20,8 +20,8 @@ typedef struct bh_queue bh_queue;
typedef void (*bh_queue_handle_msg_callback)(void *message, void *arg); typedef void (*bh_queue_handle_msg_callback)(void *message, void *arg);
#define bh_queue_malloc bh_malloc #define bh_queue_malloc BH_MALLOC
#define bh_queue_free bh_free #define bh_queue_free BH_FREE
#define bh_queue_mutex korp_mutex #define bh_queue_mutex korp_mutex
#define bh_queue_sem korp_sem #define bh_queue_sem korp_sem

225
core/shared/include/bni.h
View File

@ -1,225 +0,0 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
/**
* @file bni.h
* @date Mon Jul 2 16:54:58 2012
*
* @brief Beihai native interface.
*/
#ifndef BNI_H
#define BNI_H
#include "bh_types.h"
/* Primitive types */
typedef uint8 jboolean;
typedef int8 jbyte;
typedef uint16 jchar;
typedef int16 jshort;
typedef int32 jint;
typedef int64 jlong;
typedef float jfloat;
typedef double jdouble;
typedef jint jsize;
/* Predefined Java class types. */
struct _jobject;
typedef struct _jobject *jobject;
struct _jclass;
typedef struct _jclass *jclass;
struct _jstring;
typedef struct _jstring *jstring;
/* Values of jboolean: */
#define BNI_FALSE 0
#define BNI_TRUE 1
/**
* Return the length of the array object.
*
* @param array Java array object
*
* @return the length of the Java array
*/
#define bni_array_length(array) ((jsize)((uint32)(array)->__length >> 2))
/**
* Return the address of the first element of array object.
*
* @param array Java array object
*
* @return the address of the first element of array object
*/
#define bni_array_elem(array) ((array)->__elem)
/**
* Find the Java class with given class name.
*
* @param name Java class name
*
* @return class object of the Java class if found, NULL otherwise
*
* @throws OutOfMemoryError if VM runs out of memory.
*/
jclass
bni_find_class(const char *name);
/**
* Throw an exception of given class with message.
*
* @param clazz class object of a subclass of java.lang.Throwable
* @param msg message for the exception or NULL if no message
*
* @return 0 if succeeds, nonzero otherwise
*/
jint
bni_throw_new(jclass clazz, const char *msg);
/**
* Throw a NullPointerException.
*
* @throws NullPointerException
*/
void
bni_throw_npe(void);
/**
* Throw an ArrayIndexOutOfBoundsException
*
* @param index the index used to access the array
*
* @throws ArrayIndexOutOfBoundsException
*/
void
bni_throw_aioobe(int index);
/**
* Determine whether an exception is being thrown.
*
* @return exception object if exception is thrown, NULL otherwise
*/
jobject
bni_exception_occurred(void);
/**
* Print the current exception to error-reporting channel.
*/
void
bni_exception_describe(void);
/**
* Clear the currently thrown exception.
*/
void
bni_exception_clear(void);
/**
* Return the Unicode character number of a string.
*
* @param str Java string object
*
* @return the Unicode character number of the string
*/
jsize
bni_string_length(jstring str);
/**
* Return the length in bytes of the modified UTF-8 representation of
* a string.
*
* @param str Java string object
* @param start start offset in the string
* @param len number of Unicode characters
*
* @return the UTF-8 length of the string
*
* @throws StringIndexOutOfBoundsException on index overflow.
*/
jsize
bni_string_utf_length(jstring str, jsize start, jsize len);
/**
* Copies len number of Unicode characters beginning at offset start
* to the given buffer buf.
*
* @param str Java string object
* @param start start offset in the string
* @param len number of Unicode characters to copy
* @param buf buffer for storing the result
*/
void
bni_string_region(jstring str, jsize start, jsize len, jchar *buf);
/**
* Translates len number of Unicode characters beginning at offset
* start into modified UTF-8 encoding and place the result in the
* given buffer buf.
*
* @param str Java string object
* @param start start offset in the string
* @param len number of Unicode characters to copy
* @param buf buffer for storing the result
*
* @throws StringIndexOutOfBoundsException on index overflow.
*/
void
bni_string_utf_region(jstring str, jsize start, jsize len, char *buf);
/**
* Translate Unicode characters into modified UTF-8 encoding and return
* the result.
*
* @param str Java string object
*
* @return the UTF-8 encoding string if succeeds, NULL otherwise
*/
char *
bni_string_get_utf_chars(jstring str);
/**
* Get the given Java object's class index.
*
* @param obj Java object
*
* @return -1 if obj is an array, class index of the object otherwise
*/
jint
bni_object_class_index(jobject obj);
/**
* Allocate memory from the current instance's private heap.
*
* @param size bytes to allocate
*
* @return pointer to the allocated memory
*
* @throws OutOfMemoryError if VM runs out of memory.
*/
void*
bni_malloc(unsigned size);
/**
* Allocate memory from the current instance's private heap and clear
* to zero.
*
* @param size bytes to allocate
*
* @return pointer to the allocated memory
*
* @throws OutOfMemoryError if VM runs out of memory.
*/
void*
bni_calloc(unsigned size);
/**
* Free the memory allocated from the current instance's private heap.
*
* @param ptr pointer to the memory in current instance's private heap
*/
void
bni_free(void *ptr);
#endif

604
core/shared/include/jeff_export.h
View File

@ -1,604 +0,0 @@
/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
/**
* @file jeff-export.h
* @date Wed Aug 3 18:17:30 2011
*
* @brief Exported interface for operating or executing JEFF files.
* All interface names start with "jeff_", which is the namespace name
* of this module.
*/
#ifndef JEFF_EXPORT_H
#define JEFF_EXPORT_H
#include "bni.h"
#include "bh_types.h"
/********************************************************************
* Exported internal types
********************************************************************/
/**
* JEFF file handle type
*/
struct JeffFileHeaderLinked;
typedef struct JeffFileHeaderLinked *jeff_file_t;
/**
* JEFF class type
*/
struct JeffClassHeaderLinked;
typedef struct JeffClassHeaderLinked *jeff_class_t;
/**
* VM instance handle type
*/
struct JeffInstanceLocalRoot;
typedef struct JeffInstanceLocalRoot *jeff_instance_t;
/**
* Record of one native method's definition.
*/
struct JeffNativeMethodDef {
/* Mangled name of the native method. NULL for initialization
functions. */
const char *mangled_name;
/* Points to the native C function. */
void (*func_ptr)(uint32 *);
/* Return size type of the native function. */
uint32 return_size_type;
};
/********************************************************************
* Interface for operating global environment of the JEFF VM
********************************************************************/
/**
* Load the core library from the given file buffer and initialize the
* runtime environment (global objects etc.) of the VM. The thread
* calls this function becomes the supervisor thread, which belongs to
* a unique supervisor instance. Currently, if this init failed,
* partially initialized states of the VM runtime environment won't be
* cleaned up, so the VM must be shutdown and restarted. method_defs
* points to an array of native method definition records.
* Initialization functions must be in the front of the array and
* following native method definitions must be sorted by their mangled
* names.
*
* @param file the JEFF file of the core library
* @param file_size the size of the JEFF file of the core library
* @param method_defs native method definition records
* @param method_defs_num number of native method records
* @param heap the heap for the current (supervisor) instance
*
* @return true if succeeds, otherwise the error cannot be recovered
*/
bool
jeff_runtime_init(jeff_file_t file, unsigned file_size,
struct JeffNativeMethodDef *method_defs, unsigned method_defs_num,
void *heap);
/**
* Load a JEFF file into the VM from the given file buffer. It can be
* called from any VM thread.
*
* @param file the JEFF file to be loaded
* @param size the size of the JEFF file
* @param is_library whether the JEFF file is a library
* @param allow_to_load a function that returns true if classes in the
* given package is allowed to be loaded. The NULL function pointer
* allows all packages.
* @param allow_to_link a function that returns true if classes in the
* given package is allowed to be linked to. The NULL function
* pointer allows all packages.
*
* @return true if succeeds, otherwise detailed error information is
* passed to vmci_diagnostic_print. The caller can catch it by
* implementing that function.
*/
bool
jeff_runtime_load(jeff_file_t file, unsigned size, bool is_library,
bool (*allow_to_load)(const uint8 *pname, unsigned len),
bool (*allow_to_link)(const uint8 *pname, unsigned plen,
const uint8 *cname, unsigned clen));
/**
* Unload a JEFF file from the VM. All resources related to the JEFF
* file except the JEFF file itself are released. It can be called
* from any VM thread.
*
* @param file the JEFF file to be unloaded
*
* @return true if succeeds, otherwise detailed error information is
* passed to vmci_diagnostic_print. The caller can catch it by
* implementing that function.
*/
bool
jeff_runtime_unload(jeff_file_t file);
/**
* Return the JEFF file with the given file uid.
*
* @param fuid the unique id of a loaded JEFF file
*
* @return the JEFF file is exists, otherwise NULL
*/
jeff_file_t
jeff_runtime_fuid_to_file(unsigned fuid);
/**
* Return the file uid of the given JEFF file.
*
* @param file a loaded JEFF file
*
* @return the unique id of the given JEFF file
*/
unsigned
jeff_runtime_file_to_fuid(jeff_file_t file);
/**
* Create a supervisor thread belonging to the supervisor instance.
* Threads that may interact with VM core must be either the main
* thread of supervisor instance (which calls jeff_runtime_init) or
* created by this function so that VM core required data structures
* can be set up correctly.
*
* @param start_routine the start routine of the new thread
* @param arg argument to the start routine
*
* @return true if succeeds, false otherwise
*/
bool
jeff_runtime_create_supervisor_thread(void* (*start_routine)(void *),
void *arg);
/**
* Create a supervisor thread belonging to the supervisor instance.
* Threads that may interact with VM core must be either the main
* thread of supervisor instance (which calls jeff_runtime_init) or
* created by this function so that VM core required data structures
* can be set up correctly.
*
* @param start_routine the start routine of the new thread
* @param arg argument to the start routine
* @param prio thread priority
*
* @return true if succeeds, false otherwise
*/
bool
jeff_runtime_create_supervisor_thread_with_prio(void* (*start_routine)(void *),
void *arg, int prio);
/********************************************************************
* Interface for operating instance local environment
********************************************************************/
/**
* Create a VM instance with the given JEFF file as its main file,
* (i.e. the file containing the main class of the VM instance). This
* function can be called from any VM thread, but it must be isolated
* from JEFF file's unloading operation so that the main file won't be
* unloaded before it's locked by the new instance. All instance
* local memory except stacks of threads are allocated from the given
* heap. If succeeds, it increases reference count of the main_file
* and returns the handle of the new VM instance. The new instance's
* main thread will run the start_routine with argument arg. If the
* cleanup_routine is not NULL, it will be called after start_routine
* returns and just before the main thread exits. It will also be
* called after the instance is destroied. It is guaranteed to be
* called exactly once no matter how the instance terminates.
*
* @param main_file the main JEFF file of the new instance
* @param heap the private heap of the new instance
* @param stack_depth the maximal nesting levels of Java methods of
* the new instance. It must be <= 16 * 1024. Otherwise the instance
* creation will fail.
* @param start_routine start routine of the main thread. Don't
* destroy the heap or inform other thread to do this at the end of
* this routine since after it returns, VM core will call destroy
* functions on objects allocated in this heap (e.g. locks and
* condition variables). Do the destroying or informing of destroying
* in the cleanup_routine.
* @param arg the instance argument that will be passed to the start
* routine. It can be get or set by jeff_runtime_get_instance_arg and
* jeff_runtime_set_instance arg from threads of the instance. The
* caller can use it to store instance local data.
* @param cleanup_routine the optional cleanup routine for the
* instance, which may be NULL. It may be executed in the end of the
* main thread of the created instance by this function if this
* instance exits normally, or it may be executed in a thread of other
* instance in case this instance is being killed by that instance.
* In both cases, this routine regards it is executed in a thread of
* this instance (the instance created by this function) because
* jeff_runtime_get_instance_arg will always return the argument of
* this instance.
*
* @return the VM instance handle if succeeds, NULL otherwise
*/
jeff_instance_t
jeff_runtime_create_instance(jeff_file_t main_file, void *heap,
unsigned stack_depth, void* (*start_routine)(void *), void *arg,
void (*cleanup_routine)(void));
/**
* Destroy the given VM instance and decrease the reference count of
* its main file and all explicitly used JEFF files. It can be called
* from any VM thread. If there are alive threads of the instance,
* they will be terminated mandatorily and then the cleanup routine is
* called if it's not NULL.
*
* @param handle the handle of the instance to be destroyed
*/
void
jeff_runtime_destroy_instance(jeff_instance_t handle);
/**
* Retrieve the current instance's argument.
*
* @return the current instance's argument
*/
void*
jeff_runtime_get_instance_arg(void);
/**
* Set the current instance's argument.
*
* @return the new argument for the current instance
*/
void
jeff_runtime_set_instance_arg(void *arg);
/**
* Retrieve the current instance's heap.
*
* @return the current instance's heap
*/
void*
jeff_runtime_get_instance_heap(void);
/**
* Suspend all threads of the given VM instance. This function can
* only be called from thread that is not of the given VM instance.
*
* @param handle the handle of the instance to be suspended
*/
void
jeff_runtime_suspend_instance(jeff_instance_t handle);
/**
* Resume all threads of the given VM instance. This function can
* only be called from thread that is not of the given VM instance.
*
* @param handle the handle of the instance to be resumed
*/
void
jeff_runtime_resume_instance(jeff_instance_t handle);
/**
* Interrupt all threads of the given VM instance. This function can
* only be called from thread that is not of the given VM instance.
*
* @param handle the handle of the instance to be interrupted
* @param by_force whether the interruption is by force
*/
void
jeff_runtime_interrupt_instance(jeff_instance_t handle, bool by_force);
/**
* Wait for the given VM instance to terminate.
*
* @param ilr the VM instance to be waited for
* @param mills wait millseconds to return
*/
void
jeff_runtime_wait_for_instance(jeff_instance_t ilr, int mills);
/********************************************************************
* Interface for operating thread local environment
********************************************************************/
/**
* Return true if there is an uncaught exception (thrown during
* running an application or applet command).
*
* @return true if there is an uncaught exception
*/
bool
jeff_runtime_check_uncaught_exception(void);
/**
* Print qualified name of the uncaught exception (and stack trace if
* enabled) by calling vmci_diagnostic_print.
*/
void
jeff_runtime_print_uncaught_exception(void);
/**
* Clear the uncaught exception.
*/
void
jeff_runtime_reset_uncaught_exception(void);
/**
* Change current thread to a safe state (VMWAIT). After calling this
* and before calling jeff_runtime_exit_safe_state, all operations
* must be safe, i.e. no GC or system level resource operations are
* allowed because in a safe state, the VM instance is assumed to be
* able to perform GC, JDWP or termination at any time. Usually, this
* function is called just before the native code is going to wait for
* something and the exiting safe state function is called just after
* the waiting returns.
*/
void
jeff_runtime_enter_safe_state(void);
/**
* Change current thread to an unsafe state (RUNNING) so that unsafe
* operations can also be done.
*/
void
jeff_runtime_exit_safe_state(void);
/**
* Set thread local error code for the current thread.
*
* @param code the error code to be set
*/
void
jeff_runtime_set_error(unsigned code);
/**
* Get the last error code of current thread.
*
* @return the last error code of current thread
*/
unsigned
jeff_runtime_get_error(void);
/********************************************************************
* Interface for GC support
********************************************************************/
/**
* Traverse all objects of the given heap that are global or locate in
* threads' frames and return them by calling vmci_gc_rootset_elem.
* This function will suspend all threads except the current one of
* the VM instance owning the given heap before traversing. It
* traverses either all or none of the rootset objects, and returns
* true and false respectively. If it returns false, the GC process
* shouldn't proceed and is not necessary to unmark anything because
* no objects are marked. The function jeff_runtime_gc_finished must
* be called if and only if this function returns true so as to resume
* threads that are suspended during GC process.
*
* @param heap the heap for which rootset objects are looked up
*
* @return true if succeeds, false otherwise
*/
bool
jeff_runtime_traverse_gc_rootset(void *heap);
/**
* Get the reference offset table of the given object. If the
* returned value R >= 0, *ret points to the reference offset table of
* the object and R is the number of offsets in the table. Otherwise,
* if the returned value R < 0, all reference fields of the object
* must be in a continuous region (usually the object is an array),
* then *ret is the offset to the first field in the region and R is
* the number of such fields in the region.
*
* @param obj pointer to the Java object
* @param ret points to a pointer for storing the reference offset
* table if return value >= 0, or for storing the offset to the first
* object reference in the Java object if return value < 0
*
* @return number of offsets in the reference_offset table if >= 0, or
* number of object references in the object if < 0
*/
int
jeff_object_get_reference_offsets(const jobject obj, uint16 **ret);
/**
* Inform the containing VM instance that GC has finished and all
* suspended threads can be resumed. This function must be called if
* and only if jeff_runtime_traverse_gc_rootset returns true.
*/
void
jeff_runtime_gc_finished(void);
/********************************************************************
* Interface for tooling support
********************************************************************/
/**
* This function is used to suspend the main thread of VM instance so
* that debugger can have chance to connect to the VM instance, set
* breakpoints and do any other debug settings. It must be called
* from the main thread of VM instance at the point just after VM
* instance initialization finishes and just before application code
* is to be executed.
*/
void
jeff_tool_suspend_self(void);
/**
* Start up tool agent thread for the given VM instance. It can be
* called from any VM thread.
*
* @param handle the VM instance for which tool agent is started up
* @param queue queue of the tool agent
* @return true if succeeds, false otherwise
*/
bool
jeff_tool_start_agent(jeff_instance_t handle, void *queue);
/********************************************************************
* Interface for toolkit support
********************************************************************/
/**
* Return the JEFF class pointer of the given class name.
*
* @param class_name the qualified class name
*
* @return the JEFF class pointer
*/
jeff_class_t
jeff_tool_get_jeff_class(const char *class_name);
/**
* Get the mangled class name of the given class.
*
* @param clz the JEFF class
* @param buf buffer for returning the mangled name
* @param buf_size size of the buffer
*
* @return actual size of the mangled class name including the
* terminating null byte
*/
unsigned
jeff_tool_get_mangled_class_name(jeff_class_t clz, char *buf,
unsigned buf_size);
/**
* Get class index of given class in its containing JEFF file.
*
* @param clz the JEFF class
*
* @return class index in the containing JEFF file
*/
int
jeff_tool_get_class_index(jeff_class_t clz);
/**
* Callback handler prototype for traversing fields of class.
*
* @param arg argument passed to the handler from caller
* @param access_flag access flag of the method
* @param name the field name
* @param descriptor mangled field type descriptor
* @param offset the offset of the field in the class
* @param size size of the field
*/
typedef void
(*JeffToolFieldHandler)(void *arg, unsigned access_flag, const char *name,
const char *descriptor, unsigned offset, unsigned size);
/**
* Traverse all fields of the given class, including those inherited
* from super classes. The fields are traversed in the same order as
* the field layout of the class.
*
* @param arg argument to be passed to the handler
* @param clz the JEFF class
* @param instance instance fields or static fielts
* @param handler the callback handler for each field
*/
void
jeff_tool_foreach_field(void *arg, jeff_class_t clz, bool instance,
JeffToolFieldHandler handler);
/**
* Callback handler prototype for traversing methods of class.
*
* @param arg argument passed to the handler from caller
* @param access_flag access flag of the method
* @param name mangled name of the method
* @param descriptor mangled method arguments descriptor
* @param retune_type mangled descriptor of method's return type
*/
typedef void
(*JeffToolMethodHandler)(void *arg, unsigned access_flag, const char *name,
const char *descriptor, const char *return_type);
/**
* Traverse all methods of the given class.
*
* @param arg argument to be passed to the handler
* @param clz the JEFF class
* @param handler the callback handler for each method
*/
void
jeff_tool_foreach_method(void *arg, jeff_class_t clz,
JeffToolMethodHandler handler);
/**
* Callback handler prototype for traversing classes of main file.
*
* @param arg argument passed to the handler from caller
* @param clz pointer to one class in the main file
*/
typedef void
(*JeffToolClassHandler)(void *arg, jeff_class_t clz);
/**
* Traverse all classes of the main file.
*
* @param arg argument to be passed to the handler
* @param handler the callback handler for each class
*/
void
jeff_tool_foreach_class(void *arg, JeffToolClassHandler handler);
/********************************************************************
* Interface for executing applications
********************************************************************/
/**
* Initialize global environment for executing Java applications.
*
* @return true if succeeds, false otherwise
*/
bool
jeff_application_env_init(void);
/**
* Find the unique class containing a public static "main
* ([Ljava.lang.String;)V" method from the main JEFF file of the
* current instance and execute that method.
*
* @param argc the number of arguments
* @param argv the arguments array
*
* @return true if the main method is called, false otherwise (e.g. an
* exception occurs when preparing the arguments Java string array)
*/
bool
jeff_application_execute(int argc, char *argv[]);
/********************************************************************
* Interface for executing applets
********************************************************************/
/**
* Initialize global environment for executing applets.
*
* @return true if succeeds, false otherwise
*/
bool
jeff_applet_env_init(void);
/**
* Start to run from com.intel.runtime.core.RuntimeContext.main with a
* default message queue size and a default service class object. If
* the main JEFF file of the current VM instance contains exactly one
* class that is derived from com.intel.util.IntelApplet, then use it
* as the default service class.
*
* @param queue_size the default main message queue size
* @param default_service_class qualified class name of the default
* service class (entry point class), which must be in the main JEFF
* file. If NULL, find the default main class with rules described
* above.
*
* @return true if succeeds, false otherwise
*/
bool
jeff_applet_start(int queue_size, const char *default_service_class);
#endif

1
core/shared/mem-alloc/ems/ems_gc_internal.h
View File

@ -12,7 +12,6 @@ extern "C" {
#include "bh_platform.h" #include "bh_platform.h"
#include "bh_thread.h" #include "bh_thread.h"
#include "bh_memory.h"
#include "bh_assert.h" #include "bh_assert.h"
#include "ems_gc.h" #include "ems_gc.h"

3
core/shared/mem-alloc/mem_alloc.cmake
View File

@ -9,8 +9,7 @@ include_directories(${MEM_ALLOC_DIR})
file (GLOB_RECURSE source_all file (GLOB_RECURSE source_all
${MEM_ALLOC_DIR}/ems/*.c ${MEM_ALLOC_DIR}/ems/*.c
${MEM_ALLOC_DIR}/tlsf/*.c ${MEM_ALLOC_DIR}/tlsf/*.c
${MEM_ALLOC_DIR}/mem_alloc.c ${MEM_ALLOC_DIR}/mem_alloc.c)
${MEM_ALLOC_DIR}/bh_memory.c)
set (MEM_ALLOC_SHARED_SOURCE ${source_all}) set (MEM_ALLOC_SHARED_SOURCE ${source_all})

20
core/shared/platform/CMakeLists.txt
View File

@ -1,20 +0,0 @@
# Copyright (C) 2019 Intel Corporation. All rights reserved.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
include_directories (./include ../include ./${WAMR_BUILD_PLATFORM})
add_definitions (-D__POSIX__ -D_XOPEN_SOURCE=600 -D_POSIX_C_SOURCE=200809L -D_BSD_SOURCE)
file (GLOB_RECURSE source_all ${WAMR_BUILD_PLATFORM}/*.c)
add_library (supportlib ${source_all})
target_link_libraries (supportlib -pthread -lrt)
if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
add_library (supportlib_ut ${source_all})
set_target_properties (supportlib_ut PROPERTIES COMPILE_DEFINITIONS BH_TEST=1)
target_link_libraries (supportlib_ut -pthread -lrt)
endif ()

4
core/shared/platform/Makefile
View File

@ -1,4 +0,0 @@
# Copyright (C) 2019 Intel Corporation. All rights reserved.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
obj-y += zephyr/

22
core/shared/platform/alios/bh_platform.c
View File

@ -4,7 +4,6 @@
*/ */
#include "bh_platform.h" #include "bh_platform.h"
#include "bh_memory.h"
#include "bh_common.h" #include "bh_common.h"
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -15,16 +14,33 @@ bh_platform_init()
return 0; return 0;
} }
void *
os_malloc(unsigned size)
{
return NULL;
}
void *
os_realloc(void *ptr, unsigned size)
{
return NULL;
}
void
os_free(void *ptr)
{
}
void * void *
bh_mmap(void *hint, unsigned int size, int prot, int flags) bh_mmap(void *hint, unsigned int size, int prot, int flags)
{ {
return bh_malloc(size); return BH_MALLOC(size);
} }
void void
bh_munmap(void *addr, uint32 size) bh_munmap(void *addr, uint32 size)
{ {
return bh_free(addr); return BH_FREE(addr);
} }
int int

13
core/shared/platform/alios/bh_platform.h
View File

@ -8,7 +8,6 @@
#include "bh_config.h" #include "bh_config.h"
#include "bh_types.h" #include "bh_types.h"
#include "bh_memory.h"
#include <aos/kernel.h> #include <aos/kernel.h>
#include <inttypes.h> #include <inttypes.h>
#include <stdbool.h> #include <stdbool.h>
@ -39,10 +38,6 @@
typedef uint64_t uint64; typedef uint64_t uint64;
typedef int64_t int64; typedef int64_t int64;
#define wa_malloc bh_malloc
#define wa_free bh_free
#define wa_strdup bh_strdup
typedef aos_task_t korp_thread; typedef aos_task_t korp_thread;
typedef korp_thread *korp_tid; typedef korp_thread *korp_tid;
typedef aos_task_t *aos_tid_t; typedef aos_task_t *aos_tid_t;
@ -58,6 +53,10 @@ typedef struct korp_cond {
typedef void* (*thread_start_routine_t)(void*); typedef void* (*thread_start_routine_t)(void*);
void *os_malloc(unsigned size);
void *os_realloc(void *ptr, unsigned size);
void os_free(void *ptr);
/* Unit test framework is based on C++, where the declaration of /* Unit test framework is based on C++, where the declaration of
snprintf is different. */ snprintf is different. */
#ifndef __cplusplus #ifndef __cplusplus
@ -85,10 +84,6 @@ int snprintf(char *buffer, size_t count, const char *format, ...);
extern void bh_assert_internal(int v, const char *file_name, int line_number, const char *expr_string); extern void bh_assert_internal(int v, const char *file_name, int line_number, const char *expr_string);
#define bh_assert(expr) bh_assert_internal((int)(expr), __FILE__, __LINE__, # expr) #define bh_assert(expr) bh_assert_internal((int)(expr), __FILE__, __LINE__, # expr)
extern int b_memcpy_s(void * s1, unsigned int s1max, const void * s2, unsigned int n);
extern int b_strcat_s(char * s1, size_t s1max, const char * s2);
extern int b_strcpy_s(char * s1, size_t s1max, const char * s2);
/* math functions */ /* math functions */
double sqrt(double x); double sqrt(double x);
double floor(double x); double floor(double x);

7
core/shared/platform/alios/bh_thread.c
View File

@ -6,7 +6,6 @@
#include "bh_thread.h" #include "bh_thread.h"
#include "bh_assert.h" #include "bh_assert.h"
#include "bh_log.h" #include "bh_log.h"
#include "bh_memory.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@ -102,7 +101,7 @@ vm_thread_cleanup(void)
wait_node_sem = &thread_data->wait_node.sem; wait_node_sem = &thread_data->wait_node.sem;
/* Free thread data firstly */ /* Free thread data firstly */
bh_free(thread_data); BH_FREE(thread_data);
aos_mutex_lock(wait_list_lock, AOS_WAIT_FOREVER); aos_mutex_lock(wait_list_lock, AOS_WAIT_FOREVER);
if (thread_wait_list) { if (thread_wait_list) {
@ -152,7 +151,7 @@ _vm_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
return BHT_ERROR; return BHT_ERROR;
/* Create and initialize thread data */ /* Create and initialize thread data */
if (!(thread_data = bh_malloc(sizeof(bh_thread_data)))) if (!(thread_data = BH_MALLOC(sizeof(bh_thread_data))))
return BHT_ERROR; return BHT_ERROR;
memset(thread_data, 0, sizeof(bh_thread_data)); memset(thread_data, 0, sizeof(bh_thread_data));
@ -184,7 +183,7 @@ fail3:
fail2: fail2:
aos_sem_free(&thread_data->wait_node.sem); aos_sem_free(&thread_data->wait_node.sem);
fail1: fail1:
bh_free(thread_data); BH_FREE(thread_data);
return BHT_ERROR; return BHT_ERROR;
} }

22
core/shared/platform/android/bh_platform.c
View File

@ -18,6 +18,24 @@ bh_platform_init()
return 0; return 0;
} }
void *
os_malloc(unsigned size)
{
return malloc(size);
}
void *
os_realloc(void *ptr, unsigned size)
{
return realloc(ptr, size);
}
void
os_free(void *ptr)
{
free(ptr);
}
char* char*
bh_read_file_to_buffer(const char *filename, uint32 *ret_size) bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
{ {
@ -46,7 +64,7 @@ bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
file_size = (uint32)stat_buf.st_size; file_size = (uint32)stat_buf.st_size;
if (!(buffer = bh_malloc(file_size))) { if (!(buffer = BH_MALLOC(file_size))) {
printf("Read file to buffer failed: alloc memory failed.\n"); printf("Read file to buffer failed: alloc memory failed.\n");
close(file); close(file);
return NULL; return NULL;
@ -57,7 +75,7 @@ bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
if (read_size < file_size) { if (read_size < file_size) {
printf("Read file to buffer failed: read file content failed.\n"); printf("Read file to buffer failed: read file content failed.\n");
bh_free(buffer); BH_FREE(buffer);
return NULL; return NULL;
} }

21
core/shared/platform/android/bh_platform.h
View File

@ -8,7 +8,6 @@
#include "bh_config.h" #include "bh_config.h"
#include "bh_types.h" #include "bh_types.h"
#include "bh_memory.h"
#include <inttypes.h> #include <inttypes.h>
#include <stdbool.h> #include <stdbool.h>
#include <assert.h> #include <assert.h>
@ -36,16 +35,10 @@ extern "C" {
typedef uint64_t uint64; typedef uint64_t uint64;
typedef int64_t int64; typedef int64_t int64;
extern void DEBUGME(void);
#define DIE do{bh_debug("Die here\n\n\n\n\n\n\n\n\n\n\n\n\n\n"); DEBUGME(void); while(1);}while(0)
#ifndef BH_PLATFORM_ANDROID #ifndef BH_PLATFORM_ANDROID
#define BH_PLATFORM_ANDROID #define BH_PLATFORM_ANDROID
#endif #endif
/* NEED qsort */
#define _STACK_SIZE_ADJUSTMENT (32 * 1024) #define _STACK_SIZE_ADJUSTMENT (32 * 1024)
/* Stack size of applet threads's native part. */ /* Stack size of applet threads's native part. */
@ -67,13 +60,12 @@ typedef pthread_cond_t korp_cond;
typedef pthread_t korp_thread; typedef pthread_t korp_thread;
typedef void* (*thread_start_routine_t)(void*); typedef void* (*thread_start_routine_t)(void*);
#define wa_malloc bh_malloc void *os_malloc(unsigned size);
#define wa_free bh_free void *os_realloc(void *ptr, unsigned size);
#define wa_strdup bh_strdup void os_free(void *ptr);
#define bh_printf(...) (__android_log_print(ANDROID_LOG_INFO, "wasm_runtime::", __VA_ARGS__)) #define bh_printf(...) (__android_log_print(ANDROID_LOG_INFO, "wasm_runtime::", __VA_ARGS__))
int snprintf(char *buffer, size_t count, const char *format, ...); int snprintf(char *buffer, size_t count, const char *format, ...);
double fmod(double x, double y); double fmod(double x, double y);
float fmodf(float x, float y); float fmodf(float x, float y);
@ -99,15 +91,8 @@ double sqrt(double x);
#define bh_assert assert #define bh_assert assert
int b_memcpy_s(void * s1, unsigned int s1max, const void * s2,
unsigned int n);
int b_strcat_s(char * s1, size_t s1max, const char * s2);
int b_strcpy_s(char * s1, size_t s1max, const char * s2);
char *bh_read_file_to_buffer(const char *filename, uint32 *ret_size); char *bh_read_file_to_buffer(const char *filename, uint32 *ret_size);
char *bh_strdup(const char *s);
int bh_platform_init(); int bh_platform_init();
/* MMAP mode */ /* MMAP mode */

9
core/shared/platform/android/bh_thread.c
View File

@ -6,7 +6,6 @@
#include "bh_thread.h" #include "bh_thread.h"
#include "bh_assert.h" #include "bh_assert.h"
#include "bh_log.h" #include "bh_log.h"
#include "bh_memory.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <sys/time.h> #include <sys/time.h>
@ -67,7 +66,7 @@ static void *vm_thread_wrapper(void *arg)
targ->stack = (void *)((uintptr_t)(&arg) & (uintptr_t)~0xfff); targ->stack = (void *)((uintptr_t)(&arg) & (uintptr_t)~0xfff);
_vm_tls_put(1, targ); _vm_tls_put(1, targ);
targ->start(targ->arg); targ->start(targ->arg);
bh_free(targ); BH_FREE(targ);
_vm_tls_put(1, NULL); _vm_tls_put(1, NULL);
return NULL; return NULL;
} }
@ -94,7 +93,7 @@ int _vm_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
return BHT_ERROR; return BHT_ERROR;
} }
targ = (thread_wrapper_arg*) bh_malloc(sizeof(*targ)); targ = (thread_wrapper_arg*) BH_MALLOC(sizeof(*targ));
if (!targ) { if (!targ) {
pthread_attr_destroy(&tattr); pthread_attr_destroy(&tattr);
return BHT_ERROR; return BHT_ERROR;
@ -106,7 +105,7 @@ int _vm_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
if (pthread_create(tid, &tattr, vm_thread_wrapper, targ) != 0) { if (pthread_create(tid, &tattr, vm_thread_wrapper, targ) != 0) {
pthread_attr_destroy(&tattr); pthread_attr_destroy(&tattr);
bh_free(targ); BH_FREE(targ);
return BHT_ERROR; return BHT_ERROR;
} }
@ -128,7 +127,7 @@ korp_tid _vm_self_thread()
void vm_thread_exit(void * code) void vm_thread_exit(void * code)
{ {
bh_free(_vm_tls_get(1)); BH_FREE(_vm_tls_get(1));
_vm_tls_put(1, NULL); _vm_tls_put(1, NULL);
pthread_exit(code); pthread_exit(code);
} }

22
core/shared/platform/darwin/bh_platform.c
View File

@ -18,6 +18,24 @@ bh_platform_init()
return 0; return 0;
} }
void *
os_malloc(unsigned size)
{
return malloc(size);
}
void *
os_realloc(void *ptr, unsigned size)
{
return realloc(ptr, size);
}
void
os_free(void *ptr)
{
free(ptr);
}
char* char*
bh_read_file_to_buffer(const char *filename, uint32 *ret_size) bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
{ {
@ -46,7 +64,7 @@ bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
file_size = (uint32)stat_buf.st_size; file_size = (uint32)stat_buf.st_size;
if (!(buffer = bh_malloc(file_size))) { if (!(buffer = BH_MALLOC(file_size))) {
printf("Read file to buffer failed: alloc memory failed.\n"); printf("Read file to buffer failed: alloc memory failed.\n");
close(file); close(file);
return NULL; return NULL;
@ -57,7 +75,7 @@ bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
if (read_size < file_size) { if (read_size < file_size) {
printf("Read file to buffer failed: read file content failed.\n"); printf("Read file to buffer failed: read file content failed.\n");
bh_free(buffer); BH_FREE(buffer);
return NULL; return NULL;
} }

20
core/shared/platform/darwin/bh_platform.h
View File

@ -8,7 +8,6 @@
#include "bh_config.h" #include "bh_config.h"
#include "bh_types.h" #include "bh_types.h"
#include "bh_memory.h"
#include <inttypes.h> #include <inttypes.h>
#include <stdbool.h> #include <stdbool.h>
#include <assert.h> #include <assert.h>
@ -34,16 +33,10 @@ extern "C" {
typedef uint64_t uint64; typedef uint64_t uint64;
typedef int64_t int64; typedef int64_t int64;
extern void DEBUGME(void);
#define DIE do{bh_debug("Die here\n\n\n\n\n\n\n\n\n\n\n\n\n\n"); DEBUGME(void); while(1);}while(0)
#ifndef BH_PLATFORM_DARWIN #ifndef BH_PLATFORM_DARWIN
#define BH_PLATFORM_DARWIN #define BH_PLATFORM_DARWIN
#endif #endif
/* NEED qsort */
#define _STACK_SIZE_ADJUSTMENT (32 * 1024) #define _STACK_SIZE_ADJUSTMENT (32 * 1024)
/* Stack size of applet threads's native part. */ /* Stack size of applet threads's native part. */
@ -65,9 +58,9 @@ typedef pthread_cond_t korp_cond;
typedef pthread_t korp_thread; typedef pthread_t korp_thread;
typedef void* (*thread_start_routine_t)(void*); typedef void* (*thread_start_routine_t)(void*);
#define wa_malloc bh_malloc void *os_malloc(unsigned size);
#define wa_free bh_free void *os_realloc(void *ptr, unsigned size);
#define wa_strdup bh_strdup void os_free(void *ptr);
#define bh_printf printf #define bh_printf printf
@ -96,15 +89,8 @@ double sqrt(double x);
#define bh_assert assert #define bh_assert assert
int b_memcpy_s(void * s1, unsigned int s1max, const void * s2,
unsigned int n);
int b_strcat_s(char * s1, size_t s1max, const char * s2);
int b_strcpy_s(char * s1, size_t s1max, const char * s2);
char *bh_read_file_to_buffer(const char *filename, uint32 *ret_size); char *bh_read_file_to_buffer(const char *filename, uint32 *ret_size);
char *bh_strdup(const char *s);
int bh_platform_init(); int bh_platform_init();
/* MMAP mode */ /* MMAP mode */

9
core/shared/platform/darwin/bh_thread.c
View File

@ -6,7 +6,6 @@
#include "bh_thread.h" #include "bh_thread.h"
#include "bh_assert.h" #include "bh_assert.h"
#include "bh_log.h" #include "bh_log.h"
#include "bh_memory.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <sys/time.h> #include <sys/time.h>
@ -67,7 +66,7 @@ static void *vm_thread_wrapper(void *arg)
targ->stack = (void *)((uintptr_t)(&arg) & (uintptr_t)~0xfff); targ->stack = (void *)((uintptr_t)(&arg) & (uintptr_t)~0xfff);
_vm_tls_put(1, targ); _vm_tls_put(1, targ);
targ->start(targ->arg); targ->start(targ->arg);
bh_free(targ); BH_FREE(targ);
_vm_tls_put(1, NULL); _vm_tls_put(1, NULL);
return NULL; return NULL;
} }
@ -93,7 +92,7 @@ int _vm_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
return BHT_ERROR; return BHT_ERROR;
} }
targ = (thread_wrapper_arg*) bh_malloc(sizeof(*targ)); targ = (thread_wrapper_arg*) BH_MALLOC(sizeof(*targ));
if (!targ) { if (!targ) {
pthread_attr_destroy(&tattr); pthread_attr_destroy(&tattr);
return BHT_ERROR; return BHT_ERROR;
@ -105,7 +104,7 @@ int _vm_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
if (pthread_create(tid, &tattr, vm_thread_wrapper, targ) != 0) { if (pthread_create(tid, &tattr, vm_thread_wrapper, targ) != 0) {
pthread_attr_destroy(&tattr); pthread_attr_destroy(&tattr);
bh_free(targ); BH_FREE(targ);
return BHT_ERROR; return BHT_ERROR;
} }
@ -127,7 +126,7 @@ korp_tid _vm_self_thread()
void vm_thread_exit(void * code) void vm_thread_exit(void * code)
{ {
bh_free(_vm_tls_get(1)); BH_FREE(_vm_tls_get(1));
_vm_tls_put(1, NULL); _vm_tls_put(1, NULL);
pthread_exit(code); pthread_exit(code);
} }

33
core/shared/platform/include/bh_config.h
View File

@ -16,5 +16,38 @@
#include "config.h" #include "config.h"
#define BH_KB (1024)
#define BH_MB ((BH_KB)*1024)
#define BH_GB ((BH_MB)*1024)
#ifndef BH_MALLOC
#define BH_MALLOC os_malloc
#endif
#ifndef BH_FREE
#define BH_FREE os_free
#endif
#ifndef WA_MALLOC
#include <stdlib.h>
#define WA_MALLOC malloc
#endif
#ifndef WA_FREE
#include <stdlib.h>
#define WA_FREE free
#endif
#ifdef __cplusplus
extern "C" {
#endif
void *wasm_runtime_malloc(unsigned int size);
void wasm_runtime_free(void *ptr);
#ifdef __cplusplus
}
#endif
#endif /* end of BH_CONFIG */ #endif /* end of BH_CONFIG */

18
core/shared/platform/linux-sgx/bh_platform.c
View File

@ -19,6 +19,24 @@ int bh_platform_init()
return 0; return 0;
} }
void *
os_malloc(unsigned size)
{
return malloc(size);
}
void *
os_realloc(void *ptr, unsigned size)
{
return realloc(ptr, size);
}
void
os_free(void *ptr)
{
free(ptr);
}
int putchar(int c) int putchar(int c)
{ {
return 0; return 0;

19
core/shared/platform/linux-sgx/bh_platform.h
View File

@ -8,7 +8,6 @@
#include "bh_config.h" #include "bh_config.h"
#include "bh_types.h" #include "bh_types.h"
#include "bh_memory.h"
#include <inttypes.h> #include <inttypes.h>
#include <stdbool.h> #include <stdbool.h>
#include <assert.h> #include <assert.h>
@ -27,14 +26,15 @@
extern "C" { extern "C" {
#endif #endif
typedef void (*bh_print_function_t)(const char* message);
void bh_set_print_function(bh_print_function_t pf);
extern int bh_printf_sgx(const char *message, ...); extern int bh_printf_sgx(const char *message, ...);
extern int bh_vprintf_sgx(const char * format, va_list arg); extern int bh_vprintf_sgx(const char * format, va_list arg);
typedef uint64_t uint64; typedef uint64_t uint64;
typedef int64_t int64; typedef int64_t int64;
#define DIE do{bh_debug("Die here\n\n\n\n\n\n\n\n\n\n\n\n\n\n"); DEBUGME(void); while(1);}while(0)
#ifndef BH_PLATFORM_LINUX_SGX #ifndef BH_PLATFORM_LINUX_SGX
#define BH_PLATFORM_LINUX_SGX #define BH_PLATFORM_LINUX_SGX
#endif #endif
@ -62,9 +62,9 @@ typedef sgx_thread_t korp_tid;
typedef sgx_thread_t korp_thread; typedef sgx_thread_t korp_thread;
typedef sgx_thread_cond_t korp_cond; typedef sgx_thread_cond_t korp_cond;
#define wa_malloc bh_malloc void *os_malloc(unsigned size);
#define wa_free bh_free void *os_realloc(void *ptr, unsigned size);
#define wa_strdup bh_strdup void os_free(void *ptr);
#define bh_printf bh_printf_sgx #define bh_printf bh_printf_sgx
@ -94,13 +94,6 @@ double sqrt(double x);
#define bh_assert assert #define bh_assert assert
int b_memcpy_s(void * s1, unsigned int s1max, const void * s2,
unsigned int n);
int b_strcat_s(char * s1, size_t s1max, const char * s2);
int b_strcpy_s(char * s1, size_t s1max, const char * s2);
char *bh_strdup(const char *s);
int bh_platform_init(); int bh_platform_init();
/* MMAP mode */ /* MMAP mode */

1
core/shared/platform/linux-sgx/bh_thread.c
View File

@ -5,7 +5,6 @@
#include "bh_thread.h" #include "bh_thread.h"
#include "bh_assert.h" #include "bh_assert.h"
#include "bh_memory.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <sgx_thread.h> #include <sgx_thread.h>

22
core/shared/platform/linux/bh_platform.c
View File

@ -18,6 +18,24 @@ bh_platform_init()
return 0; return 0;
} }
void *
os_malloc(unsigned size)
{
return malloc(size);
}
void *
os_realloc(void *ptr, unsigned size)
{
return realloc(ptr, size);
}
void
os_free(void *ptr)
{
free(ptr);
}
char* char*
bh_read_file_to_buffer(const char *filename, uint32 *ret_size) bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
{ {
@ -46,7 +64,7 @@ bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
file_size = (uint32)stat_buf.st_size; file_size = (uint32)stat_buf.st_size;
if (!(buffer = bh_malloc(file_size))) { if (!(buffer = BH_MALLOC(file_size))) {
printf("Read file to buffer failed: alloc memory failed.\n"); printf("Read file to buffer failed: alloc memory failed.\n");
close(file); close(file);
return NULL; return NULL;
@ -57,7 +75,7 @@ bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
if (read_size < file_size) { if (read_size < file_size) {
printf("Read file to buffer failed: read file content failed.\n"); printf("Read file to buffer failed: read file content failed.\n");
bh_free(buffer); BH_FREE(buffer);
return NULL; return NULL;
} }

14
core/shared/platform/linux/bh_platform.h
View File

@ -8,7 +8,6 @@
#include "bh_config.h" #include "bh_config.h"
#include "bh_types.h" #include "bh_types.h"
#include "bh_memory.h"
#include <inttypes.h> #include <inttypes.h>
#include <stdbool.h> #include <stdbool.h>
#include <assert.h> #include <assert.h>
@ -66,9 +65,9 @@ typedef pthread_cond_t korp_cond;
typedef pthread_t korp_thread; typedef pthread_t korp_thread;
typedef void* (*thread_start_routine_t)(void*); typedef void* (*thread_start_routine_t)(void*);
#define wa_malloc bh_malloc void *os_malloc(unsigned size);
#define wa_free bh_free void *os_realloc(void *ptr, unsigned size);
#define wa_strdup bh_strdup void os_free(void *ptr);
#define bh_printf printf #define bh_printf printf
@ -97,15 +96,8 @@ double sqrt(double x);
#define bh_assert assert #define bh_assert assert
int b_memcpy_s(void * s1, unsigned int s1max, const void * s2,
unsigned int n);
int b_strcat_s(char * s1, size_t s1max, const char * s2);
int b_strcpy_s(char * s1, size_t s1max, const char * s2);
char *bh_read_file_to_buffer(const char *filename, uint32 *ret_size); char *bh_read_file_to_buffer(const char *filename, uint32 *ret_size);
char *bh_strdup(const char *s);
int bh_platform_init(); int bh_platform_init();
/* MMAP mode */ /* MMAP mode */

9
core/shared/platform/linux/bh_thread.c
View File

@ -6,7 +6,6 @@
#include "bh_thread.h" #include "bh_thread.h"
#include "bh_assert.h" #include "bh_assert.h"
#include "bh_log.h" #include "bh_log.h"
#include "bh_memory.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <sys/time.h> #include <sys/time.h>
@ -67,7 +66,7 @@ static void *vm_thread_wrapper(void *arg)
targ->stack = (void *)((uintptr_t)(&arg) & (uintptr_t)~0xfff); targ->stack = (void *)((uintptr_t)(&arg) & (uintptr_t)~0xfff);
_vm_tls_put(1, targ); _vm_tls_put(1, targ);
targ->start(targ->arg); targ->start(targ->arg);
bh_free(targ); BH_FREE(targ);
_vm_tls_put(1, NULL); _vm_tls_put(1, NULL);
return NULL; return NULL;
} }
@ -93,7 +92,7 @@ int _vm_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
return BHT_ERROR; return BHT_ERROR;
} }
targ = (thread_wrapper_arg*) bh_malloc(sizeof(*targ)); targ = (thread_wrapper_arg*) BH_MALLOC(sizeof(*targ));
if (!targ) { if (!targ) {
pthread_attr_destroy(&tattr); pthread_attr_destroy(&tattr);
return BHT_ERROR; return BHT_ERROR;
@ -105,7 +104,7 @@ int _vm_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
if (pthread_create(tid, &tattr, vm_thread_wrapper, targ) != 0) { if (pthread_create(tid, &tattr, vm_thread_wrapper, targ) != 0) {
pthread_attr_destroy(&tattr); pthread_attr_destroy(&tattr);
bh_free(targ); BH_FREE(targ);
return BHT_ERROR; return BHT_ERROR;
} }
@ -127,7 +126,7 @@ korp_tid _vm_self_thread()
void vm_thread_exit(void * code) void vm_thread_exit(void * code)
{ {
bh_free(_vm_tls_get(1)); BH_FREE(_vm_tls_get(1));
_vm_tls_put(1, NULL); _vm_tls_put(1, NULL);
pthread_exit(code); pthread_exit(code);
} }

22
core/shared/platform/vxworks/bh_platform.c
View File

@ -22,6 +22,24 @@ bh_platform_init()
return 0; return 0;
} }
void *
os_malloc(unsigned size)
{
return malloc(size);
}
void *
os_realloc(void *ptr, unsigned size)
{
return realloc(ptr, size);
}
void
os_free(void *ptr)
{
free(ptr);
}
char* char*
bh_read_file_to_buffer(const char *filename, uint32 *ret_size) bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
{ {
@ -50,7 +68,7 @@ bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
file_size = (uint32)stat_buf.st_size; file_size = (uint32)stat_buf.st_size;
if (!(buffer = bh_malloc(file_size))) { if (!(buffer = BH_MALLOC(file_size))) {
printf("Read file to buffer failed: alloc memory failed.\n"); printf("Read file to buffer failed: alloc memory failed.\n");
close(file); close(file);
return NULL; return NULL;
@ -61,7 +79,7 @@ bh_read_file_to_buffer(const char *filename, uint32 *ret_size)
if (read_size < file_size) { if (read_size < file_size) {
printf("Read file to buffer failed: read file content failed.\n"); printf("Read file to buffer failed: read file content failed.\n");
bh_free(buffer); BH_FREE(buffer);
return NULL; return NULL;
} }

16
core/shared/platform/vxworks/bh_platform.h
View File

@ -8,7 +8,6 @@
#include "bh_config.h" #include "bh_config.h"
#include "bh_types.h" #include "bh_types.h"
#include "bh_memory.h"
#include <inttypes.h> #include <inttypes.h>
#include <stdbool.h> #include <stdbool.h>
#include <assert.h> #include <assert.h>
@ -42,8 +41,6 @@ extern void DEBUGME(void);
#define BH_PLATFORM_VXWORKS #define BH_PLATFORM_VXWORKS
#endif #endif
/* NEED qsort */
#define _STACK_SIZE_ADJUSTMENT (32 * 1024) #define _STACK_SIZE_ADJUSTMENT (32 * 1024)
/* Stack size of applet threads's native part. */ /* Stack size of applet threads's native part. */
@ -65,9 +62,9 @@ typedef pthread_cond_t korp_cond;
typedef pthread_t korp_thread; typedef pthread_t korp_thread;
typedef void* (*thread_start_routine_t)(void*); typedef void* (*thread_start_routine_t)(void*);
#define wa_malloc bh_malloc void *os_malloc(unsigned size);
#define wa_free bh_free void *os_realloc(void *ptr, unsigned size);
#define wa_strdup bh_strdup void os_free(void *ptr);
#define bh_printf printf #define bh_printf printf
@ -96,15 +93,8 @@ double sqrt(double x);
#define bh_assert assert #define bh_assert assert
int b_memcpy_s(void * s1, unsigned int s1max, const void * s2,
unsigned int n);
int b_strcat_s(char * s1, size_t s1max, const char * s2);
int b_strcpy_s(char * s1, size_t s1max, const char * s2);
char *bh_read_file_to_buffer(const char *filename, uint32 *ret_size); char *bh_read_file_to_buffer(const char *filename, uint32 *ret_size);
char *bh_strdup(const char *s);
int bh_platform_init(); int bh_platform_init();
/* MMAP mode */ /* MMAP mode */

9
core/shared/platform/vxworks/bh_thread.c
View File

@ -6,7 +6,6 @@
#include "bh_thread.h" #include "bh_thread.h"
#include "bh_assert.h" #include "bh_assert.h"
#include "bh_log.h" #include "bh_log.h"
#include "bh_memory.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <sys/time.h> #include <sys/time.h>
@ -67,7 +66,7 @@ static void *vm_thread_wrapper(void *arg)
targ->stack = (void *)((uintptr_t)(&arg) & (uintptr_t)~0xfff); targ->stack = (void *)((uintptr_t)(&arg) & (uintptr_t)~0xfff);
_vm_tls_put(1, targ); _vm_tls_put(1, targ);
targ->start(targ->arg); targ->start(targ->arg);
bh_free(targ); BH_FREE(targ);
_vm_tls_put(1, NULL); _vm_tls_put(1, NULL);
return NULL; return NULL;
} }
@ -93,7 +92,7 @@ int _vm_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
return BHT_ERROR; return BHT_ERROR;
} }
targ = (thread_wrapper_arg*) bh_malloc(sizeof(*targ)); targ = (thread_wrapper_arg*) BH_MALLOC(sizeof(*targ));
if (!targ) { if (!targ) {
pthread_attr_destroy(&tattr); pthread_attr_destroy(&tattr);
return BHT_ERROR; return BHT_ERROR;
@ -105,7 +104,7 @@ int _vm_thread_create_with_prio(korp_tid *tid, thread_start_routine_t start,
if (pthread_create(tid, &tattr, vm_thread_wrapper, targ) != 0) { if (pthread_create(tid, &tattr, vm_thread_wrapper, targ) != 0) {
pthread_attr_destroy(&tattr); pthread_attr_destroy(&tattr);
bh_free(targ); BH_FREE(targ);
return BHT_ERROR; return BHT_ERROR;
} }
@ -127,7 +126,7 @@ korp_tid _vm_self_thread()
void vm_thread_exit(void * code) void vm_thread_exit(void * code)
{ {
bh_free(_vm_tls_get(1)); BH_FREE(_vm_tls_get(1));
_vm_tls_put(1, NULL); _vm_tls_put(1, NULL);
pthread_exit(code); pthread_exit(code);
} }

4
core/shared/platform/zephyr/Makefile
View File

@ -1,4 +0,0 @@
# Copyright (C) 2019 Intel Corporation. All rights reserved.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
obj-y += bh_assert.o bh_definition.o bh_memory.o bh_platform_log.o bh_thread.o bh_time.o

22
core/shared/platform/zephyr/bh_platform.c
View File

@ -4,7 +4,6 @@
*/ */
#include "bh_platform.h" #include "bh_platform.h"
#include "bh_memory.h"
#include "bh_common.h" #include "bh_common.h"
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -58,16 +57,33 @@ bh_platform_init()
return 0; return 0;
} }
void *
os_malloc(unsigned size)
{
return NULL;
}
void *
os_realloc(void *ptr, unsigned size)
{
return NULL;
}
void
os_free(void *ptr)
{
}
void * void *
bh_mmap(void *hint, unsigned int size, int prot, int flags) bh_mmap(void *hint, unsigned int size, int prot, int flags)
{ {
return bh_malloc(size); return BH_MALLOC(size);
} }
void void
bh_munmap(void *addr, uint32 size) bh_munmap(void *addr, uint32 size)
{ {
return bh_free(addr); return BH_FREE(addr);
} }
int int

15
core/shared/platform/zephyr/bh_platform.h
View File

@ -8,7 +8,6 @@
#include "bh_config.h" #include "bh_config.h"
#include "bh_types.h" #include "bh_types.h"
#include "bh_memory.h"
#include <autoconf.h> #include <autoconf.h>
#include <zephyr.h> #include <zephyr.h>
#include <kernel.h> #include <kernel.h>
@ -55,10 +54,6 @@ typedef korp_thread *korp_tid;
typedef struct k_mutex korp_mutex; typedef struct k_mutex korp_mutex;
typedef struct k_sem korp_sem; typedef struct k_sem korp_sem;
#define wa_malloc bh_malloc
#define wa_free bh_free
#define wa_strdup bh_strdup
struct bh_thread_wait_node; struct bh_thread_wait_node;
typedef struct bh_thread_wait_node *bh_thread_wait_list; typedef struct bh_thread_wait_node *bh_thread_wait_list;
typedef struct korp_cond { typedef struct korp_cond {
@ -68,8 +63,9 @@ typedef struct korp_cond {
typedef void* (*thread_start_routine_t)(void*); typedef void* (*thread_start_routine_t)(void*);
#define wa_malloc bh_malloc void *os_malloc(unsigned size);
#define wa_free bh_free void *os_realloc(void *ptr, unsigned size);
void os_free(void *ptr);
#define bh_printf printf #define bh_printf printf
@ -102,11 +98,6 @@ int snprintf(char *buffer, size_t count, const char *format, ...);
} \ } \
} while (0) } while (0)
int b_memcpy_s(void * s1, unsigned int s1max, const void * s2,
unsigned int n);
int b_strcat_s(char * s1, size_t s1max, const char * s2);
int b_strcpy_s(char * s1, size_t s1max, const char * s2);
/* math functions */ /* math functions */
double sqrt(double x); double sqrt(double x);
double floor(double x); double floor(double x);

27
core/shared/platform/zephyr/bh_thread.c
View File

@ -6,9 +6,6 @@
#include "bh_thread.h" #include "bh_thread.h"
#include "bh_assert.h" #include "bh_assert.h"
#include "bh_log.h" #include "bh_log.h"
#include "bh_memory.h"
#include <stdio.h>
#include <stdlib.h>
typedef struct bh_thread_wait_node { typedef struct bh_thread_wait_node {
struct k_sem sem; struct k_sem sem;
@ -140,11 +137,11 @@ static void thread_obj_list_reclaim()
if (p->to_be_freed) { if (p->to_be_freed) {
if (p_prev == NULL) { /* p is the head of list */ if (p_prev == NULL) { /* p is the head of list */
thread_obj_list = p->next; thread_obj_list = p->next;
bh_free(p); BH_FREE(p);
p = thread_obj_list; p = thread_obj_list;
} else { /* p is not the head of list */ } else { /* p is not the head of list */
p_prev->next = p->next; p_prev->next = p->next;
bh_free(p); BH_FREE(p);
p = p_prev->next; p = p_prev->next;
} }
} else { } else {
@ -210,7 +207,7 @@ static void vm_thread_cleanup(void)
/* Set flag to true for the next thread creating to /* Set flag to true for the next thread creating to
free the thread object */ free the thread object */
((bh_thread_obj*) thread_data->tid)->to_be_freed = true; ((bh_thread_obj*) thread_data->tid)->to_be_freed = true;
bh_free(thread_data); BH_FREE(thread_data);
} }
static void vm_thread_wrapper(void *start, void *arg, void *thread_data) static void vm_thread_wrapper(void *start, void *arg, void *thread_data)
@ -244,15 +241,15 @@ int _vm_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
thread_obj_list_reclaim(); thread_obj_list_reclaim();
/* Create and initialize thread object */ /* Create and initialize thread object */
if (!(tid = bh_malloc(sizeof(bh_thread_obj)))) if (!(tid = BH_MALLOC(sizeof(bh_thread_obj))))
return BHT_ERROR; return BHT_ERROR;
memset(tid, 0, sizeof(bh_thread_obj)); memset(tid, 0, sizeof(bh_thread_obj));
/* Create and initialize thread data */ /* Create and initialize thread data */
thread_data_size = offsetof(bh_thread_data, stack) + stack_size; thread_data_size = offsetof(bh_thread_data, stack) + stack_size;
if (!(thread_data = bh_malloc(thread_data_size))) { if (!(thread_data = BH_MALLOC(thread_data_size))) {
bh_free(tid); BH_FREE(tid);
return BHT_ERROR; return BHT_ERROR;
} }
@ -265,8 +262,8 @@ int _vm_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
if (!((tid = k_thread_create(tid, (k_thread_stack_t *) thread_data->stack, if (!((tid = k_thread_create(tid, (k_thread_stack_t *) thread_data->stack,
stack_size, vm_thread_wrapper, start, arg, thread_data, prio, 0, stack_size, vm_thread_wrapper, start, arg, thread_data, prio, 0,
K_NO_WAIT)))) { K_NO_WAIT)))) {
bh_free(tid); BH_FREE(tid);
bh_free(thread_data); BH_FREE(thread_data);
return BHT_ERROR; return BHT_ERROR;
} }
@ -305,7 +302,7 @@ int _vm_thread_join(korp_tid thread, void **value_ptr, int mills)
bh_thread_wait_node *node; bh_thread_wait_node *node;
/* Create wait node and append it to wait list */ /* Create wait node and append it to wait list */
if (!(node = bh_malloc(sizeof(bh_thread_wait_node)))) if (!(node = BH_MALLOC(sizeof(bh_thread_wait_node))))
return BHT_ERROR; return BHT_ERROR;
k_sem_init(&node->sem, 0, 1); k_sem_init(&node->sem, 0, 1);
@ -334,7 +331,7 @@ int _vm_thread_join(korp_tid thread, void **value_ptr, int mills)
k_sleep(100); k_sleep(100);
/* Destroy resource */ /* Destroy resource */
bh_free(node); BH_FREE(node);
return BHT_OK; return BHT_OK;
} }
@ -449,7 +446,7 @@ static int _vm_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
bh_thread_wait_node *node; bh_thread_wait_node *node;
/* Create wait node and append it to wait list */ /* Create wait node and append it to wait list */
if (!(node = bh_malloc(sizeof(bh_thread_wait_node)))) if (!(node = BH_MALLOC(sizeof(bh_thread_wait_node))))
return BHT_ERROR; return BHT_ERROR;
k_sem_init(&node->sem, 0, 1); k_sem_init(&node->sem, 0, 1);
@ -483,7 +480,7 @@ static int _vm_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
p = p->next; p = p->next;
p->next = node->next; p->next = node->next;
} }
bh_free(node); BH_FREE(node);
k_mutex_unlock(&cond->wait_list_lock); k_mutex_unlock(&cond->wait_list_lock);
return BHT_OK; return BHT_OK;

16
core/shared/utils/bh_definition.c
View File

@ -67,7 +67,21 @@ bh_strdup(const char *s)
if (s) { if (s) {
size = (uint32)(strlen(s) + 1); size = (uint32)(strlen(s) + 1);
if ((s1 = bh_malloc(size))) if ((s1 = BH_MALLOC(size)))
bh_memcpy_s(s1, size, s, size);
}
return s1;
}
char *
wa_strdup(const char *s)
{
uint32 size;
char *s1 = NULL;
if (s) {
size = (uint32)(strlen(s) + 1);
if ((s1 = WA_MALLOC(size)))
bh_memcpy_s(s1, size, s, size); bh_memcpy_s(s1, size, s, size);
} }
return s1; return s1;

13
core/shared/utils/bh_hashmap.c
View File

@ -6,7 +6,6 @@
#include "bh_hashmap.h" #include "bh_hashmap.h"
#include "bh_log.h" #include "bh_log.h"
#include "bh_thread.h" #include "bh_thread.h"
#include "bh_memory.h"
typedef struct HashMapElem { typedef struct HashMapElem {
@ -55,7 +54,7 @@ bh_hash_map_create(uint32 size, bool use_lock,
(use_lock ? sizeof(korp_mutex) : 0); (use_lock ? sizeof(korp_mutex) : 0);
if (total_size >= UINT32_MAX if (total_size >= UINT32_MAX
|| !(map = bh_malloc((uint32)total_size))) { || !(map = BH_MALLOC((uint32)total_size))) {
LOG_ERROR("HashMap create failed: alloc memory failed.\n"); LOG_ERROR("HashMap create failed: alloc memory failed.\n");
return NULL; return NULL;
} }
@ -68,7 +67,7 @@ bh_hash_map_create(uint32 size, bool use_lock,
+ sizeof(HashMapElem) * size); + sizeof(HashMapElem) * size);
if (vm_mutex_init(map->lock)) { if (vm_mutex_init(map->lock)) {
LOG_ERROR("HashMap create failed: init map lock failed.\n"); LOG_ERROR("HashMap create failed: init map lock failed.\n");
bh_free(map); BH_FREE(map);
return NULL; return NULL;
} }
} }
@ -106,7 +105,7 @@ bh_hash_map_insert(HashMap *map, void *key, void *value)
elem = elem->next; elem = elem->next;
} }
if (!(elem = bh_malloc(sizeof(HashMapElem)))) { if (!(elem = BH_MALLOC(sizeof(HashMapElem)))) {
LOG_ERROR("HashMap insert elem failed: alloc memory failed.\n"); LOG_ERROR("HashMap insert elem failed: alloc memory failed.\n");
goto fail; goto fail;
} }
@ -233,7 +232,7 @@ bh_hash_map_remove(HashMap *map, void *key,
else else
prev->next = elem->next; prev->next = elem->next;
bh_free(elem); BH_FREE(elem);
if (map->lock) { if (map->lock) {
vm_mutex_unlock(map->lock); vm_mutex_unlock(map->lock);
@ -277,7 +276,7 @@ bh_hash_map_destroy(HashMap *map)
if (map->value_destroy_func) { if (map->value_destroy_func) {
map->value_destroy_func(elem->value); map->value_destroy_func(elem->value);
} }
bh_free(elem); BH_FREE(elem);
elem = next; elem = next;
} }
@ -287,6 +286,6 @@ bh_hash_map_destroy(HashMap *map)
vm_mutex_unlock(map->lock); vm_mutex_unlock(map->lock);
vm_mutex_destroy(map->lock); vm_mutex_destroy(map->lock);
} }
bh_free(map); BH_FREE(map);
return true; return true;
} }

3
core/shared/utils/bh_queue.c
View File

@ -5,7 +5,6 @@
#include "bh_queue.h" #include "bh_queue.h"
#include "bh_thread.h" #include "bh_thread.h"
#include "bh_memory.h"
#include "bh_time.h" #include "bh_time.h"
#include "bh_common.h" #include "bh_common.h"
@ -131,7 +130,7 @@ bool bh_post_msg(bh_queue *queue, unsigned short tag, void *body,
if (msg == NULL) { if (msg == NULL) {
queue->drops++; queue->drops++;
if (len != 0 && body) if (len != 0 && body)
bh_free(body); BH_FREE(body);
return false; return false;
} }

7
core/shared/utils/bh_vector.c
View File

@ -5,7 +5,6 @@
#include "bh_log.h" #include "bh_log.h"
#include "bh_vector.h" #include "bh_vector.h"
#include "bh_memory.h"
static uint8* static uint8*
@ -18,7 +17,7 @@ alloc_vector_data(uint32 length, uint32 size_elem)
return NULL; return NULL;
} }
if ((data = bh_malloc((uint32)total_size))) { if ((data = BH_MALLOC((uint32)total_size))) {
memset(data, 0, (uint32)total_size); memset(data, 0, (uint32)total_size);
} }
@ -41,7 +40,7 @@ extend_vector(Vector *vector, uint32 length)
} }
memcpy(data, vector->data, vector->size_elem * vector->max_elements); memcpy(data, vector->data, vector->size_elem * vector->max_elements);
bh_free(vector->data); BH_FREE(vector->data);
vector->data = data; vector->data = data;
vector->max_elements = length; vector->max_elements = length;
return true; return true;
@ -200,7 +199,7 @@ bh_vector_destroy(Vector *vector)
} }
if (vector->data) if (vector->data)
bh_free(vector->data); BH_FREE(vector->data);
memset(vector, 0, sizeof(Vector)); memset(vector, 0, sizeof(Vector));
return true; return true;
} }

16
core/shared/utils/runtime_timer.c
View File

@ -172,7 +172,7 @@ static void release_timer(timer_ctx_t ctx, app_timer_t * t)
vm_mutex_unlock(&ctx->mutex); vm_mutex_unlock(&ctx->mutex);
} else { } else {
PRINT("destroy timer :%d\n", t->id); PRINT("destroy timer :%d\n", t->id);
bh_free(t); BH_FREE(t);
} }
} }
@ -182,7 +182,7 @@ void release_timer_list(app_timer_t ** p_list)
while (t) { while (t) {
app_timer_t *next = t->next; app_timer_t *next = t->next;
PRINT("destroy timer list:%d\n", t->id); PRINT("destroy timer list:%d\n", t->id);
bh_free(t); BH_FREE(t);
t = next; t = next;
} }
@ -199,7 +199,7 @@ timer_ctx_t create_timer_ctx(timer_callback_f timer_handler,
check_timer_expiry_f expiery_checker, int prealloc_num, check_timer_expiry_f expiery_checker, int prealloc_num,
unsigned int owner) unsigned int owner)
{ {
timer_ctx_t ctx = (timer_ctx_t) bh_malloc(sizeof(struct _timer_ctx)); timer_ctx_t ctx = (timer_ctx_t) BH_MALLOC(sizeof(struct _timer_ctx));
if (ctx == NULL) if (ctx == NULL)
return NULL; return NULL;
memset(ctx, 0, sizeof(struct _timer_ctx)); memset(ctx, 0, sizeof(struct _timer_ctx));
@ -210,7 +210,7 @@ timer_ctx_t create_timer_ctx(timer_callback_f timer_handler,
ctx->owner = owner; ctx->owner = owner;
while (prealloc_num > 0) { while (prealloc_num > 0) {
app_timer_t *timer = (app_timer_t*) bh_malloc(sizeof(app_timer_t)); app_timer_t *timer = (app_timer_t*) BH_MALLOC(sizeof(app_timer_t));
if (timer == NULL) if (timer == NULL)
goto cleanup; goto cleanup;
@ -231,7 +231,7 @@ timer_ctx_t create_timer_ctx(timer_callback_f timer_handler,
if (ctx) { if (ctx) {
release_timer_list(&ctx->free_timers); release_timer_list(&ctx->free_timers);
bh_free(ctx); BH_FREE(ctx);
} }
PRINT("timer ctx create failed\n"); PRINT("timer ctx create failed\n");
return NULL; return NULL;
@ -242,14 +242,14 @@ void destroy_timer_ctx(timer_ctx_t ctx)
while (ctx->free_timers) { while (ctx->free_timers) {
void * tmp = ctx->free_timers; void * tmp = ctx->free_timers;
ctx->free_timers = ctx->free_timers->next; ctx->free_timers = ctx->free_timers->next;
bh_free(tmp); BH_FREE(tmp);
} }
cleanup_app_timers(ctx); cleanup_app_timers(ctx);
vm_cond_destroy(&ctx->cond); vm_cond_destroy(&ctx->cond);
vm_mutex_destroy(&ctx->mutex); vm_mutex_destroy(&ctx->mutex);
bh_free(ctx); BH_FREE(ctx);
} }
unsigned int timer_ctx_get_owner(timer_ctx_t ctx) unsigned int timer_ctx_get_owner(timer_ctx_t ctx)
@ -279,7 +279,7 @@ uint32 sys_create_timer(timer_ctx_t ctx, int interval, bool is_period,
ctx->free_timers = timer->next; ctx->free_timers = timer->next;
} }
} else { } else {
timer = (app_timer_t*) bh_malloc(sizeof(app_timer_t)); timer = (app_timer_t*) BH_MALLOC(sizeof(app_timer_t));
if (timer == NULL) if (timer == NULL)
return (uint32)-1; return (uint32)-1;
} }

58
doc/embed_wamr.md
View File

@ -4,13 +4,11 @@ Embedding WAMR guideline
**Note**: All the embedding APIs supported by the runtime are defined under folder [core/iwasm/include](../core/iwasm/include). The API details are available in the header files. **Note**: All the embedding APIs supported by the runtime are defined under folder [core/iwasm/include](../core/iwasm/include). The API details are available in the header files.
## The initialization procedure ## The runtime initialization
``` C ``` C
static char global_heap_buf[512 * 1024];
char *buffer, error_buf[128]; char *buffer, error_buf[128];
wasm_module_t module; wasm_module_t module;
wasm_module_inst_t module_inst; wasm_module_inst_t module_inst;
@ -18,14 +16,15 @@ Embedding WAMR guideline
wasm_exec_env_t exec_env; wasm_exec_env_t exec_env;
uint32 size, stack_size = 8092, heap_size = 8092; uint32 size, stack_size = 8092, heap_size = 8092;
// all the WAMR heap and WASM applications are limited in this buffer // initialize the wasm runtime by default configurations
bh_memory_init_with_pool(global_heap_buf, sizeof(global_heap_buf));
wasm_runtime_init(); wasm_runtime_init();
// read WASM file into a memory buffer // read WASM file into a memory buffer
buffer = read_wasm_binary_to_buffer(…, &size); buffer = read_wasm_binary_to_buffer(…, &size);
// Add it below if runtime needs to export native functions to WASM APP
// wasm_runtime_register_natives(...)
// parse the WASM file from buffer and create a WASM module // parse the WASM file from buffer and create a WASM module
module = wasm_runtime_load(buffer, size, error_buf, sizeof(error_buf)); module = wasm_runtime_load(buffer, size, error_buf, sizeof(error_buf));
@ -37,9 +36,43 @@ Embedding WAMR guideline
sizeof(error_buf)); sizeof(error_buf));
``` ```
The `wasm_runtime_init()` will use the default memory allocator from the [`core/shared/platform`](../core/shared/platform) for the runtime memory management.
The WAMR supports to restrict its all memory allocations in a raw buffer. It ensures the dynamics by the WASM applications won't harm the system availability, which is extremely important for embedded systems. This can be done by using `wasm_runtime_full_init()`. This function also allows you to configure the native APIs for exporting to WASM app.
Refer to the following sample:
```c
// the native functions that will be exported to WASM app
static NativeSymbol native_symbols[] = {
EXPORT_WASM_API_WITH_SIG(display_input_read, "(*)i"),
EXPORT_WASM_API_WITH_SIG(display_flush, "(iiii*)")
};
// all the runtime memory allocations are retricted in the global_heap_buf array
static char global_heap_buf[512 * 1024];
RuntimeInitArgs init_args;
memset(&init_args, 0, sizeof(RuntimeInitArgs));
// configure the memory allocator for the runtime
init_args.mem_alloc_type = Alloc_With_Pool;
init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
// configure the native functions being exported to WASM app
init_args.native_module_name = "env";
init_args.n_native_symbols = sizeof(native_symbols) / sizeof(NativeSymbol);
init_args.native_symbols = native_symbols;
/* initialize runtime environment with user configurations*/
if (!wasm_runtime_full_init(&init_args)) {
return -1;
}
```
## Native calls WASM functions and passes parameters ## Native calls WASM functions and passes parameters
@ -48,7 +81,8 @@ After a module is instantiated, the runtime native can lookup WASM functions by
```c ```c
unit32 argv[2]; unit32 argv[2];
// lookup a WASM function by its name // lookup a WASM function by its name.
// The function signature can NULL here
func = wasm_runtime_lookup_function(module_inst, "fib", NULL); func = wasm_runtime_lookup_function(module_inst, "fib", NULL);
// creat a excution environment which can be used by executing WASM functions // creat a excution environment which can be used by executing WASM functions
@ -137,6 +171,10 @@ int32
wasm_runtime_module_dup_data(WASMModuleInstanceCommon *module_inst, wasm_runtime_module_dup_data(WASMModuleInstanceCommon *module_inst,
const char *src, const char *src,
uint32 size); uint32 size);
// free the memory allocated from module memory space
void
wasm_runtime_module_free(wasm_module_inst_t module_inst, int32_t ptr);
``` ```
@ -155,6 +193,10 @@ if(buffer_for_wasm != 0)
argv[0] = buffer_for_wasm; // pass the buffer address for WASM space. argv[0] = buffer_for_wasm; // pass the buffer address for WASM space.
argv[1] = 100; // the size of buffer argv[1] = 100; // the size of buffer
wasm_runtime_call_wasm(exec_env, func, 2, argv); wasm_runtime_call_wasm(exec_env, func, 2, argv);
// it is runtime responsibility to release the memory,
// unless the WASM app will free the passed pointer in its code
wasm_runtime_module_free(module_inst, buffer);
} }
``` ```
@ -174,7 +216,7 @@ We can't pass structure data or class objects through the pointer since the memo
wasm_runtime_deinstantiate(module_inst); wasm_runtime_deinstantiate(module_inst);
wasm_runtime_unload(module); wasm_runtime_unload(module);
wasm_runtime_destroy(); wasm_runtime_destroy();
bh_memory_destroy();
``` ```

5
product-mini/platforms/alios-things/aos.mk
View File

@ -5,6 +5,9 @@ NAME := iwasm
IWASM_ROOT := wamr/core/iwasm IWASM_ROOT := wamr/core/iwasm
SHARED_ROOT := wamr/core/shared SHARED_ROOT := wamr/core/shared
GLOBAL_DEFINES += BH_MALLOC=wasm_runtime_malloc
GLOBAL_DEFINES += BH_FREE=wasm_runtime_free
# Change it to THUMBV7M if you want to build for developerkit # Change it to THUMBV7M if you want to build for developerkit
WAMR_BUILD_TARGET := X86_32 WAMR_BUILD_TARGET := X86_32
@ -76,7 +79,6 @@ $(NAME)_SOURCES := ${SHARED_ROOT}/platform/alios/bh_assert.c \
${SHARED_ROOT}/platform/alios/bh_platform_log.c \ ${SHARED_ROOT}/platform/alios/bh_platform_log.c \
${SHARED_ROOT}/platform/alios/bh_thread.c \ ${SHARED_ROOT}/platform/alios/bh_thread.c \
${SHARED_ROOT}/platform/alios/bh_time.c \ ${SHARED_ROOT}/platform/alios/bh_time.c \
${SHARED_ROOT}/mem-alloc/bh_memory.c \
${SHARED_ROOT}/mem-alloc/mem_alloc.c \ ${SHARED_ROOT}/mem-alloc/mem_alloc.c \
${SHARED_ROOT}/mem-alloc/ems/ems_kfc.c \ ${SHARED_ROOT}/mem-alloc/ems/ems_kfc.c \
${SHARED_ROOT}/mem-alloc/ems/ems_alloc.c \ ${SHARED_ROOT}/mem-alloc/ems/ems_alloc.c \
@ -91,6 +93,7 @@ $(NAME)_SOURCES := ${SHARED_ROOT}/platform/alios/bh_assert.c \
${IWASM_ROOT}/common/wasm_runtime_common.c \ ${IWASM_ROOT}/common/wasm_runtime_common.c \
${IWASM_ROOT}/common/wasm_native.c \ ${IWASM_ROOT}/common/wasm_native.c \
${IWASM_ROOT}/common/wasm_exec_env.c \ ${IWASM_ROOT}/common/wasm_exec_env.c \
${IWASM_ROOT}/common/wasm_memory.c \
${IWASM_ROOT}/common/arch/${INVOKE_NATIVE} \ ${IWASM_ROOT}/common/arch/${INVOKE_NATIVE} \
src/main.c src/main.c

35
product-mini/platforms/alios-things/src/main.c
View File

@ -9,7 +9,6 @@
#include "bh_log.h" #include "bh_log.h"
#include "bh_platform_log.h" #include "bh_platform_log.h"
#include "wasm_export.h" #include "wasm_export.h"
#include "bh_memory.h"
#include "test_wasm.h" #include "test_wasm.h"
static int app_argc; static int app_argc;
@ -48,6 +47,7 @@ void iwasm_main(void *arg1)
uint32 wasm_file_size; uint32 wasm_file_size;
wasm_module_t wasm_module = NULL; wasm_module_t wasm_module = NULL;
wasm_module_inst_t wasm_module_inst = NULL; wasm_module_inst_t wasm_module_inst = NULL;
RuntimeInitArgs init_args;
char error_buf[128]; char error_buf[128];
#if WASM_ENABLE_LOG != 0 #if WASM_ENABLE_LOG != 0
int log_verbose_level = 2; int log_verbose_level = 2;
@ -55,15 +55,17 @@ void iwasm_main(void *arg1)
(void) arg1; (void) arg1;
if (bh_memory_init_with_pool(global_heap_buf, sizeof(global_heap_buf)) memset(&init_args, 0, sizeof(RuntimeInitArgs));
!= 0) {
bh_printf("Init global heap failed.\n"); init_args.mem_alloc_type = Alloc_With_Pool;
return; init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
} init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
/* initialize runtime environment */ /* initialize runtime environment */
if (!wasm_runtime_init()) if (!wasm_runtime_full_init(&init_args)) {
goto fail1; bh_printf("Init runtime environment failed.\n");
return;
}
#if WASM_ENABLE_LOG != 0 #if WASM_ENABLE_LOG != 0
bh_log_set_verbose_level(log_verbose_level); bh_log_set_verbose_level(log_verbose_level);
@ -77,14 +79,17 @@ void iwasm_main(void *arg1)
if (!(wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size, if (!(wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size,
error_buf, sizeof(error_buf)))) { error_buf, sizeof(error_buf)))) {
bh_printf("%s\n", error_buf); bh_printf("%s\n", error_buf);
goto fail2; goto fail1;
} }
/* instantiate the module */ /* instantiate the module */
if (!(wasm_module_inst = wasm_runtime_instantiate(wasm_module, 8 * 1024, if (!(wasm_module_inst = wasm_runtime_instantiate(wasm_module,
8 * 1024, error_buf, sizeof(error_buf)))) { 8 * 1024,
8 * 1024,
error_buf,
sizeof(error_buf)))) {
bh_printf("%s\n", error_buf); bh_printf("%s\n", error_buf);
goto fail3; goto fail2;
} }
app_instance_main(wasm_module_inst); app_instance_main(wasm_module_inst);
@ -92,15 +97,13 @@ void iwasm_main(void *arg1)
/* destroy the module instance */ /* destroy the module instance */
wasm_runtime_deinstantiate(wasm_module_inst); wasm_runtime_deinstantiate(wasm_module_inst);
fail3: fail2:
/* unload the module */ /* unload the module */
wasm_runtime_unload(wasm_module); wasm_runtime_unload(wasm_module);
fail2: fail1:
/* destroy runtime environment */ /* destroy runtime environment */
wasm_runtime_destroy(); wasm_runtime_destroy();
fail1: bh_memory_destroy();
} }
#define DEFAULT_THREAD_STACKSIZE (6 * 1024) #define DEFAULT_THREAD_STACKSIZE (6 * 1024)

45
product-mini/platforms/android/wasm-jni.cpp
View File

@ -75,27 +75,25 @@ static unsigned char wasm_test_file[] = { 0x00, 0x61, 0x73, 0x6D, 0x01, 0x00, 0x
extern "C" JNIEXPORT void JNICALL extern "C" JNIEXPORT void JNICALL
Java_com_intel_wasm_api_Runtime_run(JNIEnv *env, jclass thiz) { Java_com_intel_wasm_api_Runtime_run(JNIEnv *env, jclass thiz) {
char error_buf[128] = {0};
void *(*malloc_func)(size_t) = &malloc;
void (*free_func)(void *) = &free;
LOGI("bh_memory_init_with_allocator");
if (bh_memory_init_with_allocator((void *) malloc_func, (void *) free_func)) {
LOGI("Init memory with memory allocator failed.\n");
return;
}
wasm_module_t wasm_module = NULL; wasm_module_t wasm_module = NULL;
wasm_module_inst_t wasm_module_inst = NULL; wasm_module_inst_t wasm_module_inst = NULL;
RuntimeInitArgs init_args;
uint wasm_file_size = 0; uint wasm_file_size = 0;
uint8_t *wasm_file_buf = NULL; uint8_t *wasm_file_buf = NULL;
char error_buf[128] = {0};
memset(&init_args, 0, sizeof(RuntimeInitArgs));
init_args.mem_alloc_type = Alloc_With_Allocator;
init_args.mem_alloc_option.allocator.malloc_func = (void*)malloc;
init_args.mem_alloc_option.allocator.realloc_func = (void*)realloc;
init_args.mem_alloc_option.allocator.free_func = (void*)free;
LOGI("wasm_runtime_full_init");
/* initialize runtime environment */ /* initialize runtime environment */
LOGI("wasm_runtime_init"); if (!wasm_runtime_full_init(&init_args)) {
if (!wasm_runtime_init()) { LOGI("Init runtime failed.\n");
LOGI("goto fail1\n"); return;
goto fail1;
} }
// set log level to INFO // set log level to INFO
@ -112,8 +110,8 @@ Java_com_intel_wasm_api_Runtime_run(JNIEnv *env, jclass thiz) {
if (!(wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size, if (!(wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size,
error_buf, sizeof(error_buf)))) { error_buf, sizeof(error_buf)))) {
LOGI("in wasm_runtime_load %s\n", error_buf); LOGI("in wasm_runtime_load %s\n", error_buf);
LOGI("goto fail3\n"); LOGI("goto fail1\n");
goto fail3; goto fail1;
} }
/* instantiate the module */ /* instantiate the module */
@ -124,8 +122,8 @@ Java_com_intel_wasm_api_Runtime_run(JNIEnv *env, jclass thiz) {
error_buf, error_buf,
sizeof(error_buf)))) { sizeof(error_buf)))) {
LOGI("%s\n", error_buf); LOGI("%s\n", error_buf);
LOGI("goto fail4\n"); LOGI("goto fail2\n");
goto fail4; goto fail2;
} }
LOGI("run main() of the application"); LOGI("run main() of the application");
@ -135,23 +133,18 @@ Java_com_intel_wasm_api_Runtime_run(JNIEnv *env, jclass thiz) {
LOGI("wasm_runtime_deinstantiate"); LOGI("wasm_runtime_deinstantiate");
wasm_runtime_deinstantiate(wasm_module_inst); wasm_runtime_deinstantiate(wasm_module_inst);
fail4: fail2:
/* unload the module */ /* unload the module */
LOGI("wasm_runtime_unload"); LOGI("wasm_runtime_unload");
wasm_runtime_unload(wasm_module); wasm_runtime_unload(wasm_module);
fail3: fail1:
// in our case, we don't need a free, but it is not a typical one // in our case, we don't need a free, but it is not a typical one
/* free the file buffer */ /* free the file buffer */
//bh_free((void *) wasm_file_buf); //bh_free((void *) wasm_file_buf);
fail2:
/* destroy runtime environment */ /* destroy runtime environment */
LOGI("wasm_runtime_destroy"); LOGI("wasm_runtime_destroy");
wasm_runtime_destroy(); wasm_runtime_destroy();
fail1:
LOGI("bh_memory_destroy");
bh_memory_destroy();
return; return;
} }

64
product-mini/platforms/darwin/main.c
View File

@ -11,7 +11,6 @@
#include "bh_platform.h" #include "bh_platform.h"
#include "bh_assert.h" #include "bh_assert.h"
#include "bh_log.h" #include "bh_log.h"
#include "bh_memory.h"
#include "wasm_export.h" #include "wasm_export.h"
static int app_argc; static int app_argc;
@ -24,9 +23,11 @@ static int print_help()
bh_printf(" -f|--function name Specify function name to run in module\n" bh_printf(" -f|--function name Specify function name to run in module\n"
" rather than main\n"); " rather than main\n");
#if WASM_ENABLE_LOG != 0 #if WASM_ENABLE_LOG != 0
bh_printf(" -v=X Set log verbose level (0 to 5, default is 2),\n" bh_printf(" -v=n Set log verbose level (0 to 5, default is 2),\n"
" larger level with more log\n"); " larger level with more log\n");
#endif #endif
bh_printf(" --stack-size=n Set maximum stack size in bytes, default is 16 KB\n");
bh_printf(" --heap-size=n Set maximum heap size in bytes, default is 16 KB\n");
bh_printf(" --repl Start a very simple REPL (read-eval-print-loop) mode\n" bh_printf(" --repl Start a very simple REPL (read-eval-print-loop) mode\n"
" that runs commands in the form of `FUNC ARG...`\n"); " that runs commands in the form of `FUNC ARG...`\n");
#if WASM_ENABLE_LIBC_WASI != 0 #if WASM_ENABLE_LIBC_WASI != 0
@ -153,8 +154,10 @@ int main(int argc, char *argv[])
const char *func_name = NULL; const char *func_name = NULL;
uint8 *wasm_file_buf = NULL; uint8 *wasm_file_buf = NULL;
uint32 wasm_file_size; uint32 wasm_file_size;
uint32 stack_size = 16 * 1024, heap_size = 16 * 1024;
wasm_module_t wasm_module = NULL; wasm_module_t wasm_module = NULL;
wasm_module_inst_t wasm_module_inst = NULL; wasm_module_inst_t wasm_module_inst = NULL;
RuntimeInitArgs init_args;
char error_buf[128] = { 0 }; char error_buf[128] = { 0 };
#if WASM_ENABLE_LOG != 0 #if WASM_ENABLE_LOG != 0
int log_verbose_level = 2; int log_verbose_level = 2;
@ -186,6 +189,16 @@ int main(int argc, char *argv[])
#endif #endif
else if (!strcmp(argv[0], "--repl")) else if (!strcmp(argv[0], "--repl"))
is_repl_mode = true; is_repl_mode = true;
else if (!strncmp(argv[0], "--stack-size=", 13)) {
if (argv[0][13] == '\0')
return print_help();
stack_size = atoi(argv[0] + 13);
}
else if (!strncmp(argv[0], "--heap-size=", 12)) {
if (argv[0][12] == '\0')
return print_help();
heap_size = atoi(argv[0] + 12);
}
#if WASM_ENABLE_LIBC_WASI != 0 #if WASM_ENABLE_LIBC_WASI != 0
else if (!strncmp(argv[0], "--dir=", 6)) { else if (!strncmp(argv[0], "--dir=", 6)) {
if (argv[0][6] == '\0') if (argv[0][6] == '\0')
@ -228,35 +241,37 @@ int main(int argc, char *argv[])
app_argc = argc; app_argc = argc;
app_argv = argv; app_argv = argv;
memset(&init_args, 0, sizeof(RuntimeInitArgs));
#if USE_GLOBAL_HEAP_BUF != 0 #if USE_GLOBAL_HEAP_BUF != 0
if (bh_memory_init_with_pool(global_heap_buf, sizeof(global_heap_buf)) init_args.mem_alloc_type = Alloc_With_Pool;
!= 0) { init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
bh_printf("Init memory with global heap buffer failed.\n"); init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
return -1;
}
#else #else
if (bh_memory_init_with_allocator(malloc, free)) { init_args.mem_alloc_type = Alloc_With_Allocator;
bh_printf("Init memory with memory allocator failed.\n"); init_args.mem_alloc_option.allocator.malloc_func = malloc;
return -1; init_args.mem_alloc_option.allocator.realloc_func = realloc;
} init_args.mem_alloc_option.allocator.free_func = free;
#endif #endif
/* initialize runtime environment */ /* initialize runtime environment */
if (!wasm_runtime_init()) if (!wasm_runtime_full_init(&init_args)) {
goto fail1; bh_printf("Init runtime environment failed.\n");
return -1;
}
bh_log_set_verbose_level(log_verbose_level); bh_log_set_verbose_level(log_verbose_level);
/* load WASM byte buffer from WASM bin file */ /* load WASM byte buffer from WASM bin file */
if (!(wasm_file_buf = (uint8*) bh_read_file_to_buffer(wasm_file, if (!(wasm_file_buf = (uint8*) bh_read_file_to_buffer(wasm_file,
&wasm_file_size))) &wasm_file_size)))
goto fail2; goto fail1;
/* load WASM module */ /* load WASM module */
if (!(wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size, if (!(wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size,
error_buf, sizeof(error_buf)))) { error_buf, sizeof(error_buf)))) {
bh_printf("%s\n", error_buf); bh_printf("%s\n", error_buf);
goto fail3; goto fail2;
} }
#if WASM_ENABLE_LIBC_WASI != 0 #if WASM_ENABLE_LIBC_WASI != 0
@ -269,12 +284,12 @@ int main(int argc, char *argv[])
/* instantiate the module */ /* instantiate the module */
if (!(wasm_module_inst = wasm_runtime_instantiate(wasm_module, if (!(wasm_module_inst = wasm_runtime_instantiate(wasm_module,
64 * 1024, /* stack size */ stack_size,
64 * 1024, /* heap size */ heap_size,
error_buf, error_buf,
sizeof(error_buf)))) { sizeof(error_buf)))) {
bh_printf("%s\n", error_buf); bh_printf("%s\n", error_buf);
goto fail4; goto fail3;
} }
if (is_repl_mode) if (is_repl_mode)
@ -287,20 +302,17 @@ int main(int argc, char *argv[])
/* destroy the module instance */ /* destroy the module instance */
wasm_runtime_deinstantiate(wasm_module_inst); wasm_runtime_deinstantiate(wasm_module_inst);
fail4: fail3:
/* unload the module */ /* unload the module */
wasm_runtime_unload(wasm_module); wasm_runtime_unload(wasm_module);
fail3:
/* free the file buffer */
bh_free(wasm_file_buf);
fail2: fail2:
/* destroy runtime environment */ /* free the file buffer */
wasm_runtime_destroy(); wasm_runtime_free(wasm_file_buf);
fail1: fail1:
bh_memory_destroy(); /* destroy runtime environment */
wasm_runtime_destroy();
return 0; return 0;
} }

30
product-mini/platforms/linux-sgx/enclave-sample/Enclave/Enclave.cpp
View File

@ -7,7 +7,6 @@
#include <string.h> #include <string.h>
#include "Enclave_t.h" #include "Enclave_t.h"
#include "test_wasm.h" #include "test_wasm.h"
#include "bh_memory.h"
#include "wasm_export.h" #include "wasm_export.h"
static char global_heap_buf[2* 1024 * 1024] = { 0 }; static char global_heap_buf[2* 1024 * 1024] = { 0 };
@ -50,17 +49,21 @@ void ecall_iwasm_main()
int wasm_file_size; int wasm_file_size;
wasm_module_t wasm_module = NULL; wasm_module_t wasm_module = NULL;
wasm_module_inst_t wasm_module_inst = NULL; wasm_module_inst_t wasm_module_inst = NULL;
RuntimeInitArgs init_args;
char error_buf[128]; char error_buf[128];
if (bh_memory_init_with_pool(global_heap_buf, memset(&init_args, 0, sizeof(RuntimeInitArgs));
sizeof(global_heap_buf)) != 0) {
ocall_print("Init global heap failed.\n"); init_args.mem_alloc_type = Alloc_With_Pool;
return; init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
} init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
/* initialize runtime environment */ /* initialize runtime environment */
if (!wasm_runtime_init()) if (!wasm_runtime_full_init(&init_args)) {
goto fail1; ocall_print("Init runtime environment failed.");
ocall_print("\n");
return;
}
/* load WASM byte buffer from byte buffer of include file */ /* load WASM byte buffer from byte buffer of include file */
wasm_file_buf = (uint8_t*) wasm_test_file; wasm_file_buf = (uint8_t*) wasm_test_file;
@ -71,7 +74,7 @@ void ecall_iwasm_main()
error_buf, sizeof(error_buf)))) { error_buf, sizeof(error_buf)))) {
ocall_print(error_buf); ocall_print(error_buf);
ocall_print("\n"); ocall_print("\n");
goto fail2; goto fail1;
} }
/* instantiate the module */ /* instantiate the module */
@ -82,7 +85,7 @@ void ecall_iwasm_main()
sizeof(error_buf)))) { sizeof(error_buf)))) {
ocall_print(error_buf); ocall_print(error_buf);
ocall_print("\n"); ocall_print("\n");
goto fail3; goto fail2;
} }
/* execute the main function of wasm app */ /* execute the main function of wasm app */
@ -91,15 +94,12 @@ void ecall_iwasm_main()
/* destroy the module instance */ /* destroy the module instance */
wasm_runtime_deinstantiate(wasm_module_inst); wasm_runtime_deinstantiate(wasm_module_inst);
fail3: fail2:
/* unload the module */ /* unload the module */
wasm_runtime_unload(wasm_module); wasm_runtime_unload(wasm_module);
fail2: fail1:
/* destroy runtime environment */ /* destroy runtime environment */
wasm_runtime_destroy(); wasm_runtime_destroy();
fail1:
bh_memory_destroy();
} }

35
product-mini/platforms/linux/main.c
View File

@ -11,7 +11,6 @@
#include "bh_platform.h" #include "bh_platform.h"
#include "bh_assert.h" #include "bh_assert.h"
#include "bh_log.h" #include "bh_log.h"
#include "bh_memory.h"
#include "wasm_export.h" #include "wasm_export.h"
static int app_argc; static int app_argc;
@ -24,9 +23,11 @@ static int print_help()
bh_printf(" -f|--function name Specify function name to run in module\n" bh_printf(" -f|--function name Specify function name to run in module\n"
" rather than main\n"); " rather than main\n");
#if WASM_ENABLE_LOG != 0 #if WASM_ENABLE_LOG != 0
bh_printf(" -v=X Set log verbose level (0 to 5, default is 2),\n" bh_printf(" -v=n Set log verbose level (0 to 5, default is 2),\n"
" larger level with more log\n"); " larger level with more log\n");
#endif #endif
bh_printf(" --stack-size=n Set maximum stack size in bytes, default is 16 KB\n");
bh_printf(" --heap-size=n Set maximum heap size in bytes, default is 16 KB\n");
bh_printf(" --repl Start a very simple REPL (read-eval-print-loop) mode\n" bh_printf(" --repl Start a very simple REPL (read-eval-print-loop) mode\n"
" that runs commands in the form of `FUNC ARG...`\n"); " that runs commands in the form of `FUNC ARG...`\n");
#if WASM_ENABLE_LIBC_WASI != 0 #if WASM_ENABLE_LIBC_WASI != 0
@ -153,6 +154,7 @@ int main(int argc, char *argv[])
const char *func_name = NULL; const char *func_name = NULL;
uint8 *wasm_file_buf = NULL; uint8 *wasm_file_buf = NULL;
uint32 wasm_file_size; uint32 wasm_file_size;
uint32 stack_size = 16 * 1024, heap_size = 16 * 1024;
wasm_module_t wasm_module = NULL; wasm_module_t wasm_module = NULL;
wasm_module_inst_t wasm_module_inst = NULL; wasm_module_inst_t wasm_module_inst = NULL;
RuntimeInitArgs init_args; RuntimeInitArgs init_args;
@ -187,6 +189,16 @@ int main(int argc, char *argv[])
#endif #endif
else if (!strcmp(argv[0], "--repl")) else if (!strcmp(argv[0], "--repl"))
is_repl_mode = true; is_repl_mode = true;
else if (!strncmp(argv[0], "--stack-size=", 13)) {
if (argv[0][13] == '\0')
return print_help();
stack_size = atoi(argv[0] + 13);
}
else if (!strncmp(argv[0], "--heap-size=", 12)) {
if (argv[0][12] == '\0')
return print_help();
heap_size = atoi(argv[0] + 12);
}
#if WASM_ENABLE_LIBC_WASI != 0 #if WASM_ENABLE_LIBC_WASI != 0
else if (!strncmp(argv[0], "--dir=", 6)) { else if (!strncmp(argv[0], "--dir=", 6)) {
if (argv[0][6] == '\0') if (argv[0][6] == '\0')
@ -233,15 +245,16 @@ int main(int argc, char *argv[])
#if USE_GLOBAL_HEAP_BUF != 0 #if USE_GLOBAL_HEAP_BUF != 0
init_args.mem_alloc_type = Alloc_With_Pool; init_args.mem_alloc_type = Alloc_With_Pool;
init_args.mem_alloc.pool.heap_buf = global_heap_buf; init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
init_args.mem_alloc.pool.heap_size = sizeof(global_heap_buf); init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
#else #else
init_args.mem_alloc_type = Alloc_With_Allocator; init_args.mem_alloc_type = Alloc_With_Allocator;
init_args.mem_alloc.allocator.malloc_func = malloc; init_args.mem_alloc_option.allocator.malloc_func = malloc;
init_args.mem_alloc.allocator.realloc_func = realloc; init_args.mem_alloc_option.allocator.realloc_func = realloc;
init_args.mem_alloc.allocator.free_func = free; init_args.mem_alloc_option.allocator.free_func = free;
#endif #endif
/* initialize runtime environment */
if (!wasm_runtime_full_init(&init_args)) { if (!wasm_runtime_full_init(&init_args)) {
bh_printf("Init runtime environment failed.\n"); bh_printf("Init runtime environment failed.\n");
return -1; return -1;
@ -271,8 +284,8 @@ int main(int argc, char *argv[])
/* instantiate the module */ /* instantiate the module */
if (!(wasm_module_inst = wasm_runtime_instantiate(wasm_module, if (!(wasm_module_inst = wasm_runtime_instantiate(wasm_module,
48 * 1024, /* stack size */ stack_size,
16 * 1024, /* heap size */ heap_size,
error_buf, error_buf,
sizeof(error_buf)))) { sizeof(error_buf)))) {
bh_printf("%s\n", error_buf); bh_printf("%s\n", error_buf);
@ -295,11 +308,11 @@ fail3:
fail2: fail2:
/* free the file buffer */ /* free the file buffer */
bh_free(wasm_file_buf); wasm_runtime_free(wasm_file_buf);
fail1: fail1:
/* destroy runtime environment */ /* destroy runtime environment */
wasm_runtime_full_destroy(); wasm_runtime_destroy();
return 0; return 0;
} }

64
product-mini/platforms/vxworks/main.c
View File

@ -11,7 +11,6 @@
#include "bh_platform.h" #include "bh_platform.h"
#include "bh_assert.h" #include "bh_assert.h"
#include "bh_log.h" #include "bh_log.h"
#include "bh_memory.h"
#include "wasm_export.h" #include "wasm_export.h"
static int app_argc; static int app_argc;
@ -24,9 +23,11 @@ static int print_help()
bh_printf(" -f|--function name Specify function name to run in module\n" bh_printf(" -f|--function name Specify function name to run in module\n"
" rather than main\n"); " rather than main\n");
#if WASM_ENABLE_LOG != 0 #if WASM_ENABLE_LOG != 0
bh_printf(" -v=X Set log verbose level (0 to 5, default is 2),\n" bh_printf(" -v=n Set log verbose level (0 to 5, default is 2),\n"
" larger level with more log\n"); " larger level with more log\n");
#endif #endif
bh_printf(" --stack-size=n Set maximum stack size in bytes, default is 16 KB\n");
bh_printf(" --heap-size=n Set maximum heap size in bytes, default is 16 KB\n");
bh_printf(" --repl Start a very simple REPL (read-eval-print-loop) mode\n" bh_printf(" --repl Start a very simple REPL (read-eval-print-loop) mode\n"
" that runs commands in the form of `FUNC ARG...`\n"); " that runs commands in the form of `FUNC ARG...`\n");
#if WASM_ENABLE_LIBC_WASI != 0 #if WASM_ENABLE_LIBC_WASI != 0
@ -153,8 +154,10 @@ int main(int argc, char *argv[])
const char *func_name = NULL; const char *func_name = NULL;
uint8 *wasm_file_buf = NULL; uint8 *wasm_file_buf = NULL;
uint32 wasm_file_size; uint32 wasm_file_size;
uint32 stack_size = 16 * 1024, heap_size = 16 * 1024;
wasm_module_t wasm_module = NULL; wasm_module_t wasm_module = NULL;
wasm_module_inst_t wasm_module_inst = NULL; wasm_module_inst_t wasm_module_inst = NULL;
RuntimeInitArgs init_args;
char error_buf[128] = { 0 }; char error_buf[128] = { 0 };
#if WASM_ENABLE_LOG != 0 #if WASM_ENABLE_LOG != 0
int log_verbose_level = 2; int log_verbose_level = 2;
@ -186,6 +189,16 @@ int main(int argc, char *argv[])
#endif #endif
else if (!strcmp(argv[0], "--repl")) else if (!strcmp(argv[0], "--repl"))
is_repl_mode = true; is_repl_mode = true;
else if (!strncmp(argv[0], "--stack-size=", 13)) {
if (argv[0][13] == '\0')
return print_help();
stack_size = atoi(argv[0] + 13);
}
else if (!strncmp(argv[0], "--heap-size=", 12)) {
if (argv[0][12] == '\0')
return print_help();
heap_size = atoi(argv[0] + 12);
}
#if WASM_ENABLE_LIBC_WASI != 0 #if WASM_ENABLE_LIBC_WASI != 0
else if (!strncmp(argv[0], "--dir=", 6)) { else if (!strncmp(argv[0], "--dir=", 6)) {
if (argv[0][6] == '\0') if (argv[0][6] == '\0')
@ -228,35 +241,37 @@ int main(int argc, char *argv[])
app_argc = argc; app_argc = argc;
app_argv = argv; app_argv = argv;
memset(&init_args, 0, sizeof(RuntimeInitArgs));
#if USE_GLOBAL_HEAP_BUF != 0 #if USE_GLOBAL_HEAP_BUF != 0
if (bh_memory_init_with_pool(global_heap_buf, sizeof(global_heap_buf)) init_args.mem_alloc_type = Alloc_With_Pool;
!= 0) { init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
bh_printf("Init memory with global heap buffer failed.\n"); init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
return -1;
}
#else #else
if (bh_memory_init_with_allocator(malloc, free)) { init_args.mem_alloc_type = Alloc_With_Allocator;
bh_printf("Init memory with memory allocator failed.\n"); init_args.mem_alloc_option.allocator.malloc_func = malloc;
return -1; init_args.mem_alloc_option.allocator.realloc_func = realloc;
} init_args.mem_alloc_option.allocator.free_func = free;
#endif #endif
/* initialize runtime environment */ /* initialize runtime environment */
if (!wasm_runtime_init()) if (!wasm_runtime_full_init(&init_args)) {
goto fail1; bh_printf("Init runtime environment failed.\n");
return -1;
}
bh_log_set_verbose_level(log_verbose_level); bh_log_set_verbose_level(log_verbose_level);
/* load WASM byte buffer from WASM bin file */ /* load WASM byte buffer from WASM bin file */
if (!(wasm_file_buf = (uint8*) bh_read_file_to_buffer(wasm_file, if (!(wasm_file_buf = (uint8*) bh_read_file_to_buffer(wasm_file,
&wasm_file_size))) &wasm_file_size)))
goto fail2; goto fail1;
/* load WASM module */ /* load WASM module */
if (!(wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size, if (!(wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size,
error_buf, sizeof(error_buf)))) { error_buf, sizeof(error_buf)))) {
bh_printf("%s\n", error_buf); bh_printf("%s\n", error_buf);
goto fail3; goto fail2;
} }
#if WASM_ENABLE_LIBC_WASI != 0 #if WASM_ENABLE_LIBC_WASI != 0
@ -269,12 +284,12 @@ int main(int argc, char *argv[])
/* instantiate the module */ /* instantiate the module */
if (!(wasm_module_inst = wasm_runtime_instantiate(wasm_module, if (!(wasm_module_inst = wasm_runtime_instantiate(wasm_module,
64 * 1024, /* stack size */ stack_size,
64 * 1024, /* heap size */ heap_size,
error_buf, error_buf,
sizeof(error_buf)))) { sizeof(error_buf)))) {
bh_printf("%s\n", error_buf); bh_printf("%s\n", error_buf);
goto fail4; goto fail3;
} }
if (is_repl_mode) if (is_repl_mode)
@ -287,20 +302,17 @@ int main(int argc, char *argv[])
/* destroy the module instance */ /* destroy the module instance */
wasm_runtime_deinstantiate(wasm_module_inst); wasm_runtime_deinstantiate(wasm_module_inst);
fail4: fail3:
/* unload the module */ /* unload the module */
wasm_runtime_unload(wasm_module); wasm_runtime_unload(wasm_module);
fail3:
/* free the file buffer */
bh_free(wasm_file_buf);
fail2: fail2:
/* destroy runtime environment */ /* free the file buffer */
wasm_runtime_destroy(); wasm_runtime_free(wasm_file_buf);
fail1: fail1:
bh_memory_destroy(); /* destroy runtime environment */
wasm_runtime_destroy();
return 0; return 0;
} }

28
product-mini/platforms/zephyr/simple/src/main.c
View File

@ -8,7 +8,6 @@
#include "bh_platform.h" #include "bh_platform.h"
#include "bh_assert.h" #include "bh_assert.h"
#include "bh_log.h" #include "bh_log.h"
#include "bh_memory.h"
#include "wasm_export.h" #include "wasm_export.h"
#include "test_wasm.h" #include "test_wasm.h"
@ -63,6 +62,7 @@ void iwasm_main(void *arg1, void *arg2, void *arg3)
uint32 wasm_file_size; uint32 wasm_file_size;
wasm_module_t wasm_module = NULL; wasm_module_t wasm_module = NULL;
wasm_module_inst_t wasm_module_inst = NULL; wasm_module_inst_t wasm_module_inst = NULL;
RuntimeInitArgs init_args;
char error_buf[128]; char error_buf[128];
#if WASM_ENABLE_LOG != 0 #if WASM_ENABLE_LOG != 0
int log_verbose_level = 2; int log_verbose_level = 2;
@ -72,15 +72,17 @@ void iwasm_main(void *arg1, void *arg2, void *arg3)
(void) arg2; (void) arg2;
(void) arg3; (void) arg3;
if (bh_memory_init_with_pool(global_heap_buf, sizeof(global_heap_buf)) memset(&init_args, 0, sizeof(RuntimeInitArgs));
!= 0) {
bh_printf("Init global heap failed.\n"); init_args.mem_alloc_type = Alloc_With_Pool;
return; init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
} init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
/* initialize runtime environment */ /* initialize runtime environment */
if (!wasm_runtime_init()) if (!wasm_runtime_full_init(&init_args)) {
goto fail1; bh_printf("Init runtime environment failed.\n");
return -1;
}
#if WASM_ENABLE_LOG != 0 #if WASM_ENABLE_LOG != 0
bh_log_set_verbose_level(log_verbose_level); bh_log_set_verbose_level(log_verbose_level);
@ -94,7 +96,7 @@ void iwasm_main(void *arg1, void *arg2, void *arg3)
if (!(wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size, if (!(wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size,
error_buf, sizeof(error_buf)))) { error_buf, sizeof(error_buf)))) {
bh_printf("%s\n", error_buf); bh_printf("%s\n", error_buf);
goto fail2; goto fail1;
} }
/* instantiate the module */ /* instantiate the module */
@ -104,7 +106,7 @@ void iwasm_main(void *arg1, void *arg2, void *arg3)
error_buf, error_buf,
sizeof(error_buf)))) { sizeof(error_buf)))) {
bh_printf("%s\n", error_buf); bh_printf("%s\n", error_buf);
goto fail3; goto fail2;
} }
/* invoke the main function */ /* invoke the main function */
@ -113,16 +115,14 @@ void iwasm_main(void *arg1, void *arg2, void *arg3)
/* destroy the module instance */ /* destroy the module instance */
wasm_runtime_deinstantiate(wasm_module_inst); wasm_runtime_deinstantiate(wasm_module_inst);
fail3: fail2:
/* unload the module */ /* unload the module */
wasm_runtime_unload(wasm_module); wasm_runtime_unload(wasm_module);
fail2: fail1:
/* destroy runtime environment */ /* destroy runtime environment */
wasm_runtime_destroy(); wasm_runtime_destroy();
fail1: bh_memory_destroy();
end = k_uptime_get_32(); end = k_uptime_get_32();
printf("elpase: %d\n", (end - start)); printf("elpase: %d\n", (end - start));

6
samples/gui/lv_config/lv_conf.h
View File

@ -84,9 +84,9 @@ typedef int16_t lv_coord_t;
/* Automatically defrag. on free. Defrag. means joining the adjacent free cells. */ /* Automatically defrag. on free. Defrag. means joining the adjacent free cells. */
# define LV_MEM_AUTO_DEFRAG 1 # define LV_MEM_AUTO_DEFRAG 1
#else /*LV_MEM_CUSTOM*/ #else /*LV_MEM_CUSTOM*/
# define LV_MEM_CUSTOM_INCLUDE "bh_memory.h" /*Header for the dynamic memory function*/ # define LV_MEM_CUSTOM_INCLUDE "bh_config.h" /*Header for the dynamic memory function*/
# define LV_MEM_CUSTOM_ALLOC bh_malloc /*Wrapper to malloc*/ # define LV_MEM_CUSTOM_ALLOC BH_MALLOC /*Wrapper to malloc*/
# define LV_MEM_CUSTOM_FREE bh_free /*Wrapper to free*/ # define LV_MEM_CUSTOM_FREE BH_FREE /*Wrapper to free*/
#endif /*LV_MEM_CUSTOM*/ #endif /*LV_MEM_CUSTOM*/
/* Garbage Collector settings /* Garbage Collector settings

21
samples/gui/wasm-runtime-wgl/src/platform/linux/iwasm_main.c
View File

@ -27,7 +27,6 @@
#include "bh_common.h" #include "bh_common.h"
#include "bh_queue.h" #include "bh_queue.h"
#include "bh_thread.h" #include "bh_thread.h"
#include "bh_memory.h"
#include "runtime_sensor.h" #include "runtime_sensor.h"
#include "bi-inc/attr_container.h" #include "bi-inc/attr_container.h"
#include "module_wasm_app.h" #include "module_wasm_app.h"
@ -466,19 +465,22 @@ static void hal_init(void)
// Driver function // Driver function
int iwasm_main(int argc, char *argv[]) int iwasm_main(int argc, char *argv[])
{ {
RuntimeInitArgs init_args;
korp_thread tid; korp_thread tid;
if (!parse_args(argc, argv)) if (!parse_args(argc, argv))
return -1; return -1;
if (bh_memory_init_with_pool(global_heap_buf, sizeof(global_heap_buf)) memset(&init_args, 0, sizeof(RuntimeInitArgs));
!= 0) {
printf("Init global heap failed.\n");
return -1;
}
if (vm_thread_sys_init() != 0) { init_args.mem_alloc_type = Alloc_With_Pool;
goto fail1; init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
/* initialize runtime environment */
if (!wasm_runtime_full_init(&init_args)) {
bh_printf("Init runtime environment failed.\n");
return -1;
} }
if (!init_connection_framework()) { if (!init_connection_framework()) {
@ -513,7 +515,6 @@ int iwasm_main(int argc, char *argv[])
exit_connection_framework(); exit_connection_framework();
fail1: fail1:
bh_memory_destroy(); wasm_runtime_destroy();
return -1; return -1;
} }

21
samples/gui/wasm-runtime-wgl/src/platform/zephyr/iwasm_main.c
View File

@ -10,7 +10,6 @@
#include "bh_common.h" #include "bh_common.h"
#include "bh_queue.h" #include "bh_queue.h"
#include "bh_thread.h" #include "bh_thread.h"
#include "bh_memory.h"
#include "runtime_sensor.h" #include "runtime_sensor.h"
#include "bi-inc/attr_container.h" #include "bi-inc/attr_container.h"
#include "module_wasm_app.h" #include "module_wasm_app.h"
@ -146,16 +145,19 @@ static void hal_init(void)
int iwasm_main() int iwasm_main()
{ {
RuntimeInitArgs init_args;
host_init(); host_init();
if (bh_memory_init_with_pool(global_heap_buf, sizeof(global_heap_buf)) memset(&init_args, 0, sizeof(RuntimeInitArgs));
!= 0) {
printf("Init global heap failed.\n");
return -1;
}
if (vm_thread_sys_init() != 0) { init_args.mem_alloc_type = Alloc_With_Pool;
goto fail1; init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
/* initialize runtime environment */
if (!wasm_runtime_full_init(&init_args)) {
bh_printf("Init runtime environment failed.\n");
return -1;
} }
wgl_init(); wgl_init();
@ -167,7 +169,6 @@ int iwasm_main()
// TODO: // TODO:
app_manager_startup(&interface); app_manager_startup(&interface);
fail1: wasm_runtime_destroy();
bh_memory_destroy();
return -1; return -1;
} }

1
samples/gui/wasm-runtime-wgl/src/platform/zephyr/main.c
View File

@ -10,7 +10,6 @@
#include "bh_log.h" #include "bh_log.h"
#include "bh_platform_log.h" #include "bh_platform_log.h"
#include "wasm_export.h" #include "wasm_export.h"
#include "bh_memory.h"
extern int iwasm_main(); extern int iwasm_main();

Some files were not shown because too many files have changed in this diff Show More