Merge main into dev/fast_jit

Author: wenyongh

build-scripts/build_llvm.py

@@ -208,7 +208,7 @@ def main():
         },
         "xtensa": {
             "repo": "https://github.com/espressif/llvm-project.git",
-            "branch": "xtensa_release_11.0.0",
+            "branch": "xtensa_release_13.0.0",
         },
         "default": {
             "repo": "https://github.com/llvm/llvm-project.git",

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

@@ -8,7 +8,7 @@
 
 #include "runtime_timer.h"
 
-void
+bool
 init_wasm_timer();
 void
 exit_wasm_timer();

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

@@ -83,19 +83,36 @@ wakeup_modules_timer_thread(timer_ctx_t ctx)
     os_mutex_unlock(&g_timer_ctx_list_mutex);
 }
 
-void
+bool
 init_wasm_timer()
 {
     korp_tid tm_tid;
     bh_list_init(&g_timer_ctx_list);
 
-    os_cond_init(&g_timer_ctx_list_cond);
+    if (os_cond_init(&g_timer_ctx_list_cond) != 0) {
+        return false;
+    }
     /* temp solution for: thread_modulers_timer_check thread
        would recursive lock the mutex */
-    os_recursive_mutex_init(&g_timer_ctx_list_mutex);
+    if (os_recursive_mutex_init(&g_timer_ctx_list_mutex) != 0) {
+        goto fail1;
+    }
+
+    if (0
+        != os_thread_create(&tm_tid, thread_modulers_timer_check, NULL,
+                            BH_APPLET_PRESERVED_STACK_SIZE)) {
+        goto fail2;
+    }
+
+    return true;
+
+fail2:
+    os_mutex_destroy(&g_timer_ctx_list_mutex);
+
+fail1:
+    os_cond_destroy(&g_timer_ctx_list_cond);
 
-    os_thread_create(&tm_tid, thread_modulers_timer_check, NULL,
-                     BH_APPLET_PRESERVED_STACK_SIZE);
+    return false;
 }
 
 void

core/app-framework/sensor/native/runtime_sensor.c

@@ -309,7 +309,13 @@ add_sys_sensor(char *name, char *description, int instance,
         g_sys_sensors = s;
     }
 
-    os_mutex_init(&s->lock);
+    if (os_mutex_init(&s->lock) != 0) {
+        if (s->description) {
+            wasm_runtime_free(s->description);
+        }
+        wasm_runtime_free(s->name);
+        wasm_runtime_free(s);
+    }
 
     return s;
 }
@@ -358,6 +364,7 @@ find_sensor_client(sys_sensor_t *sensor, unsigned int client_id,
             return c;
         }
         else {
+            prev = c;
             c = c->next;
         }
     }

core/app-framework/sensor/native/runtime_sensor.h

@@ -59,7 +59,7 @@ check_sensor_timers();
 void
 reschedule_sensor_read();
 
-void
+bool
 init_sensor_framework();
 void
 start_sensor_framework();

core/app-framework/sensor/native/sensor_mgr_ref.c

@@ -106,19 +106,27 @@ cb_wakeup_thread()
 void
 set_sensor_reshceduler(void (*callback)());
 
-void
+bool
 init_sensor_framework()
 {
-    // init the mutext and conditions
-    os_cond_init(&cond);
-    os_mutex_init(&mutex);
+    /* init the mutext and conditions */
+    if (os_cond_init(&cond) != 0) {
+        return false;
+    }
+
+    if (os_mutex_init(&mutex) != 0) {
+        os_cond_destroy(&cond);
+        return false;
+    }
 
     set_sensor_reshceduler(cb_wakeup_thread);
 
     wasm_register_msg_callback(SENSOR_EVENT_WASM,
                                app_mgr_sensor_event_callback);
 
     wasm_register_cleanup_callback(sensor_cleanup_callback);
+
+    return true;
 }
 
 void

core/app-mgr/app-manager/app_manager_host.c

@@ -264,15 +264,21 @@ aee_host_msg_callback(void *msg, uint32_t msg_len)
 bool
 app_manager_host_init(host_interface *interface)
 {
-    os_mutex_init(&host_lock);
+    if (os_mutex_init(&host_lock) != 0) {
+        return false;
+    }
     memset(&recv_ctx, 0, sizeof(recv_ctx));
 
     host_commu.init = interface->init;
     host_commu.send = interface->send;
     host_commu.destroy = interface->destroy;
 
-    if (host_commu.init != NULL)
-        return host_commu.init();
+    if (host_commu.init != NULL) {
+        if (!host_commu.init()) {
+            os_mutex_destroy(&host_lock);
+            return false;
+        }
+    }
 
     return true;
 }

