Enable AoT and wamr-sdk, and change arguments of call wasm API (#157)

* Implement memory profiler, optimize memory usage, modify code indent

* Implement memory.grow and limit heap space base offset to 1G; modify iwasm build type to Release and 64 bit by default

* Add a new extension library: connection

* Fix bug of reading magic number and version in big endian platform

* Re-org platform APIs: move most platform APIs from iwasm to shared-lib

* Enhance wasm loader to fix some security issues

* Fix issue about illegal load of EXC_RETURN into PC on stm32 board

* Updates that let a restricted version of the interpreter run in SGX

* Enable native/app address validation and conversion for wasm app

* Remove wasm_application_exectue_* APIs from wasm_export.h which makes confused

* Refine binary size and fix several minor issues

Optimize interpreter LOAD/STORE opcodes to decrease the binary size
Fix issues when using iwasm library: _bh_log undefined, bh_memory.h not found
Remove unused _stdin/_stdout/_stderr global variables resolve in libc wrapper
Add macros of global heap size, stack size, heap size for Zephyr main.c
Clear compile warning of wasm_application.c

* Add more strict security checks for libc wrapper API's

* Use one libc wrapper copy for sgx and other platforms; remove bh_printf macro for other platform header files

* Enhance security of libc strcpy/sprintf wrapper function

* Fix issue of call native for x86_64/arm/mips, add module inst parameter for native wrapper functions

* Remove get_module_inst() and fix issue of call native

* Refine wgl lib: remove module_inst parameter from widget functions; move function index check to runtime instantiate

* Refine interpreter call native process, refine memory boudary check

* Fix issues of invokeNative function of arm/mips/general version

* Add a switch to build simple sample without gui support

* Add BUILD_TARGET setting in makefile to replace cpu compiler flags in source code

* Re-org shared lib header files, remove unused info; fix compile issues of vxworks

* Add build target general

* Remove unused files

* Update license header

* test push

* Restore file

* Sync up with internal/feature

* Sync up with internal/feature

* Rename build_wamr_app to build_wasm_app

* Fix small issues of README

* Enhance malformed wasm file checking
Fix issue of print hex int and implement utf8 string check
Fix wasi file read/write right issue
Fix minor issue of build wasm app doc

* Sync up with internal/feature

* Sync up with internal/feature: fix interpreter arm issue, fix read leb issue

* Sync up with internal/feature

* Fix bug of config.h and rename wasi config.h to ssp_config.h

* Sync up with internal/feature

* Import wamr aot

* update document

* update document

* Update document, disable WASI in 32bit

* update document

* remove files

* update document

* Update document

* update document

* update document

* update samples

* Sync up with internal repo

core/app-framework/base/native/base_lib_export.c

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "lib_export.h"
+#include "base_lib_export.h"
+
+static NativeSymbol extended_native_symbol_defs[] = {
+    /* TODO: use macro EXPORT_WASM_API() or EXPORT_WASM_API2() to
+       add functions to register. */
+    EXPORT_WASM_API(wasm_register_resource),
+    EXPORT_WASM_API(wasm_response_send),
+    EXPORT_WASM_API(wasm_post_request),
+    EXPORT_WASM_API(wasm_sub_event),
+    EXPORT_WASM_API(wasm_create_timer),
+    EXPORT_WASM_API(wasm_timer_destroy),
+    EXPORT_WASM_API(wasm_timer_cancel),
+    EXPORT_WASM_API(wasm_timer_restart),
+    EXPORT_WASM_API(wasm_get_sys_tick_ms),
+};
+
+int get_base_lib_export_apis(NativeSymbol **p_base_lib_apis)
+{
+    *p_base_lib_apis = extended_native_symbol_defs;
+    return sizeof(extended_native_symbol_defs) / sizeof(NativeSymbol);
+}
+

core/app-framework/base/native/base_lib_export.h

@@ -0,0 +1,13 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef _BASE_LIB_EXPORT_H_
+#define _BASE_LIB_EXPORT_H_
+
+#include "bi-inc/attr_container.h"
+#include "native_interface.h"
+
+#endif /* end of _BASE_LIB_EXPORT_H_ */
+

core/app-framework/base/native/req_resp_api.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef _REQ_RESP_API_H_
+#define _REQ_RESP_API_H_
+
+#include "bh_platform.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool
+wasm_response_send(int32 buf_offset, int size);
+
+void
+wasm_register_resource(int32 url_offset);
+
+void
+wasm_post_request(int32 buf_offset, int size);
+
+void
+wasm_sub_event(int32 url_offset);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* end of _REQ_RESP_API_H_ */
+

core/app-framework/base/native/request_response.c

@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "app_manager_export.h"
+#include "coap_ext.h"
+#include "wasm_export.h"
+#include "bh_assert.h"
+
+extern void module_request_handler(request_t *request, void *user_data);
+
+bool
+wasm_response_send(wasm_exec_env_t exec_env,
+                   int32 buffer_offset, int size)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    char *buffer = NULL;
+
+    if (!validate_app_addr(buffer_offset, size))
+        return false;
+
+    buffer = addr_app_to_native(buffer_offset);
+
+    if (buffer != NULL) {
+        response_t response[1];
+
+        if (NULL == unpack_response(buffer, size, response))
+            return false;
+
+        am_send_response(response);
+
+        return true;
+    }
+
+    return false;
+}
+
+void
+wasm_register_resource(wasm_exec_env_t exec_env, int32 url_offset)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    char *url = NULL;
+
+    if (!validate_app_str_addr(url_offset))
+        return;
+
+    url = addr_app_to_native(url_offset);
+
+    if (url != NULL) {
+        unsigned int mod_id = app_manager_get_module_id(Module_WASM_App,
+                                                        module_inst);
+        bh_assert(mod_id != ID_NONE);
+        am_register_resource(url, module_request_handler, mod_id);
+    }
+}
+
+void
+wasm_post_request(wasm_exec_env_t exec_env,
+                  int32 buffer_offset, int size)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    char *buffer = NULL;
+
+    if (!validate_app_addr(buffer_offset, size))
+        return;
+
+    buffer = addr_app_to_native(buffer_offset);
+
+    if (buffer != NULL) {
+        request_t req[1];
+
+        if (!unpack_request(buffer, size, req))
+            return;
+
+        // TODO: add permission check, ensure app can't do harm
+
+        // set sender to help dispatch the response to the sender ap
+        unsigned int mod_id = app_manager_get_module_id(Module_WASM_App,
+                                                        module_inst);
+        bh_assert(mod_id != ID_NONE);
+        req->sender = mod_id;
+
+        if (req->action == COAP_EVENT) {
+            am_publish_event(req);
+            return;
+        }
+
+        am_dispatch_request(req);
+    }
+}
+
+void
+wasm_sub_event(wasm_exec_env_t exec_env, int32 url_offset)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    char *url = NULL;
+
+    if (!validate_app_str_addr(url_offset))
+        return;
+
+    url = addr_app_to_native(url_offset);
+
+    if (url != NULL) {
+        unsigned int mod_id = app_manager_get_module_id(Module_WASM_App,
+                                                        module_inst);
+
+        bh_assert(mod_id != ID_NONE);
+        am_register_event(url, mod_id);
+    }
+}
+

