wamr: update to WAMR-12-30-2021 with LLVM 13.0.0.

bazel/external/llvm13.BUILD

@@ -0,0 +1,124 @@
+load("@rules_foreign_cc//foreign_cc:defs.bzl", "cmake")
+
+licenses(["notice"])  # Apache 2
+
+package(default_visibility = ["//visibility:public"])
+
+filegroup(
+    name = "srcs",
+    srcs = glob(["**"]),
+)
+
+cmake(
+    name = "llvm_lib",
+    cache_entries = {
+        # Disable both: BUILD and INCLUDE, since some of the INCLUDE
+        # targets build code instead of only generating build files.
+        "LLVM_BUILD_BENCHMARKS": "off",
+        "LLVM_INCLUDE_BENCHMARKS": "off",
+        "LLVM_BUILD_DOCS": "off",
+        "LLVM_INCLUDE_DOCS": "off",
+        "LLVM_BUILD_EXAMPLES": "off",
+        "LLVM_INCLUDE_EXAMPLES": "off",
+        "LLVM_BUILD_RUNTIME": "off",
+        "LLVM_BUILD_RUNTIMES": "off",
+        "LLVM_INCLUDE_RUNTIMES": "off",
+        "LLVM_BUILD_TESTS": "off",
+        "LLVM_INCLUDE_TESTS": "off",
+        "LLVM_BUILD_TOOLS": "off",
+        "LLVM_INCLUDE_TOOLS": "off",
+        "LLVM_BUILD_UTILS": "off",
+        "LLVM_INCLUDE_UTILS": "off",
+        "LLVM_ENABLE_IDE": "off",
+        "LLVM_ENABLE_LIBEDIT": "off",
+        "LLVM_ENABLE_LIBXML2": "off",
+        "LLVM_ENABLE_TERMINFO": "off",
+        "LLVM_ENABLE_ZLIB": "off",
+        "LLVM_TARGETS_TO_BUILD": "X86",
+        "CMAKE_CXX_FLAGS": "-Wno-unused-command-line-argument",
+    },
+    env_vars = {
+        # Workaround for the -DDEBUG flag added in fastbuild on macOS,
+        # which conflicts with DEBUG macro used in LLVM.
+        "CFLAGS": "-UDEBUG",
+        "CXXFLAGS": "-UDEBUG",
+        "ASMFLAGS": "-UDEBUG",
+    },
+    generate_args = ["-GNinja"],
+    lib_source = ":srcs",
+    out_static_libs = [
+        "libLLVMWindowsManifest.a",
+        "libLLVMXRay.a",
+        "libLLVMLibDriver.a",
+        "libLLVMDlltoolDriver.a",
+        "libLLVMCoverage.a",
+        "libLLVMLineEditor.a",
+        "libLLVMX86Disassembler.a",
+        "libLLVMX86AsmParser.a",
+        "libLLVMX86CodeGen.a",
+        "libLLVMX86Desc.a",
+        "libLLVMX86Info.a",
+        "libLLVMOrcJIT.a",
+        "libLLVMMCJIT.a",
+        "libLLVMJITLink.a",
+        "libLLVMInterpreter.a",
+        "libLLVMExecutionEngine.a",
+        "libLLVMRuntimeDyld.a",
+        "libLLVMOrcTargetProcess.a",
+        "libLLVMOrcShared.a",
+        "libLLVMDWP.a",
+        "libLLVMSymbolize.a",
+        "libLLVMDebugInfoPDB.a",
+        "libLLVMDebugInfoGSYM.a",
+        "libLLVMOption.a",
+        "libLLVMObjectYAML.a",
+        "libLLVMMCA.a",
+        "libLLVMMCDisassembler.a",
+        "libLLVMLTO.a",
+        "libLLVMPasses.a",
+        "libLLVMCFGuard.a",
+        "libLLVMCoroutines.a",
+        "libLLVMObjCARCOpts.a",
+        "libLLVMipo.a",
+        "libLLVMVectorize.a",
+        "libLLVMLinker.a",
+        "libLLVMInstrumentation.a",
+        "libLLVMFrontendOpenMP.a",
+        "libLLVMFrontendOpenACC.a",
+        "libLLVMExtensions.a",
+        "libLLVMDWARFLinker.a",
+        "libLLVMGlobalISel.a",
+        "libLLVMMIRParser.a",
+        "libLLVMAsmPrinter.a",
+        "libLLVMDebugInfoMSF.a",
+        "libLLVMDebugInfoDWARF.a",
+        "libLLVMSelectionDAG.a",
+        "libLLVMCodeGen.a",
+        "libLLVMIRReader.a",
+        "libLLVMAsmParser.a",
+        "libLLVMInterfaceStub.a",
+        "libLLVMFileCheck.a",
+        "libLLVMFuzzMutate.a",
+        "libLLVMTarget.a",
+        "libLLVMScalarOpts.a",
+        "libLLVMInstCombine.a",
+        "libLLVMAggressiveInstCombine.a",
+        "libLLVMTransformUtils.a",
+        "libLLVMBitWriter.a",
+        "libLLVMAnalysis.a",
+        "libLLVMProfileData.a",
+        "libLLVMObject.a",
+        "libLLVMTextAPI.a",
+        "libLLVMMCParser.a",
+        "libLLVMMC.a",
+        "libLLVMDebugInfoCodeView.a",
+        "libLLVMBitReader.a",
+        "libLLVMCore.a",
+        "libLLVMRemarks.a",
+        "libLLVMBitstreamReader.a",
+        "libLLVMBinaryFormat.a",
+        "libLLVMTableGen.a",
+        "libLLVMSupport.a",
+        "libLLVMDemangle.a",
+    ],
+)

