WasmEdge: Update the WasmEdge runtime to WasmEdge-0.9.0.

q82419 · q82419 · commit 1339541f63c9 · 2022-01-17T13:25:55.000+08:00
Signed-off-by: YiYing He &lt;yiying@secondstate.io&gt;
diff --git a/bazel/external/wasmedge.BUILD b/bazel/external/wasmedge.BUILD
@@ -1,12 +1,26 @@
-load("@rules_cc//cc:defs.bzl", "cc_library")
+load("@rules_foreign_cc//foreign_cc:defs.bzl", "cmake")
 
 licenses(["notice"])  # Apache 2
 
 package(default_visibility = ["//visibility:public"])
 
-cc_library(
+filegroup(
+    name = "srcs",
+    srcs = glob(["**"]),
+)
+
+cmake(
     name = "wasmedge_lib",
-    srcs = ["lib64/libwasmedge_c.so"],
-    hdrs = ["include/wasmedge.h"],
-    strip_include_prefix = "include/",
+    cache_entries = {
+        "WASMEDGE_BUILD_AOT_RUNTIME": "Off",
+        "WASMEDGE_BUILD_SHARED_LIB": "Off",
+        "WASMEDGE_BUILD_STATIC_LIB": "On",
+        "WASMEDGE_BUILD_TOOLS": "Off",
+        "WASMEDGE_FORCE_DISABLE_LTO": "On",
+    },
+    generate_args = ["-GNinja"],
+    lib_source = ":srcs",
+    out_static_libs = [
+        "libwasmedge_c.a"
+    ],
 )
diff --git a/bazel/repositories.bzl b/bazel/repositories.bzl
@@ -188,9 +188,9 @@ def proxy_wasm_cpp_host_repositories():
     http_archive(
         name = "com_github_wasmedge_wasmedge",
         build_file = "@proxy_wasm_cpp_host//bazel/external:wasmedge.BUILD",
-        sha256 = "48c15893f036b86b0f28d96e6269a4ac75d9697a30c44b171e254c83409afb30",
-        strip_prefix = "WasmEdge-0.8.2-Linux",
-        url = "https://github.com/WasmEdge/WasmEdge/releases/download/0.8.2/WasmEdge-0.8.2-manylinux2014_x86_64.tar.gz",
+        sha256 = "708c1652d470f74faf3b016b0fc90d426c2573d7bcf90cc3435ca3d02d5ad123",
+        strip_prefix = "WasmEdge-proxy-wasm-0.9.0",
+        url = "https://github.com/WasmEdge/WasmEdge/archive/refs/tags/proxy-wasm/0.9.0.tar.gz",
     )
 
     native.bind(
diff --git a/src/wasmedge/types.h b/src/wasmedge/types.h
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 #include "src/common/types.h"
-#include "wasmedge.h"
+#include "wasmedge/wasmedge.h"
 
 namespace proxy_wasm {
 namespace WasmEdge {
@@ -22,8 +22,7 @@ using WasmEdgeStorePtr = common::CSmartPtr<WasmEdge_StoreContext, WasmEdge_Store
 using WasmEdgeVMPtr = common::CSmartPtr<WasmEdge_VMContext, WasmEdge_VMDelete>;
 using WasmEdgeLoaderPtr = common::CSmartPtr<WasmEdge_LoaderContext, WasmEdge_LoaderDelete>;
 using WasmEdgeValidatorPtr = common::CSmartPtr<WasmEdge_ValidatorContext, WasmEdge_ValidatorDelete>;
-using WasmEdgeInterpreterPtr =
-    common::CSmartPtr<WasmEdge_InterpreterContext, WasmEdge_InterpreterDelete>;
+using WasmEdgeExecutorPtr = common::CSmartPtr<WasmEdge_ExecutorContext, WasmEdge_ExecutorDelete>;
 using WasmEdgeASTModulePtr = common::CSmartPtr<WasmEdge_ASTModuleContext, WasmEdge_ASTModuleDelete>;
 
 } // namespace WasmEdge
diff --git a/src/wasmedge/wasmedge.cc b/src/wasmedge/wasmedge.cc
@@ -17,7 +17,7 @@
 #include "include/proxy-wasm/wasm_vm.h"
 #include "src/wasmedge/types.h"
 
-#include "wasmedge.h"
+#include "wasmedge/wasmedge.h"
 
 #include <array>
 #include <cassert>
@@ -206,11 +206,10 @@ namespace WasmEdge {
 struct HostFuncData {
   HostFuncData(const std::string_view modname, const std::string_view name)
       : modname_(modname), name_(name) {}
-  ~HostFuncData() { WasmEdge_FunctionTypeDelete(functype_); }
+  ~HostFuncData() {}
 
   std::string modname_, name_;
-  WasmEdge_WrapFunc_t callback_;
-  WasmEdge_FunctionTypeContext *functype_;
+  WasmEdge_HostFunc_t callback_;
   void *raw_func_;
   WasmVm *vm_;
 };
@@ -219,8 +218,7 @@ using HostFuncDataPtr = std::unique_ptr<HostFuncData>;
 
 struct HostModuleData {
   HostModuleData(const std::string_view modname) {
-    cxt_ =
-        WasmEdge_ImportObjectCreate(WasmEdge_StringWrap(modname.data(), modname.length()), nullptr);
+    cxt_ = WasmEdge_ImportObjectCreate(WasmEdge_StringWrap(modname.data(), modname.length()));
   }
   ~HostModuleData() { WasmEdge_ImportObjectDelete(cxt_); }
 
@@ -234,7 +232,7 @@ class WasmEdge : public WasmVm {
   WasmEdge() {
     loader_ = WasmEdge_LoaderCreate(nullptr);
     validator_ = WasmEdge_ValidatorCreate(nullptr);
-    interpreter_ = WasmEdge_InterpreterCreate(nullptr, nullptr);
+    executor_ = WasmEdge_ExecutorCreate(nullptr, nullptr);
     store_ = nullptr;
     module_ = nullptr;
     memory_ = nullptr;
@@ -289,7 +287,7 @@ class WasmEdge : public WasmVm {
 
   WasmEdgeLoaderPtr loader_;
   WasmEdgeValidatorPtr validator_;
-  WasmEdgeInterpreterPtr interpreter_;
+  WasmEdgeExecutorPtr executor_;
   WasmEdgeStorePtr store_;
   WasmEdgeASTModulePtr module_;
   WasmEdge_MemoryInstanceContext *memory_;
@@ -319,16 +317,15 @@ bool WasmEdge::link(std::string_view debug_name) {
   // Create store and register imports.
   store_ = WasmEdge_StoreCreate();
   for (auto &&it : import_objects_) {
-    auto res =
-        WasmEdge_InterpreterRegisterImport(interpreter_.get(), store_.get(), it.second->cxt_);
+    auto res = WasmEdge_ExecutorRegisterImport(executor_.get(), store_.get(), it.second->cxt_);
     if (!WasmEdge_ResultOK(res)) {
       fail(FailState::UnableToInitializeCode,
            std::string("Failed to link Wasm module due to import: ") + it.first);
       return false;
     }
   }
   // Instantiate module.
-  if (auto res = WasmEdge_InterpreterInstantiate(interpreter_.get(), store_.get(), module_.get());
+  if (auto res = WasmEdge_ExecutorInstantiate(executor_.get(), store_.get(), module_.get());
       !WasmEdge_ResultOK(res)) {
     fail(FailState::UnableToInitializeCode,
          std::string("Failed to link Wasm module: ") + std::string(WasmEdge_ResultGetMessage(res)));
@@ -345,7 +342,6 @@ bool WasmEdge::link(std::string_view debug_name) {
     WasmEdge_StoreListFunction(store_.get(), &names[0], num);
     for (auto i = 0; i < num; i++) {
       module_functions_.insert(std::string(names[i].Buf, names[i].Length));
-      WasmEdge_StringDelete(names[i]);
     }
   }
   return true;
@@ -402,13 +398,12 @@ void WasmEdge::registerHostFunctionImpl(std::string_view module_name,
   }
 
   auto data = std::make_unique<HostFuncData>(module_name, function_name);
+  auto *func_type = newWasmEdgeFuncType<std::tuple<Args...>>();
   data->vm_ = this;
-  data->functype_ = newWasmEdgeFuncType<std::tuple<Args...>>();
   data->raw_func_ = reinterpret_cast<void *>(function);
-  data->callback_ = [](void *func, void *data, WasmEdge_MemoryInstanceContext *MemCxt,
-                       const WasmEdge_Value *Params, const uint32_t ParamLen,
-                       WasmEdge_Value *Returns, const uint32_t ReturnLen) -> WasmEdge_Result {
-    auto func_data = reinterpret_cast<HostFuncData *>(func);
+  data->callback_ = [](void *data, WasmEdge_MemoryInstanceContext *MemCxt,
+                       const WasmEdge_Value *Params, WasmEdge_Value *Returns) -> WasmEdge_Result {
+    auto func_data = reinterpret_cast<HostFuncData *>(data);
     const bool log = func_data->vm_->cmpLogLevel(LogLevel::trace);
     if (log) {
       func_data->vm_->integration()->trace("[vm->host] " + func_data->modname_ + "." +
@@ -425,10 +420,10 @@ void WasmEdge::registerHostFunctionImpl(std::string_view module_name,
     return WasmEdge_Result_Success;
   };
 
-  auto *hostfunc_cxt =
-      WasmEdge_HostFunctionCreateBinding(data->functype_, data->callback_, data.get(), 0);
+  auto *hostfunc_cxt = WasmEdge_FunctionInstanceCreate(func_type, data->callback_, data.get(), 0);
+  WasmEdge_FunctionTypeDelete(func_type);
 
-  WasmEdge_ImportObjectAddHostFunction(
+  WasmEdge_ImportObjectAddFunction(
       it->second->cxt_, WasmEdge_StringWrap(function_name.data(), function_name.length()),
       hostfunc_cxt);
   host_functions_.insert_or_assign(std::string(module_name) + "." + std::string(function_name),
@@ -445,13 +440,12 @@ void WasmEdge::registerHostFunctionImpl(std::string_view module_name,
   }
 
   auto data = std::make_unique<HostFuncData>(module_name, function_name);
+  auto *func_type = newWasmEdgeFuncType<R, std::tuple<Args...>>();
   data->vm_ = this;
-  data->functype_ = newWasmEdgeFuncType<R, std::tuple<Args...>>();
   data->raw_func_ = reinterpret_cast<void *>(function);
-  data->callback_ = [](void *func, void *data, WasmEdge_MemoryInstanceContext *MemCxt,
-                       const WasmEdge_Value *Params, const uint32_t ParamLen,
-                       WasmEdge_Value *Returns, const uint32_t ReturnLen) -> WasmEdge_Result {
-    auto func_data = reinterpret_cast<HostFuncData *>(func);
+  data->callback_ = [](void *data, WasmEdge_MemoryInstanceContext *MemCxt,
+                       const WasmEdge_Value *Params, WasmEdge_Value *Returns) -> WasmEdge_Result {
+    auto func_data = reinterpret_cast<HostFuncData *>(data);
     const bool log = func_data->vm_->cmpLogLevel(LogLevel::trace);
     if (log) {
       func_data->vm_->integration()->trace("[vm->host] " + func_data->modname_ + "." +
@@ -469,10 +463,10 @@ void WasmEdge::registerHostFunctionImpl(std::string_view module_name,
     return WasmEdge_Result_Success;
   };
 
-  auto *hostfunc_cxt =
-      WasmEdge_HostFunctionCreateBinding(data->functype_, data->callback_, data.get(), 0);
+  auto *hostfunc_cxt = WasmEdge_FunctionInstanceCreate(func_type, data->callback_, data.get(), 0);
+  WasmEdge_FunctionTypeDelete(func_type);
 
-  WasmEdge_ImportObjectAddHostFunction(
+  WasmEdge_ImportObjectAddFunction(
       it->second->cxt_, WasmEdge_StringWrap(function_name.data(), function_name.length()),
       hostfunc_cxt);
   host_functions_.insert_or_assign(std::string(module_name) + "." + std::string(function_name),
@@ -518,10 +512,10 @@ void WasmEdge::getModuleFunctionImpl(std::string_view function_name,
                            printValues(params, sizeof...(Args)) + ")");
     }
     SaveRestoreContext saved_context(context);
-    WasmEdge_Result res = WasmEdge_InterpreterInvoke(
-        interpreter_.get(), store_.get(),
-        WasmEdge_StringWrap(function_name.data(), function_name.length()), params, sizeof...(Args),
-        nullptr, 0);
+    WasmEdge_Result res =
+        WasmEdge_ExecutorInvoke(executor_.get(), store_.get(),
+                                WasmEdge_StringWrap(function_name.data(), function_name.length()),
+                                params, sizeof...(Args), nullptr, 0);
     if (!WasmEdge_ResultOK(res)) {
       fail(FailState::RuntimeError, "Function: " + std::string(function_name) + " failed:\n" +
                                         WasmEdge_ResultGetMessage(res));
@@ -573,10 +567,10 @@ void WasmEdge::getModuleFunctionImpl(std::string_view function_name,
                            printValues(params, sizeof...(Args)) + ")");
     }
     SaveRestoreContext saved_context(context);
-    WasmEdge_Result res = WasmEdge_InterpreterInvoke(
-        interpreter_.get(), store_.get(),
-        WasmEdge_StringWrap(function_name.data(), function_name.length()), params, sizeof...(Args),
-        results, 1);
+    WasmEdge_Result res =
+        WasmEdge_ExecutorInvoke(executor_.get(), store_.get(),
+                                WasmEdge_StringWrap(function_name.data(), function_name.length()),
+                                params, sizeof...(Args), results, 1);
     if (!WasmEdge_ResultOK(res)) {
       fail(FailState::RuntimeError, "Function: " + std::string(function_name) + " failed:\n" +
                                         WasmEdge_ResultGetMessage(res));