core/app-mgr/app-manager/module_wasm_app.c

@@ -207,10 +207,12 @@ app_instance_queue_callback(void *queue_msg, void *arg)
 
     wasm_module_inst_t inst = (wasm_module_inst_t)arg;
     module_data *m_data = app_manager_get_module_data(Module_WASM_App, inst);
-    wasm_data *wasm_app_data = (wasm_data *)m_data->internal_data;
-    int message_type = bh_message_type(queue_msg);
+    wasm_data *wasm_app_data;
+    int message_type;
 
     bh_assert(m_data);
+    wasm_app_data = (wasm_data *)m_data->internal_data;
+    message_type = bh_message_type(queue_msg);
 
     if (message_type < BASE_EVENT_MAX) {
         switch (message_type) {
@@ -410,16 +412,15 @@ wasm_app_prepare_wasi_dir(wasm_module_t module, const char *module_name,
     p += module_name_len;
     *p++ = '\0';
 
-    /* Create a wasi dir for the module */
-    if (stat(wasi_dir_buf, &st) == 0) {
-        /* exist, but is a regular file, not a dir */
-        if (st.st_mode & S_IFREG)
-            return false;
-    }
-    else {
-        /* not exist, create it */
-        if (mkdir(wasi_dir_buf, 0777) != 0)
-            return false;
+    if (mkdir(wasi_dir_buf, 0777) != 0) {
+        if (errno == EEXIST) {
+            /* Failed due to dir already exist */
+            if ((stat(wasi_dir_buf, &st) == 0) && (st.st_mode & S_IFDIR)) {
+                return true;
+            }
+        }
+
+        return false;
     }
 
     return true;
@@ -491,9 +492,16 @@ wasm_app_routine(void *arg)
 fail2:
     /* Call WASM app onDestroy() method if there is */
     func_onDestroy = app_manager_lookup_function(inst, "_on_destroy", "()");
-    if (func_onDestroy)
-        wasm_runtime_call_wasm(wasm_app_data->exec_env, func_onDestroy, 0,
-                               NULL);
+    if (func_onDestroy) {
+        if (!wasm_runtime_call_wasm(wasm_app_data->exec_env, func_onDestroy, 0,
+                                    NULL)) {
+            const char *exception = wasm_runtime_get_exception(inst);
+            bh_assert(exception);
+            app_manager_printf("Got exception running WASM code: %s\n",
+                               exception);
+            wasm_runtime_clear_exception(inst);
+        }
+    }
 
 fail1:
 

core/iwasm/aot/aot_loader.c

@@ -261,48 +261,34 @@ load_string(uint8 **p_buf, const uint8 *buf_end, AOTModule *module,
     char *str;
     uint16 str_len;
 
-    CHECK_BUF(p, p_end, 1);
-    if (*p & 0x80) {
-        /* The string has been adjusted */
-        str = (char *)++p;
-        /* Ensure the whole string is in range */
-        do {
-            CHECK_BUF(p, p_end, 1);
-        } while (*p++ != '\0');
+    read_uint16(p, p_end, str_len);
+    CHECK_BUF(p, p_end, str_len);
+
+    if (str_len == 0) {
+        str = "";
+    }
+    else if (p[str_len - 1] == '\0') {
+        /* The string is terminated with '\0', use it directly */
+        str = (char *)p;
+    }
+    else if (is_load_from_file_buf) {
+        /* As the file buffer can be referred to after loading,
+           we use the 2 bytes of size to adjust the string:
+           move string 2 byte backward and then append '\0' */
+        str = (char *)(p - 2);
+        bh_memmove_s(str, (uint32)(str_len + 1), p, (uint32)str_len);
+        str[str_len] = '\0';
     }
     else {
-        /* The string hasn't been adjusted */
-        read_uint16(p, p_end, str_len);
-        CHECK_BUF(p, p_end, str_len);
-
-        if (str_len == 0) {
-            str = "";
-        }
-        else if (p[str_len - 1] == '\0') {
-            /* The string is terminated with '\0', use it directly */
-            str = (char *)p;
-        }
-        else if (is_load_from_file_buf) {
-            /* As the file buffer can be referred to after loading,
-               we use the 2 bytes of size to adjust the string:
-               mark the flag with the highest bit of size[0],
-               move string 1 byte backward and then append '\0' */
-            *(p - 2) |= 0x80;
-            bh_memmove_s(p - 1, (uint32)(str_len + 1), p, (uint32)str_len);
-            p[str_len - 1] = '\0';
-            str = (char *)(p - 1);
-        }
-        else {
-            /* Load from sections, the file buffer cannot be reffered to
-               after loading, we must create another string and insert it
-               into const string set */
-            if (!(str = const_str_set_insert((uint8 *)p, str_len, module,
-                                             error_buf, error_buf_size))) {
-                goto fail;
-            }
+        /* Load from sections, the file buffer cannot be reffered to
+           after loading, we must create another string and insert it
+           into const string set */
+        if (!(str = const_str_set_insert((uint8 *)p, str_len, module, error_buf,
+                                         error_buf_size))) {
+            goto fail;
         }
-        p += str_len;
     }
+    p += str_len;
 
     *p_buf = p;
     return str;
@@ -1850,7 +1836,9 @@ do_text_relocation(AOTModule *module, AOTRelocationGroup *group,
                  || !strcmp(symbol, ".rdata")
                  || !strcmp(symbol, ".rodata")
                  /* ".rodata.cst4/8/16/.." */
-                 || !strncmp(symbol, ".rodata.cst", strlen(".rodata.cst"))) {
+                 || !strncmp(symbol, ".rodata.cst", strlen(".rodata.cst"))
+                 /* ".rodata.strn.m" */
+                 || !strncmp(symbol, ".rodata.str", strlen(".rodata.str"))) {
             symbol_addr = get_data_section_addr(module, symbol, NULL);
             if (!symbol_addr) {
                 set_error_buf_v(error_buf, error_buf_size,
@@ -2054,6 +2042,7 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
     uint8 *symbol_buf, *symbol_buf_end;
     int map_prot, map_flags;
     bool ret = false;
+    char **symbols = NULL;
 
     read_uint32(buf, buf_end, symbol_count);
 
@@ -2074,6 +2063,14 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
         goto fail;
     }
 
+    if (symbol_count > 0) {
+        symbols = loader_malloc((uint64)sizeof(*symbols) * symbol_count,
+                                error_buf, error_buf_size);
+        if (symbols == NULL) {
+            goto fail;
+        }
+    }
+
 #if defined(BH_PLATFORM_WINDOWS)
     buf = symbol_buf_end;
     read_uint32(buf, buf_end, group_count);
@@ -2208,7 +2205,6 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
     for (i = 0, group = groups; i < group_count; i++, group++) {
         AOTRelocation *relocation;
         uint32 name_index;
-        uint8 *name_addr;
 
         /* section name address is 4 bytes aligned. */
         buf = (uint8 *)align_ptr(buf, sizeof(uint32));
@@ -2220,8 +2216,12 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
             goto fail;
         }
 
-        name_addr = symbol_buf + symbol_offsets[name_index];
-        read_string(name_addr, buf_end, group->section_name);
+        if (symbols[name_index] == NULL) {
+            uint8 *name_addr = symbol_buf + symbol_offsets[name_index];
+
+            read_string(name_addr, buf_end, symbols[name_index]);
+        }
+        group->section_name = symbols[name_index];
 
         read_uint32(buf, buf_end, group->relocation_count);
 
@@ -2236,7 +2236,6 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
         /* Load each relocation */
         for (j = 0; j < group->relocation_count; j++, relocation++) {
             uint32 symbol_index;
-            uint8 *symbol_addr;
 
             if (sizeof(void *) == 8) {
                 read_uint64(buf, buf_end, relocation->relocation_offset);
@@ -2258,8 +2257,12 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
                 goto fail;
             }
 
-            symbol_addr = symbol_buf + symbol_offsets[symbol_index];
-            read_string(symbol_addr, buf_end, relocation->symbol_name);
+            if (symbols[symbol_index] == NULL) {
+                uint8 *symbol_addr = symbol_buf + symbol_offsets[symbol_index];
+
+                read_string(symbol_addr, buf_end, symbols[symbol_index]);
+            }
+            relocation->symbol_name = symbols[symbol_index];
         }
 
         if (!strcmp(group->section_name, ".rel.text")
@@ -2314,14 +2317,20 @@ load_relocation_section(const uint8 *buf, const uint8 *buf_end,
             || !strcmp(data_section->name, ".rodata")
             /* ".rodata.cst4/8/16/.." */
             || !strncmp(data_section->name, ".rodata.cst",
-                        strlen(".rodata.cst"))) {
+                        strlen(".rodata.cst"))
+            /* ".rodata.strn.m" */
+            || !strncmp(data_section->name, ".rodata.str",
+                        strlen(".rodata.str"))) {
             os_mprotect(data_section->data, data_section->size, map_prot);
         }
     }
 
     ret = true;
 
 fail:
+    if (symbols) {
+        wasm_runtime_free(symbols);
+    }
     if (groups) {
         for (i = 0, group = groups; i < group_count; i++, group++)
             if (group->relocations)