bazel/external/wamr.BUILD

@@ -12,9 +12,11 @@ filegroup(
 cmake(
     name = "wamr_lib",
     cache_entries = {
-        "LLVM_DIR": "$EXT_BUILD_DEPS/copy_llvm/llvm/lib/cmake/llvm",
+        "LLVM_DIR": "$EXT_BUILD_DEPS/copy_llvm13/llvm/lib/cmake/llvm",
         "WAMR_BUILD_INTERP": "1",
+        "WAMR_BUILD_FAST_INTERP": "1",
         "WAMR_BUILD_JIT": "0",
+        "WAMR_BUILD_LAZY_JIT": "0",
         "WAMR_BUILD_AOT": "0",
         "WAMR_BUILD_SIMD": "0",
         "WAMR_BUILD_MULTI_MODULE": "1",
@@ -25,6 +27,6 @@ cmake(
     lib_source = ":srcs",
     out_static_libs = ["libvmlib.a"],
     deps = [
-        "@llvm//:llvm_lib",
+        "@llvm13//:llvm_lib",
     ],
 )

bazel/external/wamr.patch

@@ -0,0 +1,15 @@
+1. Automatically detect the host platform. (https://github.com/bytecodealliance/wasm-micro-runtime/pull/929)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index d77473e..bc74e72 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -6,7 +6,7 @@ cmake_minimum_required (VERSION 2.8...3.16)
+ project (iwasm)
+ # set (CMAKE_VERBOSE_MAKEFILE 1)
+
+-set (WAMR_BUILD_PLATFORM "linux")
++string (TOLOWER ${CMAKE_HOST_SYSTEM_NAME} WAMR_BUILD_PLATFORM)
+
+ # Reset default linker flags
+ set (CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "")

bazel/repositories.bzl

@@ -43,12 +43,22 @@ def proxy_wasm_cpp_host_repositories():
         url = "https://github.com/protocolbuffers/protobuf/releases/download/v3.17.3/protobuf-all-3.17.3.tar.gz",
     )
 
+    http_archive(
+        name = "llvm13",
+        build_file = "@proxy_wasm_cpp_host//bazel/external:llvm13.BUILD",
+        sha256 = "408d11708643ea826f519ff79761fcdfc12d641a2510229eec459e72f8163020",
+        strip_prefix = "llvm-13.0.0.src",
+        url = "https://github.com/llvm/llvm-project/releases/download/llvmorg-13.0.0/llvm-13.0.0.src.tar.xz",
+    )
+
     http_archive(
         name = "com_github_bytecodealliance_wasm_micro_runtime",
         build_file = "@proxy_wasm_cpp_host//bazel/external:wamr.BUILD",
-        sha256 = "46ad365a1c0668797e69cb868574fd526cd8e26a503213caf782c39061e6d2e1",
-        strip_prefix = "wasm-micro-runtime-17a216748574499bd3a5130e7e6a20b84fe76798",
-        url = "https://github.com/bytecodealliance/wasm-micro-runtime/archive/17a216748574499bd3a5130e7e6a20b84fe76798.tar.gz",
+        sha256 = "0ccf19f30f744fca635be5428f6460c14dfee19bfa0820c70e0fc9554f79c9b1",
+        strip_prefix = "wasm-micro-runtime-cdf306364eff8f50fd6473b32a316cb90cc15a2f",
+        url = "https://github.com/bytecodealliance/wasm-micro-runtime/archive/cdf306364eff8f50fd6473b32a316cb90cc15a2f.tar.gz",
+        patches = ["@proxy_wasm_cpp_host//bazel/external:wamr.patch"],
+        patch_args = ["-p1"],
     )
 
     native.bind(

src/wamr/wamr.cc

@@ -153,17 +153,17 @@ static std::string printValue(const wasm_val_t &value) {
   }
 }
 
-static std::string printValues(const wasm_val_t values[], size_t size) {
-  if (size == 0) {
+static std::string printValues(const wasm_val_vec_t *values) {
+  if (values->size == 0) {
     return "";
   }
 
   std::string s;
-  for (size_t i = 0; i < size; i++) {
+  for (size_t i = 0; i < values->size; i++) {
     if (i) {
       s.append(", ");
     }
-    s.append(printValue(values[i]));
+    s.append(printValue(values->data[i]));
   }
   return s;
 }
@@ -209,7 +209,7 @@ bool Wamr::link(std::string_view debug_name) {
   WasmImporttypeVec import_types;
   wasm_module_imports(module_.get(), import_types.get());
 
-  std::vector<const wasm_extern_t *> imports;
+  std::vector<wasm_extern_t *> imports;
   for (size_t i = 0; i < import_types.get()->size; i++) {
     const wasm_name_t *module_name_ptr = wasm_importtype_module(import_types.get()->data[i]);
     const wasm_name_t *name_ptr = wasm_importtype_name(import_types.get()->data[i]);
@@ -273,7 +273,8 @@ bool Wamr::link(std::string_view debug_name) {
     return false;
   }
 
-  instance_ = wasm_instance_new(store_.get(), module_.get(), imports.data(), nullptr);
+  wasm_extern_vec_t imports_vec = {imports.size(), imports.data()};
+  instance_ = wasm_instance_new(store_.get(), module_.get(), &imports_vec, nullptr);
   assert(instance_ != nullptr);
 
   WasmExportTypeVec export_types;
@@ -403,14 +404,10 @@ template <> uint64_t convertValueTypeToArg<uint64_t>(wasm_val_t val) {
 template <> double convertValueTypeToArg<double>(wasm_val_t val) { return val.of.f64; }
 
 template <typename T, typename U, std::size_t... I>
-constexpr T convertValTypesToArgsTupleImpl(const U &arr, std::index_sequence<I...>) {
+constexpr T convertValTypesToArgsTuple(const U &vec, std::index_sequence<I...>) {
   return std::make_tuple(
-      convertValueTypeToArg<typename ConvertWordType<std::tuple_element_t<I, T>>::type>(arr[I])...);
-}
-
-template <typename T, typename U, typename Is = std::make_index_sequence<std::tuple_size<T>::value>>
-constexpr T convertValTypesToArgsTuple(const U &arr) {
-  return convertValTypesToArgsTupleImpl<T>(arr, Is());
+      convertValueTypeToArg<typename ConvertWordType<std::tuple_element_t<I, T>>::type>(
+          vec->data[I])...);
 }
 
 template <typename T, std::size_t... I>
@@ -449,14 +446,15 @@ void Wamr::registerHostFunctionImpl(std::string_view module_name, std::string_vi
   WasmFunctypePtr type = newWasmNewFuncType<std::tuple<Args...>>();
   WasmFuncPtr func = wasm_func_new_with_env(
       store_.get(), type.get(),
-      [](void *data, const wasm_val_t params[], wasm_val_t results[]) -> wasm_trap_t * {
+      [](void *data, const wasm_val_vec_t *params, wasm_val_vec_t *results) -> wasm_trap_t * {
         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->name_ + "(" +
-                                               printValues(params, sizeof...(Args)) + ")");
+                                               printValues(params) + ")");
         }
-        auto args = convertValTypesToArgsTuple<std::tuple<Args...>>(params);
+        auto args = convertValTypesToArgsTuple<std::tuple<Args...>>(
+            params, std::make_index_sequence<sizeof...(Args)>{});
         auto fn = reinterpret_cast<void (*)(Args...)>(func_data->raw_func_);
         std::apply(fn, args);
         if (log) {
@@ -481,17 +479,18 @@ void Wamr::registerHostFunctionImpl(std::string_view module_name, std::string_vi
   WasmFunctypePtr type = newWasmNewFuncType<R, std::tuple<Args...>>();
   WasmFuncPtr func = wasm_func_new_with_env(
       store_.get(), type.get(),
-      [](void *data, const wasm_val_t params[], wasm_val_t results[]) -> wasm_trap_t * {
+      [](void *data, const wasm_val_vec_t *params, wasm_val_vec_t *results) -> wasm_trap_t * {
         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->name_ + "(" +
-                                               printValues(params, sizeof...(Args)) + ")");
+                                               printValues(params) + ")");
         }
-        auto args = convertValTypesToArgsTuple<std::tuple<Args...>>(params);
+        auto args = convertValTypesToArgsTuple<std::tuple<Args...>>(
+            params, std::make_index_sequence<sizeof...(Args)>{});
         auto fn = reinterpret_cast<R (*)(Args...)>(func_data->raw_func_);
         R res = std::apply(fn, args);
-        assignVal<R>(res, results[0]);
+        assignVal<R>(res, results->data[0]);
         if (log) {
           func_data->vm_->integration()->trace("[vm<-host] " + func_data->name_ +
                                                " return: " + std::to_string(res));
@@ -534,14 +533,16 @@ void Wamr::getModuleFunctionImpl(std::string_view function_name,
   }
 
   *function = [func, function_name, this](ContextBase *context, Args... args) -> void {
-    wasm_val_t params[] = {makeVal(args)...};
+    wasm_val_t params_arr[] = {makeVal(args)...};
+    const wasm_val_vec_t params = WASM_ARRAY_VEC(params_arr);
+    wasm_val_vec_t results = WASM_EMPTY_VEC;
     const bool log = cmpLogLevel(LogLevel::trace);
     if (log) {
-      integration()->trace("[host->vm] " + std::string(function_name) + "(" +
-                           printValues(params, sizeof...(Args)) + ")");
+      integration()->trace("[host->vm] " + std::string(function_name) + "(" + printValues(&params) +
+                           ")");
     }
     SaveRestoreContext saved_context(context);
-    WasmTrapPtr trap{wasm_func_call(func, params, nullptr)};
+    WasmTrapPtr trap{wasm_func_call(func, &params, &results)};
     if (trap) {
       WasmByteVec error_message;
       wasm_trap_message(trap.get(), error_message.get());
@@ -580,15 +581,17 @@ void Wamr::getModuleFunctionImpl(std::string_view function_name,
   }
 
   *function = [func, function_name, this](ContextBase *context, Args... args) -> R {
-    wasm_val_t params[] = {makeVal(args)...};
-    wasm_val_t results[1];
+    wasm_val_t params_arr[] = {makeVal(args)...};
+    const wasm_val_vec_t params = WASM_ARRAY_VEC(params_arr);
+    wasm_val_t results_arr[1];
+    wasm_val_vec_t results = WASM_ARRAY_VEC(results_arr);
     const bool log = cmpLogLevel(LogLevel::trace);
     if (log) {
-      integration()->trace("[host->vm] " + std::string(function_name) + "(" +
-                           printValues(params, sizeof...(Args)) + ")");
+      integration()->trace("[host->vm] " + std::string(function_name) + "(" + printValues(&params) +
+                           ")");
     }
     SaveRestoreContext saved_context(context);
-    WasmTrapPtr trap{wasm_func_call(func, params, results)};
+    WasmTrapPtr trap{wasm_func_call(func, &params, &results)};
     if (trap) {
       WasmByteVec error_message;
       wasm_trap_message(trap.get(), error_message.get());
@@ -597,7 +600,7 @@ void Wamr::getModuleFunctionImpl(std::string_view function_name,
                std::string(error_message.get()->data, error_message.get()->size));
       return R{};
     }
-    R ret = convertValueTypeToArg<R>(results[0]);
+    R ret = convertValueTypeToArg<R>(results.data[0]);
     if (log) {
       integration()->trace("[host<-vm] " + std::string(function_name) +
                            " return: " + std::to_string(ret));