add support for AliOS Things (#34)

* Add support of AliOS-Things

* update the README.md format

* update the README.md #1

* update the README.md #2

README.md

@@ -78,6 +78,47 @@ source ../../../zephyr-env.sh
 cmake -GNinja -DBOARD=qemu_x86 ..
 ninja
 ```
+AliOS-Things
+-------------------------
+1. a developerkit board id needed for testing
+2. download the AliOS-Things code
+   ``` Bash
+   git clone https://github.com/alibaba/AliOS-Things.git
+   ```
+3. copy <iwasm_root_dir>/products/alios-things directory to AliOS-Things/middleware, and rename it as iwasm
+   ``` Bash
+   cp -a <iwasm_root_dir>/products/alios-things middleware/iwasm
+   ```
+4. create a link to <iwasm_root_dir> in middleware/iwasm/ and rename it to iwasm
+   ``` Bash
+   ln -s <iwasm_root_dir> middleware/iwasm/iwasm
+   ```
+5. create a link to <shared-lib_root_dir> in middleware/iwasm/ and rename it to shared-lib
+   ``` Bash
+   ln -s <shared-lib_root_dir> middle/iwasm/shared-lib
+   ```
+6. modify file app/example/helloworld/helloworld.c, patch as:
+   ``` C
+   #include <stdbool.h>
+   #include <aos/kernel.h>
+   extern bool iwasm_init();
+   int application_start(int argc, char *argv[])
+   {
+        int count = 0;
+        iwasm_init();
+       ...
+   }
+   ```
+7. modify file app/example/helloworld/aos.mk
+   ``` C
+      $(NAME)_COMPONENTS := osal_aos iwasm
+   ```
+8. build source code
+   ``` Bash
+   aos make helloworld@developerkit -c config
+   aos make
+   ```
+9. download the binary to developerkit board, check the output from serial port
 
 Build WASM app
 =========================
@@ -492,7 +533,7 @@ In this sample, the LittlevGL source code is built into the WebAssembly code wit
         EXPORT_WASM_API(display_map),
         EXPORT_WASM_API(time_get_ms), };
 
-The runtime component supports building target for Linux and Zephyr/STM Nucleo board respectively. The beauty of this sample is the WebAssembly application can have identical display and behavior when running from both runtime environments. That implies we can do the majority of application validation from the desktop environment then load it to the target device as long as two runtime distributions support the same set of the application interface.
+The runtime component supports building target for Linux and AliOS-Things, Zephyr/STM Nucleo board respectively. The beauty of this sample is the WebAssembly application can have identical display and behavior when running from both runtime environments. That implies we can do the majority of application validation from the desktop environment then load it to the target device as long as two runtime distributions support the same set of the application interface.
 
 
 Below pictures show the WASM application is running on an STM board with an LCD touch panel. When users click the blue button, the WASM application increases the counter, and the latest counter value is displayed on the top banner of the touch panel. 

core/iwasm/products/alios-things/iwasm.mk

@@ -0,0 +1,50 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+NAME := iwasm
+IWASM_ROOT := iwasm
+SHARED_LIB_ROOT := shared-lib
+
+GLOBAL_DEFINES += NVALGRIND
+GLOBAL_INCLUDES += ${IWASM_ROOT}/runtime/include \
+                   ${IWASM_ROOT}/runtime/platform/include \
+                   ${IWASM_ROOT}/runtime/platform/alios \
+                   ${IWASM_ROOT}/runtime/vmcore-wasm \
+                   ${SHARED_LIB_ROOT}/include \
+                   ${SHARED_LIB_ROOT}/platform/include \
+                   ${SHARED_LIB_ROOT}/platform/alios
+
+$(NAME)_SOURCES := ${IWASM_ROOT}/runtime/utils/wasm_hashmap.c \
+                   ${IWASM_ROOT}/runtime/utils/wasm_log.c \
+                   ${IWASM_ROOT}/runtime/utils/wasm_dlfcn.c \
+                   ${IWASM_ROOT}/runtime/platform/alios/wasm_math.c \
+                   ${IWASM_ROOT}/runtime/platform/alios/wasm_platform.c \
+                   ${IWASM_ROOT}/runtime/platform/alios/wasm-native.c \
+                   ${IWASM_ROOT}/runtime/vmcore-wasm/wasm_application.c \
+                   ${IWASM_ROOT}/runtime/vmcore-wasm/wasm_interp.c \
+                   ${IWASM_ROOT}/runtime/vmcore-wasm/wasm_loader.c \
+                   ${IWASM_ROOT}/runtime/vmcore-wasm/wasm_runtime.c \
+                   ${IWASM_ROOT}/runtime/vmcore-wasm/invokeNative_general.c \
+                   ${IWASM_ROOT}/lib/native/libc/libc_wrapper.c \
+                   ${IWASM_ROOT}/lib/native/base/base_lib_export.c \
+                   ${SHARED_LIB_ROOT}/platform/alios/bh_platform.c \
+                   ${SHARED_LIB_ROOT}/platform/alios/bh_assert.c \
+                   ${SHARED_LIB_ROOT}/platform/alios/bh_thread.c \
+                   ${SHARED_LIB_ROOT}/mem-alloc/bh_memory.c \
+                   ${SHARED_LIB_ROOT}/mem-alloc/mem_alloc.c \
+                   ${SHARED_LIB_ROOT}/mem-alloc/ems/ems_kfc.c \
+                   ${SHARED_LIB_ROOT}/mem-alloc/ems/ems_alloc.c \
+                   ${SHARED_LIB_ROOT}/mem-alloc/ems/ems_hmu.c \
+                   src/main.c src/ext_lib_export.c
+

core/iwasm/products/alios-things/src/ext_lib_export.c

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "lib_export.h"
+
+static NativeSymbol extended_native_symbol_defs[] = { };
+
+#include "ext_lib_export.h"

core/iwasm/products/alios-things/src/main.c

@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include "wasm_assert.h"
+#include "wasm_log.h"
+#include "wasm_platform.h"
+#include "wasm_platform_log.h"
+#include "wasm_thread.h"
+#include "wasm_export.h"
+#include "wasm_memory.h"
+#include "bh_memory.h"
+#include "test_wasm.h"
+
+static int app_argc;
+static char **app_argv;
+
+static void*
+app_instance_main(wasm_module_inst_t module_inst)
+{
+    const char *exception;
+
+    wasm_application_execute_main(module_inst, app_argc, app_argv);
+    if ((exception = wasm_runtime_get_exception(module_inst)))
+        wasm_printf("%s\n", exception);
+    return NULL;
+}
+
+static char global_heap_buf[256 * 1024] = { 0 };
+
+void iwasm_main(void *arg1)
+{
+    uint8 *wasm_file_buf = NULL;
+    int wasm_file_size;
+    wasm_module_t wasm_module = NULL;
+    wasm_module_inst_t wasm_module_inst = NULL;
+    char error_buf[128];
+#if WASM_ENABLE_LOG != 0
+    int log_verbose_level = 1;
+#endif
+
+    (void) arg1;
+
+    if (bh_memory_init_with_pool(global_heap_buf, sizeof(global_heap_buf))
+            != 0) {
+        wasm_printf("Init global heap failed.\n");
+        return;
+    }
+
+    /* initialize runtime environment */
+    if (!wasm_runtime_init())
+        goto fail1;
+
+#if WASM_ENABLE_LOG != 0
+    wasm_log_set_verbose_level(log_verbose_level);
+#endif
+
+    /* load WASM byte buffer from byte buffer of include file */
+    wasm_file_buf = (uint8*) wasm_test_file;
+    wasm_file_size = sizeof(wasm_test_file);
+
+    /* load WASM module */
+    if (!(wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size,
+            error_buf, sizeof(error_buf)))) {
+        wasm_printf("%s\n", error_buf);
+        goto fail2;
+    }
+
+    /* instantiate the module */
+    if (!(wasm_module_inst = wasm_runtime_instantiate(wasm_module, 8 * 1024,
+            8 * 1024, error_buf, sizeof(error_buf)))) {
+        wasm_printf("%s\n", error_buf);
+        goto fail3;
+    }
+
+    app_instance_main(wasm_module_inst);
+
+    /* destroy the module instance */
+    wasm_runtime_deinstantiate(wasm_module_inst);
+
+    fail3:
+    /* unload the module */
+    wasm_runtime_unload(wasm_module);
+
+    fail2:
+    /* destroy runtime environment */
+    wasm_runtime_destroy();
+
+    fail1: bh_memory_destroy();
+}
+
+#define DEFAULT_THREAD_STACKSIZE (6 * 1024)
+#define DEFAULT_THREAD_PRIORITY 50
+
+bool iwasm_init(void)
+{
+    int ret = aos_task_new("wasm-main", iwasm_main, NULL,
+    DEFAULT_THREAD_STACKSIZE);
+    return ret == 0 ? true : false;
+}
+

core/iwasm/products/alios-things/src/test_wasm.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+unsigned char wasm_test_file[] = { 0x00, 0x61, 0x73, 0x6D, 0x01, 0x00, 0x00,
+        0x00, 0x00, 0x0D, 0x06, 0x64, 0x79, 0x6C, 0x69, 0x6E, 0x6B, 0xC0, 0x80,
+        0x04, 0x04, 0x00, 0x00, 0x01, 0x13, 0x04, 0x60, 0x01, 0x7F, 0x00, 0x60,
+        0x01, 0x7F, 0x01, 0x7F, 0x60, 0x02, 0x7F, 0x7F, 0x01, 0x7F, 0x60, 0x00,
+        0x00, 0x02, 0x58, 0x06, 0x03, 0x65, 0x6E, 0x76, 0x05, 0x5F, 0x66, 0x72,
+        0x65, 0x65, 0x00, 0x00, 0x03, 0x65, 0x6E, 0x76, 0x07, 0x5F, 0x6D, 0x61,
+        0x6C, 0x6C, 0x6F, 0x63, 0x00, 0x01, 0x03, 0x65, 0x6E, 0x76, 0x07, 0x5F,
+        0x70, 0x72, 0x69, 0x6E, 0x74, 0x66, 0x00, 0x02, 0x03, 0x65, 0x6E, 0x76,
+        0x05, 0x5F, 0x70, 0x75, 0x74, 0x73, 0x00, 0x01, 0x03, 0x65, 0x6E, 0x76,
+        0x0D, 0x5F, 0x5F, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x5F, 0x62, 0x61,
+        0x73, 0x65, 0x03, 0x7F, 0x00, 0x03, 0x65, 0x6E, 0x76, 0x06, 0x6D, 0x65,
+        0x6D, 0x6F, 0x72, 0x79, 0x02, 0x00, 0x01, 0x03, 0x04, 0x03, 0x02, 0x03,
+        0x03, 0x06, 0x10, 0x03, 0x7F, 0x01, 0x41, 0x00, 0x0B, 0x7F, 0x01, 0x41,
+        0x00, 0x0B, 0x7F, 0x00, 0x41, 0x1B, 0x0B, 0x07, 0x33, 0x04, 0x12, 0x5F,
+        0x5F, 0x70, 0x6F, 0x73, 0x74, 0x5F, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E,
+        0x74, 0x69, 0x61, 0x74, 0x65, 0x00, 0x06, 0x05, 0x5F, 0x6D, 0x61, 0x69,
+        0x6E, 0x00, 0x04, 0x0B, 0x72, 0x75, 0x6E, 0x50, 0x6F, 0x73, 0x74, 0x53,
+        0x65, 0x74, 0x73, 0x00, 0x05, 0x04, 0x5F, 0x73, 0x74, 0x72, 0x03, 0x03,
+        0x0A, 0xBA, 0x01, 0x03, 0x9E, 0x01, 0x01, 0x01, 0x7F, 0x23, 0x01, 0x21,
+        0x00, 0x23, 0x01, 0x41, 0x10, 0x6A, 0x24, 0x01, 0x20, 0x00, 0x41, 0x08,
+        0x6A, 0x21, 0x02, 0x23, 0x00, 0x41, 0x1B, 0x6A, 0x10, 0x03, 0x1A, 0x41,
+        0x80, 0x08, 0x10, 0x01, 0x21, 0x01, 0x20, 0x01, 0x04, 0x7F, 0x20, 0x00,
+        0x20, 0x01, 0x36, 0x02, 0x00, 0x23, 0x00, 0x20, 0x00, 0x10, 0x02, 0x1A,
+        0x20, 0x01, 0x23, 0x00, 0x2C, 0x00, 0x0D, 0x3A, 0x00, 0x00, 0x20, 0x01,
+        0x23, 0x00, 0x2C, 0x00, 0x0E, 0x3A, 0x00, 0x01, 0x20, 0x01, 0x23, 0x00,
+        0x2C, 0x00, 0x0F, 0x3A, 0x00, 0x02, 0x20, 0x01, 0x23, 0x00, 0x2C, 0x00,
+        0x10, 0x3A, 0x00, 0x03, 0x20, 0x01, 0x23, 0x00, 0x2C, 0x00, 0x11, 0x3A,
+        0x00, 0x04, 0x20, 0x01, 0x23, 0x00, 0x2C, 0x00, 0x12, 0x3A, 0x00, 0x05,
+        0x20, 0x02, 0x20, 0x01, 0x36, 0x02, 0x00, 0x23, 0x00, 0x41, 0x13, 0x6A,
+        0x20, 0x02, 0x10, 0x02, 0x1A, 0x20, 0x01, 0x10, 0x00, 0x20, 0x00, 0x24,
+        0x01, 0x41, 0x00, 0x05, 0x23, 0x00, 0x41, 0x28, 0x6A, 0x10, 0x03, 0x1A,
+        0x20, 0x00, 0x24, 0x01, 0x41, 0x7F, 0x0B, 0x0B, 0x03, 0x00, 0x01, 0x0B,
+        0x14, 0x00, 0x23, 0x00, 0x41, 0x40, 0x6B, 0x24, 0x01, 0x23, 0x01, 0x41,
+        0x80, 0x80, 0x04, 0x6A, 0x24, 0x02, 0x10, 0x05, 0x0B, 0x0B, 0x3F, 0x01,
+        0x00, 0x23, 0x00, 0x0B, 0x39, 0x62, 0x75, 0x66, 0x20, 0x70, 0x74, 0x72,
+        0x3A, 0x20, 0x25, 0x70, 0x0A, 0x00, 0x31, 0x32, 0x33, 0x34, 0x0A, 0x00,
+        0x62, 0x75, 0x66, 0x3A, 0x20, 0x25, 0x73, 0x00, 0x48, 0x65, 0x6C, 0x6C,
+        0x6F, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64, 0x21, 0x00, 0x6D, 0x61, 0x6C,
+        0x6C, 0x6F, 0x63, 0x20, 0x62, 0x75, 0x66, 0x20, 0x66, 0x61, 0x69, 0x6C,
+        0x65, 0x64, 0x00, 0x50, 0x04, 0x6E, 0x61, 0x6D, 0x65, 0x01, 0x49, 0x07,
+        0x00, 0x05, 0x5F, 0x66, 0x72, 0x65, 0x65, 0x01, 0x07, 0x5F, 0x6D, 0x61,
+        0x6C, 0x6C, 0x6F, 0x63, 0x02, 0x07, 0x5F, 0x70, 0x72, 0x69, 0x6E, 0x74,
+        0x66, 0x03, 0x05, 0x5F, 0x70, 0x75, 0x74, 0x73, 0x04, 0x05, 0x5F, 0x6D,
+        0x61, 0x69, 0x6E, 0x05, 0x0B, 0x72, 0x75, 0x6E, 0x50, 0x6F, 0x73, 0x74,
+        0x53, 0x65, 0x74, 0x73, 0x06, 0x12, 0x5F, 0x5F, 0x70, 0x6F, 0x73, 0x74,
+        0x5F, 0x69, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74, 0x69, 0x61, 0x74, 0x65,
+        0x00, 0x20, 0x10, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x4D, 0x61, 0x70,
+        0x70, 0x69, 0x6E, 0x67, 0x55, 0x52, 0x4C, 0x0E, 0x61, 0x2E, 0x6F, 0x75,
+        0x74, 0x2E, 0x77, 0x61, 0x73, 0x6D, 0x2E, 0x6D, 0x61, 0x70 };

core/iwasm/runtime/platform/alios/COPYRIGHT

@@ -0,0 +1,126 @@
+# $FreeBSD$
+#	@(#)COPYRIGHT	8.2 (Berkeley) 3/21/94
+
+The compilation of software known as FreeBSD is distributed under the
+following terms:
+
+Copyright (c) 1992-2019 The FreeBSD Project.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+
+The 4.4BSD and 4.4BSD-Lite software is distributed under the following
+terms:
+
+All of the documentation and software included in the 4.4BSD and 4.4BSD-Lite
+Releases is copyrighted by The Regents of the University of California.
+
+Copyright 1979, 1980, 1983, 1986, 1988, 1989, 1991, 1992, 1993, 1994
+	The Regents of the University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. All advertising materials mentioning features or use of this software
+   must display the following acknowledgement:
+This product includes software developed by the University of
+California, Berkeley and its contributors.
+4. Neither the name of the University nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+
+The Institute of Electrical and Electronics Engineers and the American
+National Standards Committee X3, on Information Processing Systems have
+given us permission to reprint portions of their documentation.
+
+In the following statement, the phrase ``this text'' refers to portions
+of the system documentation.
+
+Portions of this text are reprinted and reproduced in electronic form in
+the second BSD Networking Software Release, from IEEE Std 1003.1-1988, IEEE
+Standard Portable Operating System Interface for Computer Environments
+(POSIX), copyright C 1988 by the Institute of Electrical and Electronics
+Engineers, Inc.  In the event of any discrepancy between these versions
+and the original IEEE Standard, the original IEEE Standard is the referee
+document.
+
+In the following statement, the phrase ``This material'' refers to portions
+of the system documentation.
+
+This material is reproduced with permission from American National
+Standards Committee X3, on Information Processing Systems.  Computer and
+Business Equipment Manufacturers Association (CBEMA), 311 First St., NW,
+Suite 500, Washington, DC 20001-2178.  The developmental work of
+Programming Language C was completed by the X3J11 Technical Committee.
+
+The views and conclusions contained in the software and documentation are
+those of the authors and should not be interpreted as representing official
+policies, either expressed or implied, of the Regents of the University
+of California.
+
+
+NOTE: The copyright of UC Berkeley's Berkeley Software Distribution ("BSD")
+source has been updated.  The copyright addendum may be found at
+ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change and is
+included below.
+
+July 22, 1999
+
+To All Licensees, Distributors of Any Version of BSD:
+
+As you know, certain of the Berkeley Software Distribution ("BSD") source
+code files require that further distributions of products containing all or
+portions of the software, acknowledge within their advertising materials
+that such products contain software developed by UC Berkeley and its
+contributors.
+
+Specifically, the provision reads:
+
+"     * 3. All advertising materials mentioning features or use of this software
+      *    must display the following acknowledgement:
+      *    This product includes software developed by the University of
+      *    California, Berkeley and its contributors."
+
+Effective immediately, licensees and distributors are no longer required to
+include the acknowledgement within advertising materials.  Accordingly, the
+foregoing paragraph of those BSD Unix files containing it is hereby deleted
+in its entirety.
+
+William Hoskins
+Director, Office of Technology Licensing
+University of California, Berkeley

core/iwasm/runtime/platform/alios/wasm-native.c

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "wasm_native.h"
+
+
+void*
+wasm_platform_native_func_lookup(const char *module_name,
+                                 const char *func_name)
+{
+    return NULL;
+}
+

core/iwasm/runtime/platform/alios/wasm_math.c

@@ -0,0 +1,581 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2004 David Schultz <das@FreeBSD.ORG>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+#include "wasm_log.h"
+#include "wasm_platform.h"
+#include "wasm_platform_log.h"
+#include "wasm_memory.h"
+
+#define __FDLIBM_STDC__
+
+typedef uint32_t u_int32_t;
+typedef uint64_t u_int64_t;
+
+typedef union u32double_tag {
+  int *pint;
+  double *pdouble;
+} U32DOUBLE;
+
+static inline int *
+pdouble2pint(double *pdouble)
+{
+  U32DOUBLE u;
+  u.pdouble = pdouble;
+  return u.pint;
+}
+
+typedef union
+{
+  double value;
+  struct
+  {
+    u_int32_t lsw;
+    u_int32_t msw;
+  } parts;
+  struct
+  {
+    u_int64_t w;
+  } xparts;
+} ieee_double_shape_type_little;
+
+typedef union
+{
+  double value;
+  struct
+  {
+    u_int32_t msw;
+    u_int32_t lsw;
+  } parts;
+  struct
+  {
+    u_int64_t w;
+  } xparts;
+} ieee_double_shape_type_big;
+
+typedef union {
+	double	d;
+	struct {
+		unsigned int	manl	:32;
+		unsigned int	manh	:20;
+		unsigned int	exp	:11;
+		unsigned int	sign	:1;
+	} bits;
+} IEEEd2bits_L;
+
+typedef union {
+	double	d;
+	struct {
+		unsigned int	sign	:1;
+		unsigned int	exp	:11;
+		unsigned int	manh	:20;
+		unsigned int	manl	:32;
+	} bits;
+} IEEEd2bits_B;
+
+#define __HIL(x) *(1+pdouble2pint(&x))
+#define __LOL(x) *(pdouble2pint(&x))
+#define __HIB(x) *(int*)&x
+#define __LOB(x) *(1+(int*)&x)
+
+/* Get two 32 bit ints from a double.  */
+
+#define EXTRACT_WORDS_L(ix0,ix1,d)				\
+do {								\
+  ieee_double_shape_type_little ew_u;	                 	\
+  ew_u.value = (d);						\
+  (ix0) = ew_u.parts.msw;					\
+  (ix1) = ew_u.parts.lsw;					\
+} while (0)
+
+/* Set a double from two 32 bit ints.  */
+
+#define INSERT_WORDS_L(d,ix0,ix1)				\
+do {								\
+  ieee_double_shape_type_little iw_u;	                 	\
+  iw_u.parts.msw = (ix0);					\
+  iw_u.parts.lsw = (ix1);					\
+  (d) = iw_u.value;						\
+} while (0)
+
+/* Get two 32 bit ints from a double.  */
+
+#define EXTRACT_WORDS_B(ix0,ix1,d)				\
+do {								\
+  ieee_double_shape_type_big ew_u;	                 	\
+  ew_u.value = (d);						\
+  (ix0) = ew_u.parts.msw;					\
+  (ix1) = ew_u.parts.lsw;					\
+} while (0)
+
+/* Set a double from two 32 bit ints.  */
+
+#define INSERT_WORDS_B(d,ix0,ix1)				\
+do {								\
+  ieee_double_shape_type_big iw_u;	                 	\
+  iw_u.parts.msw = (ix0);					\
+  iw_u.parts.lsw = (ix1);					\
+  (d) = iw_u.value;						\
+} while (0)
+
+/* Get the more significant 32 bit int from a double.  */
+#define GET_HIGH_WORD_L(i,d)					\
+do {								\
+  ieee_double_shape_type_little gh_u;			        \
+  gh_u.value = (d);						\
+  (i) = gh_u.parts.msw;						\
+} while (0)
+
+/* Get the more significant 32 bit int from a double.  */
+#define GET_HIGH_WORD_B(i,d)					\
+do {								\
+  ieee_double_shape_type_big gh_u;			        \
+  gh_u.value = (d);						\
+  (i) = gh_u.parts.msw;						\
+} while (0)
+
+/* Set the more significant 32 bits of a double from an int.  */
+#define SET_HIGH_WORD_L(d,v)					\
+do {								\
+  ieee_double_shape_type_little sh_u;				\
+  sh_u.value = (d);						\
+  sh_u.parts.msw = (v);						\
+  (d) = sh_u.value;						\
+} while (0)
+
+/* Set the more significant 32 bits of a double from an int.  */
+#define SET_HIGH_WORD_B(d,v)					\
+do {								\
+  ieee_double_shape_type_big sh_u;				\
+  sh_u.value = (d);						\
+  sh_u.parts.msw = (v);						\
+  (d) = sh_u.value;						\
+} while (0)
+
+/* Macro wrappers.  */
+#define EXTRACT_WORDS(ix0,ix1,d) do { \
+  if (is_little_endian)               \
+    EXTRACT_WORDS_L(ix0,ix1,d);       \
+  else                                \
+    EXTRACT_WORDS_B(ix0,ix1,d);       \
+} while (0)
+
+#define INSERT_WORDS(d,ix0,ix1) do {  \
+  if (is_little_endian)               \
+    INSERT_WORDS_L(d,ix0,ix1);        \
+  else                                \
+    INSERT_WORDS_B(d,ix0,ix1);        \
+} while (0)
+
+#define GET_HIGH_WORD(i,d)					\
+do {								\
+  if (is_little_endian)                                         \
+    GET_HIGH_WORD_L(i,d);              			        \
+  else                                                          \
+    GET_HIGH_WORD_B(i,d);                                       \
+} while (0)
+
+#define SET_HIGH_WORD(d,v)					\
+do {								\
+  if (is_little_endian)                                         \
+    SET_HIGH_WORD_L(d,v);        				\
+  else                                                          \
+    SET_HIGH_WORD_B(d,v);                                       \
+} while (0)
+
+#define __HI(x) (is_little_endian ? __HIL(x) : __HIB(x))
+
+#define __LO(x) (is_little_endian ? __LOL(x) : __LOB(x))
+
+/*
+ * Attempt to get strict C99 semantics for assignment with non-C99 compilers.
+ */
+#if FLT_EVAL_METHOD == 0 || __GNUC__ == 0
+#define	STRICT_ASSIGN(type, lval, rval)	((lval) = (rval))
+#else
+#define	STRICT_ASSIGN(type, lval, rval) do {	\
+	volatile type __lval;			\
+						\
+	if (sizeof(type) >= sizeof(long double))	\
+		(lval) = (rval);		\
+	else {					\
+		__lval = (rval);		\
+		(lval) = __lval;		\
+	}					\
+} while (0)
+#endif
+
+#ifdef __FDLIBM_STDC__
+static const double huge = 1.0e300;
+#else
+static double huge = 1.0e300;
+#endif
+
+#ifdef __STDC__
+static const double
+#else
+static double
+#endif
+tiny  = 1.0e-300;
+
+#ifdef __STDC__
+static const double
+#else
+static double
+#endif
+one=  1.00000000000000000000e+00; /* 0x3FF00000, 0x00000000 */
+
+#ifdef __STDC__
+static const double
+#else
+static double
+#endif
+TWO52[2]={
+  4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
+ -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
+};
+
+static double freebsd_sqrt(double x);
+static double freebsd_floor(double x);
+static double freebsd_ceil(double x);
+static double freebsd_fabs(double x);
+static double freebsd_rint(double x);
+static int freebsd_isnan(double x);
+
+static double freebsd_sqrt(double x)		/* wrapper sqrt */
+{
+	double z;
+	int32_t sign = (int)0x80000000;
+	int32_t ix0,s0,q,m,t,i;
+	u_int32_t r,t1,s1,ix1,q1;
+
+ 	EXTRACT_WORDS(ix0,ix1,x);
+
+    /* take care of Inf and NaN */
+	if((ix0&0x7ff00000)==0x7ff00000) {
+	    return x*x+x;		/* sqrt(NaN)=NaN, sqrt(+inf)=+inf
+					   sqrt(-inf)=sNaN */
+	}
+    /* take care of zero */
+	if(ix0<=0) {
+	    if(((ix0&(~sign))|ix1)==0) return x;/* sqrt(+-0) = +-0 */
+	    else if(ix0<0)
+		return (x-x)/(x-x);		/* sqrt(-ve) = sNaN */
+	}
+    /* normalize x */
+	m = (ix0>>20);
+	if(m==0) {				/* subnormal x */
+	    while(ix0==0) {
+		m -= 21;
+		ix0 |= (ix1>>11); ix1 <<= 21;
+	    }
+	    for(i=0;(ix0&0x00100000)==0;i++) ix0<<=1;
+	    m -= i-1;
+	    ix0 |= (ix1>>(32-i));
+	    ix1 <<= i;
+	}
+	m -= 1023;	/* unbias exponent */
+	ix0 = (ix0&0x000fffff)|0x00100000;
+	if(m&1){	/* odd m, double x to make it even */
+	    ix0 += ix0 + ((ix1&sign)>>31);
+	    ix1 += ix1;
+	}
+	m >>= 1;	/* m = [m/2] */
+
+    /* generate sqrt(x) bit by bit */
+	ix0 += ix0 + ((ix1&sign)>>31);
+	ix1 += ix1;
+	q = q1 = s0 = s1 = 0;	/* [q,q1] = sqrt(x) */
+	r = 0x00200000;		/* r = moving bit from right to left */
+
+	while(r!=0) {
+	    t = s0+r;
+	    if(t<=ix0) {
+		s0   = t+r;
+		ix0 -= t;
+		q   += r;
+	    }
+	    ix0 += ix0 + ((ix1&sign)>>31);
+	    ix1 += ix1;
+	    r>>=1;
+	}
+
+	r = sign;
+	while(r!=0) {
+	    t1 = s1+r;
+	    t  = s0;
+	    if((t<ix0)||((t==ix0)&&(t1<=ix1))) {
+		s1  = t1+r;
+		if(((t1&sign)==sign)&&(s1&sign)==0) s0 += 1;
+		ix0 -= t;
+		if (ix1 < t1) ix0 -= 1;
+		ix1 -= t1;
+		q1  += r;
+	    }
+	    ix0 += ix0 + ((ix1&sign)>>31);
+	    ix1 += ix1;
+	    r>>=1;
+	}
+
+    /* use floating add to find out rounding direction */
+	if((ix0|ix1)!=0) {
+	    z = one-tiny; /* trigger inexact flag */
+	    if (z>=one) {
+	        z = one+tiny;
+	        if (q1==(u_int32_t)0xffffffff) { q1=0; q += 1;}
+		else if (z>one) {
+		    if (q1==(u_int32_t)0xfffffffe) q+=1;
+		    q1+=2;
+		} else
+	            q1 += (q1&1);
+	    }
+	}
+	ix0 = (q>>1)+0x3fe00000;
+	ix1 =  q1>>1;
+	if ((q&1)==1) ix1 |= sign;
+	ix0 += (m <<20);
+
+	INSERT_WORDS(z,ix0,ix1);
+
+	return z;
+}
+
+static double freebsd_floor(double x)
+{
+	int32_t i0,i1,j0;
+	u_int32_t i,j;
+
+	EXTRACT_WORDS(i0,i1,x);
+
+	j0 = ((i0>>20)&0x7ff)-0x3ff;
+	if(j0<20) {
+	    if(j0<0) { 	/* raise inexact if x != 0 */
+		if(huge+x>0.0) {/* return 0*sign(x) if |x|<1 */
+		    if(i0>=0) {i0=i1=0;}
+		    else if(((i0&0x7fffffff)|i1)!=0)
+			{ i0=0xbff00000;i1=0;}
+		}
+	    } else {
+		i = (0x000fffff)>>j0;
+		if(((i0&i)|i1)==0) return x; /* x is integral */
+		if(huge+x>0.0) {	/* raise inexact flag */
+		    if(i0<0) i0 += (0x00100000)>>j0;
+		    i0 &= (~i); i1=0;
+		}
+	    }
+	} else if (j0>51) {
+	    if(j0==0x400) return x+x;	/* inf or NaN */
+	    else return x;		/* x is integral */
+	} else {
+	    i = ((u_int32_t)(0xffffffff))>>(j0-20);
+	    if((i1&i)==0) return x;	/* x is integral */
+	    if(huge+x>0.0) { 		/* raise inexact flag */
+		if(i0<0) {
+		    if(j0==20) i0+=1;
+		    else {
+			j = i1+(1<<(52-j0));
+			if(j<i1) i0 +=1 ; 	/* got a carry */
+			i1=j;
+		    }
+		}
+		i1 &= (~i);
+	    }
+	}
+
+	INSERT_WORDS(x,i0,i1);
+
+	return x;
+}
+
+static double freebsd_ceil(double x)
+{
+	int32_t i0,i1,j0;
+	u_int32_t i,j;
+	EXTRACT_WORDS(i0,i1,x);
+	j0 = ((i0>>20)&0x7ff)-0x3ff;
+	if(j0<20) {
+	    if(j0<0) { 	/* raise inexact if x != 0 */
+		if(huge+x>0.0) {/* return 0*sign(x) if |x|<1 */
+		    if(i0<0) {i0=0x80000000;i1=0;}
+		    else if((i0|i1)!=0) { i0=0x3ff00000;i1=0;}
+		}
+	    } else {
+		i = (0x000fffff)>>j0;
+		if(((i0&i)|i1)==0) return x; /* x is integral */
+		if(huge+x>0.0) {	/* raise inexact flag */
+		    if(i0>0) i0 += (0x00100000)>>j0;
+		    i0 &= (~i); i1=0;
+		}
+	    }
+	} else if (j0>51) {
+	    if(j0==0x400) return x+x;	/* inf or NaN */
+	    else return x;		/* x is integral */
+	} else {
+	    i = ((u_int32_t)(0xffffffff))>>(j0-20);
+	    if((i1&i)==0) return x;	/* x is integral */
+	    if(huge+x>0.0) { 		/* raise inexact flag */
+		if(i0>0) {
+		    if(j0==20) i0+=1;
+		    else {
+			j = i1 + (1<<(52-j0));
+			if(j<i1) i0+=1;	/* got a carry */
+			i1 = j;
+		    }
+		}
+		i1 &= (~i);
+	    }
+	}
+	INSERT_WORDS(x,i0,i1);
+	return x;
+}
+
+static double freebsd_rint(double x)
+{
+	int32_t i0,j0,sx;
+	u_int32_t i,i1;
+	double w,t;
+	EXTRACT_WORDS(i0,i1,x);
+	sx = (i0>>31)&1;
+	j0 = ((i0>>20)&0x7ff)-0x3ff;
+	if(j0<20) {
+	    if(j0<0) {
+		if(((i0&0x7fffffff)|i1)==0) return x;
+		i1 |= (i0&0x0fffff);
+		i0 &= 0xfffe0000;
+		i0 |= ((i1|-i1)>>12)&0x80000;
+		SET_HIGH_WORD(x,i0);
+	        STRICT_ASSIGN(double,w,TWO52[sx]+x);
+	        t =  w-TWO52[sx];
+		GET_HIGH_WORD(i0,t);
+		SET_HIGH_WORD(t,(i0&0x7fffffff)|(sx<<31));
+	        return t;
+	    } else {
+		i = (0x000fffff)>>j0;
+		if(((i0&i)|i1)==0) return x; /* x is integral */
+		i>>=1;
+		if(((i0&i)|i1)!=0) {
+		    /*
+		     * Some bit is set after the 0.5 bit.  To avoid the
+		     * possibility of errors from double rounding in
+		     * w = TWO52[sx]+x, adjust the 0.25 bit to a lower
+		     * guard bit.  We do this for all j0<=51.  The
+		     * adjustment is trickiest for j0==18 and j0==19
+		     * since then it spans the word boundary.
+		     */
+		    if(j0==19) i1 = 0x40000000; else
+		    if(j0==18) i1 = 0x80000000; else
+		    i0 = (i0&(~i))|((0x20000)>>j0);
+		}
+	    }
+	} else if (j0>51) {
+	    if(j0==0x400) return x+x;	/* inf or NaN */
+	    else return x;		/* x is integral */
+	} else {
+	    i = ((u_int32_t)(0xffffffff))>>(j0-20);
+	    if((i1&i)==0) return x;	/* x is integral */
+	    i>>=1;
+	    if((i1&i)!=0) i1 = (i1&(~i))|((0x40000000)>>(j0-20));
+	}
+	INSERT_WORDS(x,i0,i1);
+	STRICT_ASSIGN(double,w,TWO52[sx]+x);
+	return w-TWO52[sx];
+}
+
+static int freebsd_isnan(double d)
+{
+	if (is_little_endian) {
+	  IEEEd2bits_L u;
+	  u.d = d;
+	  return (u.bits.exp == 2047 && (u.bits.manl != 0 || u.bits.manh != 0));
+	}
+	else {
+      IEEEd2bits_B u;
+	  u.d = d;
+	  return (u.bits.exp == 2047 && (u.bits.manl != 0 || u.bits.manh != 0));
+	}
+}
+
+static double freebsd_fabs(double x)
+{
+	u_int32_t high;
+	GET_HIGH_WORD(high,x);
+	SET_HIGH_WORD(x,high&0x7fffffff);
+        return x;
+}
+
+double sqrt(double x)
+{
+  return freebsd_sqrt(x);
+}
+
+double floor(double x)
+{
+  return freebsd_floor(x);
+}
+
+double ceil(double x)
+{
+  return freebsd_ceil(x);
+}
+
+double fmin(double x, double y)
+{
+  return x < y ? x : y;
+}
+
+double fmax(double x, double y)
+{
+  return x > y ? x : y;
+}
+
+double rint(double x)
+{
+  return freebsd_rint(x);
+}
+
+double fabs(double x)
+{
+  return freebsd_fabs(x);
+}
+
+int isnan(double x)
+{
+  return freebsd_isnan(x);
+}
+
+double trunc(double x)
+{
+  return (x > 0) ? freebsd_floor(x) : freebsd_ceil(x);
+}
+
+int signbit(double x)
+{
+  return ((__HI(x) & 0x80000000) >> 31);
+}
+

core/iwasm/runtime/platform/alios/wasm_platform.c

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "wasm_platform.h"
+
+bool is_little_endian = false;
+
+bool __is_little_endian()
+{
+    union w
+    {
+        int a;
+        char b;
+    }c;
+
+    c.a = 1;
+    return (c.b == 1);
+}
+
+int wasm_platform_init()
+{
+    if (__is_little_endian())
+        is_little_endian = true;
+
+    return 0;
+}
+

core/iwasm/runtime/platform/alios/wasm_platform.h

@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _WASM_PLATFORM_H
+#define _WASM_PLATFORM_H
+
+#include "wasm_config.h"
+#include "wasm_types.h"
+#include <aos/kernel.h>
+#include <inttypes.h>
+
+#include <stdbool.h>
+typedef uint64_t uint64;
+typedef int64_t int64;
+typedef float float32;
+typedef double float64;
+
+#ifndef NULL
+#  define NULL ((void*) 0)
+#endif
+
+#define WASM_PLATFORM "AliOS"
+#define __ALIOS__ 1
+
+#include <stdarg.h>
+#include <ctype.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+/**
+ * Return the offset of the given field in the given type.
+ *
+ * @param Type the type containing the filed
+ * @param field the field in the type
+ *
+ * @return the offset of field in Type
+ */
+#ifndef offsetof
+#define offsetof(Type, field) ((size_t)(&((Type *)0)->field))
+#endif
+
+typedef aos_task_t korp_thread;
+typedef korp_thread *korp_tid;
+typedef aos_mutex_t korp_mutex;
+
+int wasm_platform_init();
+
+extern bool is_little_endian;
+
+#include <string.h>
+
+/* The following operations declared in string.h may be defined as
+   macros on Linux, so don't declare them as functions here.  */
+/* memset */
+/* memcpy */
+/* memmove */
+
+/* #include <stdio.h> */
+
+/* Unit test framework is based on C++, where the declaration of
+   snprintf is different.  */
+#ifndef __cplusplus
+int snprintf(char *buffer, size_t count, const char *format, ...);
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* math functions */
+double sqrt(double x);
+double floor(double x);
+double ceil(double x);
+double fmin(double x, double y);
+double fmax(double x, double y);
+double rint(double x);
+double fabs(double x);
+double trunc(double x);
+int signbit(double x);
+int isnan(double x);
+
+void*
+wasm_dlsym(void *handle, const char *symbol);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

core/iwasm/runtime/vmcore-wasm/wasm_loader.h

@@ -47,7 +47,7 @@ wasm_loader_load(const uint8 *buf, uint32 size, char *error_buf, uint32 error_bu
  */
 WASMModule*
 wasm_loader_load_from_sections(WASMSection *section_list,
-                               char *error_buf, uint32_t error_buf_size);
+                               char *error_buf, uint32 error_buf_size);
 
 /**
  * Unload a WASM module.

core/iwasm/runtime/vmcore-wasm/wasm_runtime.h

@@ -293,30 +293,30 @@ WASMModuleInstance *
 wasm_runtime_get_current_module_inst();
 
 /* See wasm-export.h for description */
-int32_t
-wasm_runtime_module_malloc(WASMModuleInstance *module_inst, uint32_t size);
+int32
+wasm_runtime_module_malloc(WASMModuleInstance *module_inst, uint32 size);
 
 /* See wasm-export.h for description */
 void
-wasm_runtime_module_free(WASMModuleInstance *module_inst, int32_t ptr);
+wasm_runtime_module_free(WASMModuleInstance *module_inst, int32 ptr);
 
 /* See wasm-export.h for description */
 bool
 wasm_runtime_validate_app_addr(WASMModuleInstance *module_inst,
-                               int32_t app_offset, uint32_t size);
+                               int32 app_offset, uint32 size);
 
 /* See wasm-export.h for description */
 bool
 wasm_runtime_validate_native_addr(WASMModuleInstance *module_inst,
-                                  void *native_ptr, uint32_t size);
+                                  void *native_ptr, uint32 size);
 
 /* See wasm-export.h for description */
 void *
 wasm_runtime_addr_app_to_native(WASMModuleInstance *module_inst,
-                                int32_t app_offset);
+                                int32 app_offset);
 
 /* See wasm-export.h for description */
-int32_t
+int32
 wasm_runtime_addr_native_to_app(WASMModuleInstance *module_inst,
                                 void *native_ptr);
 

core/shared-lib/platform/alios/bh_assert.c

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bh_platform.h"
+#include "bh_assert.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef BH_TEST
+#include <setjmp.h>
+#endif
+
+#ifdef BH_TEST
+/* for exception throwing */
+jmp_buf bh_test_jb;
+#endif
+
+void bh_assert_internal(int v, const char *file_name, int line_number, const char *expr_string)
+{
+  if(v) return;
+
+  if(!file_name) file_name = "NULL FILENAME";
+  if(!expr_string) expr_string = "NULL EXPR_STRING";
+
+  printf("\nASSERTION FAILED: %s, at FILE=%s, LINE=%d\n", expr_string, file_name, line_number);
+
+#ifdef BH_TEST
+  longjmp(bh_test_jb, 1);
+#endif
+
+  aos_reboot();
+}
+
+void bh_debug_internal(const char *file_name, int line_number, const char *fmt, ...)
+{
+#ifndef JEFF_TEST_VERIFIER
+  va_list args;
+
+  va_start(args, fmt);
+  bh_assert(file_name);
+
+  printf("\nDebug info FILE=%s, LINE=%d: ", file_name, line_number);
+  vprintf(fmt, args);
+
+  va_end(args);
+  printf("\n");
+#endif
+}
+

core/shared-lib/platform/alios/bh_definition.c

@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bh_definition.h"
+#include "bh_platform.h"
+
+int bh_return(int ret)
+{
+  return ret;
+}
+
+#define RSIZE_MAX 0x7FFFFFFF
+
+int b_memcpy_s(void * s1, unsigned int s1max,
+               const void * s2, unsigned int n)
+{
+  char *dest = (char*)s1;
+  char *src = (char*)s2;
+  if (n == 0) {
+    return 0;
+  }
+
+  if (s1 == NULL || s1max > RSIZE_MAX) {
+    return -1;
+  }
+  if (s2 == NULL || n > s1max) {
+    memset(dest, 0, s1max);
+    return -1;
+  }
+  memcpy(dest, src, n);
+  return 0;
+}
+
+int b_strcat_s(char * s1, size_t s1max, const char * s2)
+{
+  if (NULL == s1 || NULL == s2
+      || s1max < (strlen(s1) + strlen(s2) + 1)
+      || s1max > RSIZE_MAX) {
+    return -1;
+  }
+
+  strcat(s1, s2);
+  return 0;
+}
+
+int b_strcpy_s(char * s1, size_t s1max, const char * s2)
+{
+  if (NULL == s1 || NULL == s2
+      || s1max < (strlen(s2) + 1)
+      || s1max > RSIZE_MAX) {
+    return -1;
+  }
+
+  strcpy(s1, s2);
+  return 0;
+}
+

core/shared-lib/platform/alios/bh_platform.c

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bh_platform.h"
+#include <stdlib.h>
+#include <string.h>
+
+char *bh_strdup(const char *s)
+{
+    char *s1 = NULL;
+    if (s && (s1 = bh_malloc(strlen(s) + 1)))
+        memcpy(s1, s, strlen(s) + 1);
+    return s1;
+}

core/shared-lib/platform/alios/bh_platform.h

@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _BH_PLATFORM_H
+#define _BH_PLATFORM_H
+
+#include "bh_config.h"
+#include "bh_types.h"
+#include "bh_memory.h"
+#include <aos/kernel.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+/* Platform name */
+#define BH_PLATFORM "AliOS-Things"
+
+#define BH_APPLET_PRESERVED_STACK_SIZE (2 * BH_KB)
+
+/* Default thread priority */
+#define BH_THREAD_DEFAULT_PRIORITY 30
+
+#define BH_ROUTINE_MODIFIER
+
+/* Invalid thread tid */
+#define INVALID_THREAD_ID NULL
+
+#define INVALID_SEM_ID NULL
+
+#define BH_WAIT_FOREVER AOS_WAIT_FOREVER
+
+typedef uint64_t uint64;
+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 korp_thread *korp_tid;
+typedef aos_task_t *aos_tid_t;
+typedef aos_mutex_t korp_mutex;
+typedef aos_sem_t korp_sem;
+
+struct bh_thread_wait_node;
+typedef struct bh_thread_wait_node *bh_thread_wait_list;
+typedef struct korp_cond {
+  aos_mutex_t wait_list_lock;
+  bh_thread_wait_list thread_wait_list;
+} korp_cond;
+
+typedef void* (*thread_start_routine_t)(void*);
+
+/* Unit test framework is based on C++, where the declaration of
+   snprintf is different.  */
+#ifndef __cplusplus
+int snprintf(char *buffer, size_t count, const char *format, ...);
+#endif
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+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)
+
+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);
+
+#endif /* end of _BH_PLATFORM_H */
+

core/shared-lib/platform/alios/bh_platform_log.c

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bh_platform.h"
+#include <stdio.h>
+
+
+void bh_log_emit(const char *fmt, va_list ap)
+{
+  vprintf(fmt, ap);
+}
+
+int bh_fprintf(FILE *stream, const char *fmt, ...)
+{
+  (void)stream;
+  va_list ap;
+  int ret;
+
+  va_start(ap, fmt);
+  ret = vprintf(fmt, ap);
+  va_end(ap);
+
+  return ret;
+}
+
+int bh_fflush(void *stream)
+{
+  (void)stream;
+  return 0;
+}
+

core/shared-lib/platform/alios/bh_thread.c

@@ -0,0 +1,447 @@
+/*
+ * INTEL CONFIDENTIAL
+ *
+ * Copyright 2017-2018 Intel Corporation
+ *
+ * This software and the related documents are Intel copyrighted materials,
+ * and your use of them is governed by the express license under which they
+ * were provided to you (License). Unless the License provides otherwise, you
+ * may not use, modify, copy, publish, distribute, disclose or transmit this
+ * software or the related documents without Intel's prior written permission.
+ *
+ * This software and the related documents are provided as is, with no express
+ * or implied warranties, other than those that are expressly stated in the
+ * License.
+*/
+
+#include "bh_thread.h"
+#include "bh_assert.h"
+#include "bh_log.h"
+#include "bh_memory.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+
+struct bh_thread_data;
+typedef struct bh_thread_wait_node {
+  aos_sem_t sem;
+  bh_thread_wait_list next;
+} bh_thread_wait_node;
+
+typedef struct bh_thread_data {
+  /* Thread body */
+  aos_task_t thread;
+  /* Thread start routine */
+  thread_start_routine_t start_routine;
+  /* Thread start routine argument */
+  void *arg;
+  /* Thread local root */
+  void *tlr;
+  /* Wait node of current thread */
+  bh_thread_wait_node wait_node;
+  /* Lock for waiting list */
+  aos_mutex_t wait_list_lock;
+  /* Waiting list of other threads who are joining this thread */
+  bh_thread_wait_list thread_wait_list;
+} bh_thread_data;
+
+static bool is_thread_sys_inited = false;
+
+/* Thread data of supervisor thread */
+static bh_thread_data supervisor_thread_data;
+
+/* Thread data key */
+static aos_task_key_t thread_data_key;
+
+/* Thread name index */
+static int thread_name_index;
+
+int
+_vm_thread_sys_init()
+{
+  if (is_thread_sys_inited)
+    return BHT_OK;
+
+  if (aos_task_key_create(&thread_data_key) != 0)
+    return BHT_ERROR;
+
+  /* Initialize supervisor thread data */
+  memset(&supervisor_thread_data, 0, sizeof(supervisor_thread_data));
+
+  if (aos_sem_new(&supervisor_thread_data.wait_node.sem, 1) != 0) {
+    aos_task_key_delete(thread_data_key);
+    return BHT_ERROR;
+  }
+
+  if (aos_task_setspecific(thread_data_key, &supervisor_thread_data)) {
+    aos_sem_free(&supervisor_thread_data.wait_node.sem);
+    aos_task_key_delete(thread_data_key);
+    return BHT_ERROR;
+  }
+
+  is_thread_sys_inited = true;
+  return BHT_OK;
+}
+
+void
+vm_thread_sys_destroy()
+{
+  if (is_thread_sys_inited) {
+    aos_task_key_delete(thread_data_key);
+    aos_sem_free(&supervisor_thread_data.wait_node.sem);
+    is_thread_sys_inited = false;
+  }
+}
+
+static bh_thread_data *
+thread_data_current()
+{
+  return aos_task_getspecific(thread_data_key);
+}
+
+static void
+vm_thread_cleanup(void)
+{
+  bh_thread_data *thread_data = thread_data_current();
+  bh_thread_wait_list thread_wait_list;
+  aos_mutex_t *wait_list_lock;
+  aos_sem_t *wait_node_sem;
+
+  bh_assert(thread_data != NULL);
+  wait_list_lock = &thread_data->wait_list_lock;
+  thread_wait_list = thread_data->thread_wait_list;
+  wait_node_sem = &thread_data->wait_node.sem;
+
+  /* Free thread data firstly */
+  bh_free(thread_data);
+
+  aos_mutex_lock(wait_list_lock, AOS_WAIT_FOREVER);
+  if (thread_wait_list) {
+    /* Signal each joining thread */
+    bh_thread_wait_list head = thread_wait_list;
+    while (head) {
+      bh_thread_wait_list next = head->next;
+      aos_sem_signal(&head->sem);
+      head = next;
+    }
+  }
+  aos_mutex_unlock(wait_list_lock);
+
+  /* Free sem and lock */
+  aos_sem_free(wait_node_sem);
+  aos_mutex_free(wait_list_lock);
+}
+
+static void
+vm_thread_wrapper(void *arg)
+{
+  bh_thread_data *thread_data = arg;
+
+  /* Set thread custom data */
+  if (!aos_task_setspecific(thread_data_key, thread_data))
+    thread_data->start_routine(thread_data->arg);
+
+  vm_thread_cleanup();
+}
+
+int
+_vm_thread_create(korp_tid *p_tid, thread_start_routine_t start,
+                  void *arg, unsigned int stack_size)
+{
+  return _vm_thread_create_with_prio(p_tid, start, arg, stack_size,
+                                     BH_THREAD_DEFAULT_PRIORITY);
+}
+
+int
+_vm_thread_create_with_prio(korp_tid *p_tid, thread_start_routine_t start,
+                            void *arg, unsigned int stack_size, int prio)
+{
+  bh_thread_data *thread_data;
+  char thread_name[32];
+
+  if (!p_tid || !stack_size)
+    return BHT_ERROR;
+
+  /* Create and initialize thread data */
+  if (!(thread_data = bh_malloc(sizeof(bh_thread_data))))
+    return BHT_ERROR;
+
+  memset(thread_data, 0, sizeof(bh_thread_data));
+
+  thread_data->start_routine = start;
+  thread_data->arg = arg;
+
+  if (aos_sem_new(&thread_data->wait_node.sem, 1) != 0)
+    goto fail1;
+
+  if (aos_mutex_new(&thread_data->wait_list_lock))
+    goto fail2;
+
+  snprintf(thread_name, sizeof(thread_name), "%s%d",
+           "wasm-thread-", ++thread_name_index);
+
+  /* Create the thread */
+  if (aos_task_new_ext((aos_task_t*)thread_data, thread_name,
+                        vm_thread_wrapper, thread_data,
+                        stack_size, prio))
+    goto fail3;
+
+  aos_msleep(10);
+  *p_tid = (korp_tid)thread_data;
+  return BHT_OK;
+
+fail3:
+  aos_mutex_free(&thread_data->wait_list_lock);
+fail2:
+  aos_sem_free(&thread_data->wait_node.sem);
+fail1:
+  bh_free(thread_data);
+  return BHT_ERROR;
+}
+
+korp_tid
+_vm_self_thread()
+{
+  return (korp_tid)aos_task_getspecific(thread_data_key);
+}
+
+void
+vm_thread_exit(void * code)
+{
+  vm_thread_cleanup();
+  aos_task_exit((int)(intptr_t)code);
+}
+
+int
+_vm_thread_cancel (korp_tid thread)
+{
+  /* TODO */
+  return 0;
+}
+
+int
+_vm_thread_join (korp_tid thread, void **value_ptr, int mills)
+{
+  (void)value_ptr;
+  bh_thread_data *thread_data, *curr_thread_data;
+
+  /* Get thread data of current thread */
+  curr_thread_data = thread_data_current();
+  curr_thread_data->wait_node.next = NULL;
+
+  /* Get thread data */
+  thread_data = (bh_thread_data*)thread;
+
+  aos_mutex_lock(&thread_data->wait_list_lock, AOS_WAIT_FOREVER);
+  if (!thread_data->thread_wait_list)
+    thread_data->thread_wait_list = &curr_thread_data->wait_node;
+  else {
+    /* Add to end of waiting list */
+    bh_thread_wait_node *p = thread_data->thread_wait_list;
+    while (p->next)
+      p = p->next;
+    p->next = &curr_thread_data->wait_node;
+  }
+  aos_mutex_unlock(&thread_data->wait_list_lock);
+
+  /* Wait the sem */
+  aos_sem_wait(&curr_thread_data->wait_node.sem, mills);
+
+  return BHT_OK;
+}
+
+int
+_vm_thread_detach (korp_tid thread)
+{
+  (void)thread;
+  return BHT_OK;
+}
+
+void *
+_vm_tls_get(unsigned idx)
+{
+  (void)idx;
+  bh_thread_data *thread_data;
+
+  bh_assert (idx == 0);
+  thread_data = thread_data_current();
+
+  return thread_data ? thread_data->tlr : NULL;
+}
+
+int
+_vm_tls_put(unsigned idx, void * tls)
+{
+  bh_thread_data *thread_data;
+
+  (void)idx;
+  bh_assert (idx == 0);
+  thread_data = thread_data_current();
+  bh_assert (thread_data != NULL);
+
+  thread_data->tlr = tls;
+  return BHT_OK;
+}
+
+int
+_vm_mutex_init(korp_mutex *mutex)
+{
+  return aos_mutex_new(mutex) == 0 ? BHT_OK : BHT_ERROR;
+}
+
+int
+_vm_recursive_mutex_init(korp_mutex *mutex)
+{
+  return aos_mutex_new(mutex) == 0 ? BHT_OK : BHT_ERROR;
+}
+
+int
+_vm_mutex_destroy(korp_mutex *mutex)
+{
+  aos_mutex_free(mutex);
+  return BHT_OK;
+}
+
+void
+vm_mutex_lock(korp_mutex *mutex)
+{
+  aos_mutex_lock(mutex, AOS_WAIT_FOREVER);
+}
+
+int
+vm_mutex_trylock(korp_mutex *mutex)
+{
+  return aos_mutex_lock(mutex, AOS_NO_WAIT);
+}
+
+void vm_mutex_unlock(korp_mutex *mutex)
+{
+  aos_mutex_unlock(mutex);
+}
+
+int _vm_sem_init(korp_sem* sem, unsigned int c)
+{
+  return aos_sem_new(sem, c) == 0 ? BHT_OK : BHT_ERROR;
+}
+
+int _vm_sem_destroy(korp_sem *sem)
+{
+  aos_sem_free(sem);
+  return BHT_OK;
+}
+
+int _vm_sem_wait(korp_sem *sem)
+{
+  return aos_sem_wait(sem, AOS_WAIT_FOREVER);
+}
+
+int _vm_sem_reltimedwait(korp_sem *sem, int mills)
+{
+  return aos_sem_wait(sem, mills);
+}
+
+int _vm_sem_post(korp_sem *sem)
+{
+  aos_sem_signal(sem);
+  return BHT_OK;
+}
+
+int
+_vm_cond_init(korp_cond *cond)
+{
+  if (aos_mutex_new(&cond->wait_list_lock) != 0)
+    return BHT_ERROR;
+
+  cond->thread_wait_list = NULL;
+  return BHT_OK;
+}
+
+int
+_vm_cond_destroy(korp_cond *cond)
+{
+  aos_mutex_free(&cond->wait_list_lock);
+  return BHT_OK;
+}
+
+static int
+vm_cond_wait_internal(korp_cond *cond, korp_mutex *mutex,
+                      bool timed, int mills)
+{
+  bh_thread_wait_node *node = &thread_data_current()->wait_node;
+
+  node->next = NULL;
+
+  aos_mutex_lock(&cond->wait_list_lock, AOS_WAIT_FOREVER);
+  if (!cond->thread_wait_list)
+    cond->thread_wait_list = node;
+  else {
+    /* Add to end of wait list */
+    bh_thread_wait_node *p = cond->thread_wait_list;
+    while (p->next)
+      p = p->next;
+    p->next = node;
+  }
+  aos_mutex_unlock(&cond->wait_list_lock);
+
+  /* Unlock mutex, wait sem and lock mutex again */
+  aos_mutex_unlock(mutex);
+  aos_sem_wait(&node->sem, timed ? mills : AOS_WAIT_FOREVER);
+  aos_mutex_lock(mutex, AOS_WAIT_FOREVER);
+
+  /* Remove wait node from wait list */
+  aos_mutex_lock(&cond->wait_list_lock, AOS_WAIT_FOREVER);
+  if (cond->thread_wait_list == node)
+    cond->thread_wait_list = node->next;
+  else {
+    /* Remove from the wait list */
+    bh_thread_wait_node *p = cond->thread_wait_list;
+    while (p->next != node)
+      p = p->next;
+    p->next = node->next;
+  }
+  aos_mutex_unlock(&cond->wait_list_lock);
+
+  return BHT_OK;
+}
+
+int
+_vm_cond_wait(korp_cond *cond, korp_mutex *mutex)
+{
+  return vm_cond_wait_internal(cond, mutex, false, 0);
+}
+
+int
+_vm_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, int mills)
+{
+  return vm_cond_wait_internal(cond, mutex, true, mills);
+}
+
+int
+_vm_cond_signal(korp_cond *cond)
+{
+  /* Signal the head wait node of wait list */
+  aos_mutex_lock(&cond->wait_list_lock, AOS_WAIT_FOREVER);
+  if (cond->thread_wait_list)
+    aos_sem_signal(&cond->thread_wait_list->sem);
+  aos_mutex_unlock(&cond->wait_list_lock);
+
+  return BHT_OK;
+}
+
+int
+_vm_cond_broadcast (korp_cond *cond)
+{
+  /* Signal each wait node of wait list */
+  aos_mutex_lock(&cond->wait_list_lock, AOS_WAIT_FOREVER);
+  if (cond->thread_wait_list) {
+    bh_thread_wait_node *p = cond->thread_wait_list;
+    while (p) {
+      aos_sem_signal(&p->sem);
+      p = p->next;
+    }
+  }
+  aos_mutex_unlock(&cond->wait_list_lock);
+
+  return BHT_OK;
+}
+

core/shared-lib/platform/alios/bh_time.c

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "bh_time.h"
+
+/*
+ * This function returns milliseconds per tick.
+ * @return milliseconds per tick.
+ */
+uint64 _bh_time_get_tick_millisecond()
+{
+  return aos_get_hz() / 1000();
+}
+
+/*
+ * This function returns milliseconds after boot.
+ * @return milliseconds after boot.
+ */
+uint64 _bh_time_get_boot_millisecond()
+{
+  return (uint64)aos_now_ms();
+}
+
+uint64 _bh_time_get_millisecond_from_1970()
+{
+  return (uint64)aos_now_ms();
+}
+
+size_t
+_bh_time_strftime (char *str, size_t max, const char *format, int64 time)
+{
+  str = aos_now_time_str(str, max);
+  return str ? strlen(str) + 1 : 0;
+}
+

core/shared-lib/platform/alios/shared_platform.cmake

@@ -0,0 +1,24 @@
+# Copyright (C) 2019 Intel Corporation.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set (PLATFORM_SHARED_DIR ${CMAKE_CURRENT_LIST_DIR})
+
+include_directories(${PLATFORM_SHARED_DIR})
+include_directories(${PLATFORM_SHARED_DIR}/../include)
+
+
+file (GLOB_RECURSE source_all ${PLATFORM_SHARED_DIR}/*.c)
+
+set (PLATFORM_SHARED_SOURCE ${source_all})
+