core/app-framework/base/native/runtime_lib.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef LIB_BASE_RUNTIME_LIB_H_
+#define LIB_BASE_RUNTIME_LIB_H_
+
+
+#include "runtime_timer.h"
+
+void init_wasm_timer();
+void exit_wasm_timer();
+timer_ctx_t get_wasm_timer_ctx();
+timer_ctx_t create_wasm_timer_ctx(unsigned int module_id, int prealloc_num);
+void destroy_module_timer_ctx(unsigned int module_id);
+
+#endif /* LIB_BASE_RUNTIME_LIB_H_ */

core/app-framework/base/native/timer_api.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef _TIMER_API_H_
+#define _TIMER_API_H_
+
+#include "bh_platform.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef unsigned int timer_id_t;
+
+timer_id_t
+wasm_create_timer(int interval, bool is_period, bool auto_start);
+
+void
+wasm_timer_destroy(timer_id_t timer_id);
+
+void
+wasm_timer_cancel(timer_id_t timer_id);
+
+void
+wasm_timer_restart(timer_id_t timer_id, int interval);
+
+uint32
+wasm_get_sys_tick_ms(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* end of _TIMER_API_H_ */
+

core/app-framework/base/native/timer_wrapper.c

@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "runtime_timer.h"
+#include "app_manager_export.h"
+#include "module_wasm_app.h"
+#include "bh_list.h"
+#include "bh_thread.h"
+#include "bh_time.h"
+
+static bool timer_thread_run = true;
+
+bh_list g_timer_ctx_list;
+korp_cond g_timer_ctx_list_cond;
+korp_mutex g_timer_ctx_list_mutex;
+typedef struct {
+    bh_list_link l;
+    timer_ctx_t timer_ctx;
+} timer_ctx_node_t;
+
+void wasm_timer_callback(timer_id_t id, unsigned int mod_id)
+{
+    module_data* module = module_data_list_lookup_id(mod_id);
+    if (module == NULL)
+        return;
+
+    // !!! the length parameter must be 0, so the receiver will
+    //     not free the payload pointer.
+    bh_post_msg(module->queue, TIMER_EVENT_WASM, (char *)(uintptr_t)id, 0);
+}
+
+///
+/// why we create a separate link for module timer contexts
+/// rather than traverse the module list?
+/// It helps to reduce the lock frequency for the module list.
+/// Also when we lock the module list and then call the callback for
+/// timer expire, the callback is request the list lock again for lookup
+/// the module from module id. It is for avoiding that situation.
+
+void * thread_modulers_timer_check(void * arg)
+{
+    int ms_to_expiry;
+
+    while (timer_thread_run) {
+        ms_to_expiry = -1;
+        vm_mutex_lock(&g_timer_ctx_list_mutex);
+        timer_ctx_node_t* elem = (timer_ctx_node_t*)
+                                 bh_list_first_elem(&g_timer_ctx_list);
+        while (elem) {
+            int next = check_app_timers(elem->timer_ctx);
+            if (next != -1) {
+                if (ms_to_expiry == -1 || ms_to_expiry > next)
+                    ms_to_expiry = next;
+            }
+
+            elem = (timer_ctx_node_t*) bh_list_elem_next(elem);
+        }
+        vm_mutex_unlock(&g_timer_ctx_list_mutex);
+
+        if (ms_to_expiry == -1)
+            ms_to_expiry = 60 * 1000;
+        vm_mutex_lock(&g_timer_ctx_list_mutex);
+        vm_cond_reltimedwait(&g_timer_ctx_list_cond, &g_timer_ctx_list_mutex,
+                             ms_to_expiry);
+        vm_mutex_unlock(&g_timer_ctx_list_mutex);
+    }
+
+    return NULL;
+}
+
+void wakeup_modules_timer_thread(timer_ctx_t ctx)
+{
+    vm_mutex_lock(&g_timer_ctx_list_mutex);
+    vm_cond_signal(&g_timer_ctx_list_cond);
+    vm_mutex_unlock(&g_timer_ctx_list_mutex);
+}
+
+void init_wasm_timer()
+{
+    korp_tid tm_tid;
+    bh_list_init(&g_timer_ctx_list);
+
+    vm_cond_init(&g_timer_ctx_list_cond);
+    /* temp solution for: thread_modulers_timer_check thread would recursive lock the mutex */
+    vm_recursive_mutex_init(&g_timer_ctx_list_mutex);
+
+    vm_thread_create(&tm_tid, thread_modulers_timer_check,
+                     NULL, BH_APPLET_PRESERVED_STACK_SIZE);
+}
+
+void exit_wasm_timer()
+{
+    timer_thread_run = false;
+}
+
+timer_ctx_t create_wasm_timer_ctx(unsigned int module_id, int prealloc_num)
+{
+    timer_ctx_t ctx = create_timer_ctx(wasm_timer_callback,
+                                       wakeup_modules_timer_thread,
+                                       prealloc_num,
+                                       module_id);
+
+    if (ctx == NULL)
+        return NULL;
+
+    timer_ctx_node_t * node = (timer_ctx_node_t*)
+                              bh_malloc(sizeof(timer_ctx_node_t));
+    if (node == NULL) {
+        destroy_timer_ctx(ctx);
+        return NULL;
+    }
+    memset(node, 0, sizeof(*node));
+    node->timer_ctx = ctx;
+
+    vm_mutex_lock(&g_timer_ctx_list_mutex);
+    bh_list_insert(&g_timer_ctx_list, node);
+    vm_mutex_unlock(&g_timer_ctx_list_mutex);
+
+    return ctx;
+}
+
+void destroy_module_timer_ctx(unsigned int module_id)
+{
+    vm_mutex_lock(&g_timer_ctx_list_mutex);
+    timer_ctx_node_t* elem = (timer_ctx_node_t*)
+                             bh_list_first_elem(&g_timer_ctx_list);
+    while (elem) {
+        if (timer_ctx_get_owner(elem->timer_ctx) == module_id) {
+            bh_list_remove(&g_timer_ctx_list, elem);
+            destroy_timer_ctx(elem->timer_ctx);
+            bh_free(elem);
+            break;
+        }
+
+        elem = (timer_ctx_node_t*) bh_list_elem_next(elem);
+    }
+    vm_mutex_unlock(&g_timer_ctx_list_mutex);
+}
+
+timer_ctx_t get_wasm_timer_ctx(wasm_module_inst_t module_inst)
+{
+    module_data * m = app_manager_get_module_data(Module_WASM_App,
+                                                  module_inst);
+    if (m == NULL)
+        return NULL;
+    return m->timer_ctx;
+}
+
+timer_id_t
+wasm_create_timer(wasm_exec_env_t exec_env,
+                  int interval, bool is_period, bool auto_start)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    timer_ctx_t timer_ctx = get_wasm_timer_ctx(module_inst);
+    bh_assert(timer_ctx);
+    return sys_create_timer(timer_ctx, interval, is_period, auto_start);
+}
+
+void
+wasm_timer_destroy(wasm_exec_env_t exec_env, timer_id_t timer_id)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    timer_ctx_t timer_ctx = get_wasm_timer_ctx(module_inst);
+    bh_assert(timer_ctx);
+    sys_timer_destroy(timer_ctx, timer_id);
+}
+
+void
+wasm_timer_cancel(wasm_exec_env_t exec_env, timer_id_t timer_id)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    timer_ctx_t timer_ctx = get_wasm_timer_ctx(module_inst);
+    bh_assert(timer_ctx);
+    sys_timer_cancel(timer_ctx, timer_id);
+}
+
+void
+wasm_timer_restart(wasm_exec_env_t exec_env,
+                   timer_id_t timer_id, int interval)
+{
+    wasm_module_inst_t module_inst = get_module_inst(exec_env);
+    timer_ctx_t timer_ctx = get_wasm_timer_ctx(module_inst);
+    bh_assert(timer_ctx);
+    sys_timer_restart(timer_ctx, timer_id, interval);
+}
+
+extern uint32 get_sys_tick_ms();
+
+uint32
+wasm_get_sys_tick_ms(wasm_exec_env_t exec_env)
+{
+    return (uint32) bh_get_tick_ms();
+}
+

core/app-framework/base/native/wasm_lib.cmake

@@ -0,0 +1,13 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+set (WASM_LIB_BASE_DIR ${CMAKE_CURRENT_LIST_DIR})
+
+add_definitions (-DWASM_ENABLE_BASE_LIB)
+
+include_directories(${WASM_LIB_BASE_DIR})
+
+file (GLOB_RECURSE source_all ${WASM_LIB_BASE_DIR}/*.c)
+
+set (WASM_APP_LIB_CURRENT_SOURCE ${source_all})
+