Added requested changes

Author: 1c3t3a

core/shared/platform/esp-idf/espidf_malloc.c

@@ -1,3 +1,8 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
 #include "platform_api_vmcore.h"
 #include "platform_api_extension.h"
 
@@ -6,16 +11,16 @@ os_malloc(unsigned size)
 {
     void *buf_origin;
     void *buf_fixed;
-    uint32 *addr_field;
+    uintptr_t *addr_field;
 
-    buf_origin = malloc(size + 8 + sizeof(uint32));
+    buf_origin = malloc(size + 8 + sizeof(uintptr_t));
     buf_fixed = buf_origin + sizeof(void *);
-    if ((uint32)buf_fixed & 0x7) {
-        buf_fixed = (void *)((size_t)(buf_fixed + 8) & (~7));
+    if ((uintptr_t)buf_fixed & (uintptr_t)0x7) {
+        buf_fixed = (void *)((uintptr_t)(buf_fixed + 8) & (~(uintptr_t)7));
     }
 
-    addr_field = buf_fixed - sizeof(uint32);
-    *addr_field = (uint32)buf_origin;
+    addr_field = buf_fixed - sizeof(uintptr_t);
+    *addr_field = (uintptr_t)buf_origin;
 
     return buf_fixed;
 }
@@ -26,24 +31,25 @@ os_realloc(void *ptr, unsigned size)
     void *mem_origin;
     void *mem_new;
     void *mem_new_fixed;
-    int *addr_field;
+    uintptr_t *addr_field;
 
     if (!ptr) {
         return NULL;
     }
 
-    addr_field = ptr - sizeof(uint32);
+    addr_field = ptr - sizeof(uintptr_t);
     mem_origin = (void *)(*addr_field);
-    mem_new = realloc(mem_origin, size + 8 + sizeof(uint32));
+    mem_new = realloc(mem_origin, size + 8 + sizeof(uintptr_t));
 
     if (mem_origin != mem_new) {
-        mem_new_fixed = mem_new + sizeof(uint32);
+        mem_new_fixed = mem_new + sizeof(uintptr_t);
         if ((uint32)mem_new_fixed & 0x7) {
-            mem_new_fixed = (void *)((uint32)(mem_new_fixed + 8) & (~7));
+            mem_new_fixed =
+                (void *)((uintptr_t)(mem_new + 8) & (~(uintptr_t)7));
         }
 
-        addr_field = mem_new_fixed - sizeof(uint32);
-        *addr_field = (uint32)mem_new;
+        addr_field = mem_new_fixed - sizeof(uintptr_t);
+        *addr_field = (uintptr_t)mem_new;
 
         return mem_new_fixed;
     }
@@ -55,10 +61,10 @@ void
 os_free(void *ptr)
 {
     void *mem_origin;
-    uint32 *addr_field;
+    uintptr *addr_field;
 
     if (ptr) {
-        addr_field = ptr - sizeof(uint32);
+        addr_field = ptr - sizeof(uintptr_t);
         mem_origin = (void *)(*addr_field);
 
         free(mem_origin);

core/shared/platform/esp-idf/espidf_memmap.c

@@ -1,16 +1,21 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
 #include "platform_api_vmcore.h"
 #include "platform_api_extension.h"
 
 void *
 os_mmap(void *hint, size_t size, int prot, int flags)
 {
-    return malloc((int)size);
+    return os_malloc((int)size);
 }
 
 void
 os_munmap(void *addr, size_t size)
 {
-    return free(addr);
+    return os_free(addr);
 }
 
 int

core/shared/platform/esp-idf/espidf_platform.c

@@ -19,7 +19,14 @@ bh_platform_destroy()
 int
 os_printf(const char *format, ...)
 {
-    return printf(format);
+    int ret = 0;
+    va_list ap;
+
+    va_start(ap, format);
+    ret += vprintf(format, ap);
+    va_end(ap);
+
+    return ret;
 }
 
 int

core/shared/platform/esp-idf/espidf_thread.c

@@ -31,8 +31,8 @@ os_thread_wrapper(void *arg)
 korp_tid
 os_self_thread(void)
 {
-    // only allowed if this is a thread, xTaskCreate is not enough
-    // look at product_mini for how to use this
+    /* only allowed if this is a thread, xTaskCreate is not enough look at
+     * product_mini for how to use this*/
     return pthread_self();
 }
 
@@ -143,6 +143,43 @@ os_cond_wait(korp_cond *cond, korp_mutex *mutex)
     return pthread_cond_wait(cond, mutex);
 }
 
+static void
+msec_nsec_to_abstime(struct timespec *ts, uint64 usec)
+{
+    struct timeval tv;
+    time_t tv_sec_new;
+    long int tv_nsec_new;
+
+    gettimeofday(&tv, NULL);
+
+    tv_sec_new = (time_t)(tv.tv_sec + usec / 1000000);
+    if (tv_sec_new >= tv.tv_sec) {
+        ts->tv_sec = tv_sec_new;
+    }
+    else {
+        /* integer overflow */
+        ts->tv_sec = BH_TIME_T_MAX;
+        os_printf("Warning: os_cond_reltimedwait exceeds limit, "
+                  "set to max timeout instead\n");
+    }
+
+    tv_nsec_new = (long int)(tv.tv_usec * 1000 + (usec % 1000000) * 1000);
+    if (tv.tv_usec * 1000 >= tv.tv_usec && tv_nsec_new >= tv.tv_usec * 1000) {
+        ts->tv_nsec = tv_nsec_new;
+    }
+    else {
+        /* integer overflow */
+        ts->tv_nsec = LONG_MAX;
+        os_printf("Warning: os_cond_reltimedwait exceeds limit, "
+                  "set to max timeout instead\n");
+    }
+
+    if (ts->tv_nsec >= 1000000000L && ts->tv_sec < BH_TIME_T_MAX) {
+        ts->tv_sec++;
+        ts->tv_nsec -= 1000000000L;
+    }
+}
+
 int
 os_cond_reltimedwait(korp_cond *cond, korp_mutex *mutex, uint64 useconds)
 {

doc/build_wamr.md

@@ -464,13 +464,13 @@ ESP-IDF
 -------------------------
 WAMR integrates with ESP-IDF both for the XTENSA and RISC-V chips (esp32x and esp32c3 respectively). 
 
-In order to use this, you need version at least version 4.3.1 of ESP-IDF. 
+In order to use this, you need at least version 4.3.1 of ESP-IDF.
 If you don't have it installed, follow the instructions [here](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/#get-started-get-prerequisites).
 ESP-IDF also installs the toolchains needed for compiling WAMR and ESP-IDF.
 A small demonstration of how to use WAMR and ESP-IDF can be found under [product_mini](/product-mini/platforms/esp-idf).
 The demo builds WAMR for ESP-IDF and runs a small wasm program. 
-In order to run it for you're specific Espressif chip, edit the ['build.sh'](/product-mini/platforms/esp-idf/build.sh) file and put the correct toolchain file (see #Cross-compilation) and `IDF_TARGET`.
-Before compiling it is also necessary to calls ESP-IDF's `export.sh` script to bring all compile time relevant information in scope.
+In order to run it for your specific Espressif chip, edit the ['build.sh'](/product-mini/platforms/esp-idf/build.sh) file and put the correct toolchain file (see #Cross-compilation) and `IDF_TARGET`.
+Before compiling it is also necessary to call ESP-IDF's `export.sh` script to bring all compile time relevant information in scope.
 
 Docker
 -------------------------

product-mini/platforms/esp-idf/CMakeLists.txt

@@ -7,7 +7,9 @@ project(wamr_on_esp32c3)
 
 enable_language(ASM)
 
-set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3")
+if (NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release)
+endif ()
 
 if("${IDF_TARGET}" STREQUAL "")
     message(FATAL_ERROR "You need to set IDF_TARGET to your target string")
@@ -36,11 +38,27 @@ else()
 endif()
 
 set(WAMR_BUILD_PLATFORM "esp-idf")
-set(WAMR_BUILD_INTERP 1)
-set(WAMR_BUILD_FAST_INTERP 0)
-set(WAMR_BUILD_AOT 0)
-set(WAMR_BUILD_LIBC_BUILTIN 1)
-set(WAMR_BUILD_APP_FRAMEWORK 0)
+
+if (NOT DEFINED WAMR_BUILD_INTERP)
+  set (WAMR_BUILD_INTERP 0)
+endif ()
+
+if (NOT DEFINED WAMR_BUILD_FAST_INTERP)
+  set (WAMR_BUILD_FAST_INTERP 0)
+endif ()
+
+if (NOT DEFINED WAMR_BUILD_AOT)
+  set (WAMR_BUILD_AOT 1)
+endif ()
+
+if (NOT DEFINED WAMR_BUILD_LIBC_BUILTIN)
+  set (WAMR_BUILD_LIBC_BUILTIN 1)
+endif ()
+
+if (NOT DEFINED WAMR_BUILD_APP_FRAMEWORK)
+  set (WAMR_BUILD_APP_FRAMEWORK 0)
+endif ()
+
 
 # Set the compile time variable so that the right binary is selected
 add_compile_options(-DWAMR_BUILD_INTERP=${WAMR_BUILD_INTERP})

product-mini/platforms/esp-idf/main.c

@@ -8,7 +8,6 @@
 #include "wasm_export.h"
 #include "aot_export.h"
 #include "bh_platform.h"
-#include "platform_api_vmcore.h"
 #include "test_wasm.h"
 
 static void *
@@ -29,14 +28,14 @@ iwasm_main(void *arg)
 
     printf("about to set up the stuff\n");
 
-    // setup variables for instantiating and running the wasm module
+    /* setup variables for instantiating and running the wasm module */
     uint8_t *wasm_file_buf = NULL;
     unsigned wasm_file_buf_size = 0;
     wasm_module_t wasm_module = NULL;
     wasm_module_inst_t wasm_module_inst = NULL;
     char error_buf[128];
 
-    // configure memory allocation
+    /* configure memory allocation */
     RuntimeInitArgs init_args;
     memset(&init_args, 0, sizeof(RuntimeInitArgs));
 
@@ -46,22 +45,22 @@ iwasm_main(void *arg)
     init_args.mem_alloc_option.allocator.free_func = (void *)os_free;
 
     printf("wasm_runtime_full_init\n");
-    // initialize runtime environment
+    /* initialize runtime environment */
     if (!wasm_runtime_full_init(&init_args)) {
         printf("Init runtime failed.\n");
         return NULL;
     }
 
-    // load WASM byte buffer from byte buffer of include file
+    /* load WASM byte buffer from byte buffer of include file */
     printf("use an internal test file, that's going to output Hello World\n");
     wasm_file_buf = (uint8_t *)wasm_test_file;
     wasm_file_buf_size = sizeof(wasm_test_file);
 
-    // load WASM module
+    /* load WASM module */
     if (!(wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_buf_size,
                                           error_buf, sizeof(error_buf)))) {
         printf("Error in wasm_runtime_load: %s\n", error_buf);
-        goto fail2;
+        goto fail1;
     }
 
     printf("about to call wasm_runtime_instantiate\n");
@@ -70,24 +69,24 @@ iwasm_main(void *arg)
                                        32 * 1024,              // heap size
                                        error_buf, sizeof(error_buf)))) {
         printf("Error while instantiating: %s\n", error_buf);
-        goto fail1;
+        goto fail2;
     }
 
     printf("run main() of the application\n");
     void *ret = app_instance_main(wasm_module_inst);
     assert(!ret);
 
-fail1:
-    // destroy the module instance
+    /* destroy the module instance */
     printf("wasm_runtime_deinstantiate\n");
     wasm_runtime_deinstantiate(wasm_module_inst);
 
 fail2:
-    // unload the module
+    /* unload the module */
     printf("wasm_runtime_unload\n");
     wasm_runtime_unload(wasm_module);
 
-    // destroy runtime environment
+fail1:
+    /* destroy runtime environment */
     printf("wasm_runtime_destroy\n");
     wasm_runtime_destroy();