fix: put additional checks in wasm_runtime_is_underlying_binary_freeable

core/iwasm/common/wasm_c_api.c

@@ -2999,10 +2999,13 @@ wasm_module_get_name(wasm_module_t *module)
 }
 
 bool
-wasm_module_is_underlying_binary_freeable(const wasm_module_t *module)
+wasm_module_is_underlying_binary_freeable(
+    const wasm_module_t *module, const struct wasm_instance_t *instance)
 {
-    return ((wasm_module_ex_t *)module)->is_binary_cloned
-           && wasm_runtime_is_underlying_binary_freeable(*module);
+    if (((wasm_module_ex_t *)module)->is_binary_cloned)
+        return true;
+
+    return wasm_runtime_is_underlying_binary_freeable(instance->inst_comm_rt);
 }
 
 static wasm_func_t *

core/iwasm/common/wasm_runtime_common.c

@@ -1389,6 +1389,7 @@ wasm_runtime_load(uint8 *buf, uint32 size, char *error_buf,
 {
     LoadArgs args = { 0 };
     args.name = "";
+    args.wasm_binary_freeable = false;
     return wasm_runtime_load_ex(buf, size, &args, error_buf, error_buf_size);
 }
 
@@ -7180,27 +7181,49 @@ wasm_runtime_detect_native_stack_overflow_size(WASMExecEnv *exec_env,
 }
 
 WASM_RUNTIME_API_EXTERN bool
-wasm_runtime_is_underlying_binary_freeable(const wasm_module_t module)
+wasm_runtime_is_underlying_binary_freeable(const wasm_module_inst_t module_inst)
 {
-    bool is_freeable = false;
+    uint32 i;
 
 #if WASM_ENABLE_INTERP != 0
-    if (module->module_type == Wasm_Module_Bytecode) {
+    if (module_inst->module_type == Wasm_Module_Bytecode) {
 #if (WASM_ENABLE_JIT != 0 || WASM_ENABLE_FAST_JIT != 0) \
     && (WASM_ENABLE_LAZY_JIT != 0)
-        is_freeable = false;
+        return false;
 #elif WASM_ENABLE_FAST_INTERP == 0
-        is_freeable = false;
+        return false;
 #else
-        is_freeable = ((WASMModule *)module)->is_binary_freeable;
+        /* Fast interpreter mode */
+        WASMModule *module = ((WASMModuleInstance *)module_inst)->module;
+        if (!module->is_binary_freeable)
+            return false;
+#if WASM_ENABLE_GC != 0 && WASM_ENABLE_STRINGREF != 0
+        if (module->string_literal_ptrs)
+            return false;
+#endif
+#if WASM_ENABLE_BULK_MEMORY != 0
+        for (i = 0; i < module->data_seg_count; i++)
+            if (!bh_bitmap_get_bit(
+                    ((WASMModuleInstance *)module_inst)->e->common.data_dropped,
+                    i))
+                return false;
 #endif
-    }
 #endif
-#if WASM_ENABLE_AOT != 0
-    if (module->module_type == Wasm_Module_AoT) {
-        is_freeable = ((AOTModule *)module)->is_binary_freeable;
     }
+#endif /* WASM_ENABLE_INTERP != 0 */
+#if WASM_ENABLE_AOT != 0
+    if (module_inst->module_type == Wasm_Module_AoT) {
+        AOTModule *module =
+            (AOTModule *)((AOTModuleInstance *)module_inst)->module;
+        if (!module->is_binary_freeable)
+            return false;
+#if WASM_ENABLE_GC != 0 && WASM_ENABLE_STRINGREF != 0
+        if (module->string_literal_ptrs)
+            return false;
 #endif
+    }
+#endif /* WASM_ENABLE_AOT != 0 */
 
-    return is_freeable;
+    (void)i;
+    return true;
 }

core/iwasm/common/wasm_runtime_common.h

@@ -1197,7 +1197,8 @@ wasm_runtime_detect_native_stack_overflow_size(WASMExecEnv *exec_env,
                                                uint32 requested_size);
 
 WASM_RUNTIME_API_EXTERN bool
-wasm_runtime_is_underlying_binary_freeable(const wasm_module_t module);
+wasm_runtime_is_underlying_binary_freeable(
+    const wasm_module_inst_t module_inst);
 
 #if WASM_ENABLE_LINUX_PERF != 0
 bool

core/iwasm/include/wasm_c_api.h

@@ -562,7 +562,7 @@ WASM_API_EXTERN void wasm_shared_module_delete(own wasm_shared_module_t*);
 WASM_API_EXTERN bool wasm_module_set_name(wasm_module_t*, const char* name);
 WASM_API_EXTERN const char *wasm_module_get_name(wasm_module_t*);
 
-WASM_API_EXTERN bool wasm_module_is_underlying_binary_freeable(const wasm_module_t* module);
+WASM_API_EXTERN bool wasm_module_is_underlying_binary_freeable(const wasm_module_t *module, const struct wasm_instance_t* instance);
 
 
 // Function Instances

core/iwasm/include/wasm_export.h

@@ -1870,11 +1870,12 @@ wasm_runtime_detect_native_stack_overflow_size(wasm_exec_env_t exec_env,
 /**
  * Query whether the wasm binary buffer used to create the module can be freed
  *
- * @param module the target module
+ * @param module_inst the target module instance
  * @return true if the wasm binary buffer can be freed
  */
 WASM_RUNTIME_API_EXTERN bool
-wasm_runtime_is_underlying_binary_freeable(const wasm_module_t module);
+wasm_runtime_is_underlying_binary_freeable(
+    const wasm_module_inst_t module_inst);
 
 #ifdef __cplusplus
 }

doc/memory_tune.md

@@ -30,5 +30,5 @@ Normally there are some methods to tune the memory usage:
 - set the app heap size with `wasm_runtime_instantiate`
 - use `nostdlib` mode, add `-Wl,--strip-all`: refer to [How to reduce the footprint](./build_wasm_app.md#2-how-to-reduce-the-footprint) of building wasm app for more details
 - use XIP mode, refer to [WAMR XIP (Execution In Place) feature introduction](./xip.md) for more details
-- when using the Wasm C API in fast interpreter or AOT mode, set `clone_wasm_binary=false` in `LoadArgs` and free the wasm binary buffer (with `wasm_byte_vec_delete`) after module loading; `wasm_module_is_underlying_binary_freeable` can be queried to check if the wasm binary buffer can be safely freed (see [the example](../samples/basic/src/free_buffer_early.c))
-- when using the wasm/AOT loader in fast interpreter or AOT mode, set `wasm_binary_freeable=true` in `LoadArgs` and free the wasm binary buffer (with `wasm_byte_vec_delete`) after module loading; `wasm_runtime_is_underlying_binary_freeable` can be queried to check if the wasm binary buffer can be safely freed
+- when using the Wasm C API in fast interpreter or AOT mode, set `clone_wasm_binary=false` in `LoadArgs` and free the wasm binary buffer (with `wasm_byte_vec_delete`) after module loading; `wasm_module_is_underlying_binary_freeable` can be queried to check if the wasm binary buffer can be safely freed (see [the example](../samples/basic/src/free_buffer_early.c)); after the buffer is freed, `wasm_runtime_get_custom_section` cannot be called anymore
+- when using the wasm/AOT loader in fast interpreter or AOT mode, set `wasm_binary_freeable=true` in `LoadArgs` and free the wasm binary buffer (with `wasm_byte_vec_delete`) after module loading; `wasm_runtime_is_underlying_binary_freeable` can be queried to check if the wasm binary buffer can be safely freed; after the buffer is freed, `wasm_runtime_get_custom_section` cannot be called anymore

samples/basic/src/free_buffer_early.c

@@ -10,7 +10,7 @@ void
 my_log(uint32 log_level, const char *file, int line, const char *fmt, ...)
 {
     char buf[200];
-    snprintf(buf, sizeof(buf), "[WamrLogger] %s", fmt);
+    snprintf(buf, sizeof(buf), "[WamrLogger] %s\n", fmt);
 
     va_list ap;
     va_start(ap, fmt);
@@ -89,19 +89,19 @@ main(int argc, char *argv_main[])
         goto fail;
     }
 
-    if (wasm_runtime_is_underlying_binary_freeable(module)) {
-        printf("Able to free wasm binary buffer.\n");
-        wasm_runtime_free(buffer);
-        buffer = NULL;
-    }
-
     module_inst = wasm_runtime_instantiate(module, stack_size, heap_size,
                                            error_buf, sizeof(error_buf));
     if (!module_inst) {
         printf("Instantiate wasm module failed. error: %s.\n", error_buf);
         goto fail;
     }
 
+    if (wasm_runtime_is_underlying_binary_freeable(module_inst)) {
+        printf("Able to free wasm binary buffer.\n");
+        wasm_runtime_free(buffer);
+        buffer = NULL;
+    }
+
     char *args[1] = { "3" };
     success = wasm_application_execute_func(module_inst, "mul7", 1, args);
     if (!success) {