chore(frontend): split linked API to multiple files (#121)

Author: HerrCai0907

frontend/CompilerImpl.cpp

@@ -271,14 +271,16 @@ FrontendCompiler::FrontendCompiler(Config const &config)
   if (config.ascWasmPath) [[unlikely]] {
     support::PerfRAII const r{support::PerfItemKind::CompilationHIR_PrepareWASMModule};
     std::string const wasmBytes = readBinaryFile(*config.ascWasmPath);
-    m.initFromBytecode(
-        vb::Span<const uint8_t>{reinterpret_cast<uint8_t const *>(wasmBytes.data()), wasmBytes.size()},
-        vb::Span<vb::NativeSymbol const>{warpo::frontend::linkedAPI.data(), warpo::frontend::linkedAPI.size()}, true);
+    m.initFromBytecode(vb::Span<const uint8_t>{reinterpret_cast<uint8_t const *>(wasmBytes.data()), wasmBytes.size()},
+                       vb::Span<vb::NativeSymbol const>{warpo::frontend::getLinkedAPI().data(),
+                                                        warpo::frontend::getLinkedAPI().size()},
+                       true);
   } else {
     support::PerfRAII const r{support::PerfItemKind::CompilationHIR_PrepareWASMModule};
-    static vb::WasmModule::CompileResult const embedJitCode = m.compile(
-        vb::Span<const uint8_t>{embed_asc_wasm.data(), embed_asc_wasm.size()},
-        vb::Span<vb::NativeSymbol const>{warpo::frontend::linkedAPI.data(), warpo::frontend::linkedAPI.size()});
+    static vb::WasmModule::CompileResult const embedJitCode =
+        m.compile(vb::Span<const uint8_t>{embed_asc_wasm.data(), embed_asc_wasm.size()},
+                  vb::Span<vb::NativeSymbol const>{warpo::frontend::getLinkedAPI().data(),
+                                                   warpo::frontend::getLinkedAPI().size()});
     m.initFromCompiledBinary(
         vb::Span<uint8_t const>{embedJitCode.getModule().data(), embedJitCode.getModule().size()},
         vb::Span<vb::NativeSymbol const>{},
@@ -365,10 +367,10 @@ warpo::frontend::CompilationResult FrontendCompiler::compile(std::vector<std::st
     int32_t const compiled = m.callExportedFunctionWithName<1>(stackTop, "compile", program)[0].i32;
     if (checkDiag(program, config.useColorfulDiagMessage))
       return {.m = {}, .errorMessage = errorMessage_};
-    wasm::Module *binaryen_module = reinterpret_cast<wasm::Module *>(
-        m.callExportedFunctionWithName<1>(stackTop, "getBinaryenModuleRef", compiled)[0].i64);
+    asModule_.set(BinaryenModule{reinterpret_cast<wasm::Module *>(
+        m.callExportedFunctionWithName<1>(stackTop, "getBinaryenModuleRef", compiled)[0].i64)});
     compileStat.release();
-    return {.m = AsModule{binaryen_module}, .errorMessage = errorMessage_};
+    return {.m = std::move(asModule_), .errorMessage = errorMessage_};
   } catch (vb::TrapException const &e) {
     logger << "Error: " << e.what() << vb::endStatement;
     m.printStacktrace(logger);

frontend/CompilerImpl.hpp

@@ -14,6 +14,7 @@
 #include <string_view>
 #include <vector>
 
+#include "warpo/common/AsModule.hpp"
 #include "warpo/frontend/Compiler.hpp"
 #include "wasm-compiler/src/WasmModule/WasmModule.hpp"
 #include "wasm-compiler/src/utils/STDCompilerLogger.hpp"
@@ -29,6 +30,7 @@ class FrontendCompiler {
   std::map<std::string, std::filesystem::path> packageRootMap_{};
   size_t errorCount_ = 0;
   std::string errorMessage_;
+  AsModule asModule_;
 
   int32_t allocString(std::string_view str);
   std::u16string utf8ToUtf16(std::string const &utf8Str);

frontend/LinkedAPI.cpp

@@ -6,6 +6,10 @@
 
 namespace warpo::frontend {
 
-extern const std::vector<vb::NativeSymbol> linkedAPI;
+std::vector<vb::NativeSymbol> createAssemblyscriptAPI();
+std::vector<vb::NativeSymbol> createCppWrapperAPI();
+std::vector<vb::NativeSymbol> createBinaryenLinkedAPI();
 
-}
+std::vector<vb::NativeSymbol> const &getLinkedAPI();
+
+} // namespace warpo::frontend

frontend/LinkedAPI.hpp

@@ -0,0 +1,81 @@
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <fmt/base.h>
+#include <iostream>
+#include <sstream>
+#include <utility>
+#include <vector>
+
+#include "LinkedAPI.hpp"
+#include "wasm-compiler/src/WasmModule/WasmModule.hpp"
+#include "wasm-compiler/src/core/common/NativeSymbol.hpp"
+#include "wasm-compiler/src/core/common/function_traits.hpp"
+
+namespace warpo::frontend {
+
+namespace {
+
+std::string getAsString(uint32_t ptr, vb::WasmModule *ctx) {
+  if (ptr == 0U)
+    return "<<NULL>>";
+  uint8_t const *header = ctx->getLinearMemoryRegion(ptr - 20U, 20);
+  uint32_t size = 0;
+  std::memcpy(&size, header + 16, sizeof(size));
+  uint8_t const *content = ctx->getLinearMemoryRegion(ptr, size);
+  size /= 2U;
+
+  std::stringstream ss{};
+  for (uint32_t i = 0; i < size; ++i) {
+    ss << content[i * 2U];
+  }
+  return std::move(ss).str();
+}
+
+void abortForLink(uint32_t messagePtr, uint32_t fileNamePtr, uint32_t lineNumber, uint32_t columnNumber,
+                  vb::WasmModule *ctx) {
+  std::stringstream ss{};
+  ss << "abort: " << getAsString(messagePtr, ctx) << " in " << getAsString(fileNamePtr, ctx) << ":" << lineNumber << ":"
+     << columnNumber;
+  std::cerr << std::move(ss).str() << std::endl;
+  ctx->requestInterruption(vb::TrapCode::BUILTIN_TRAP);
+}
+
+void traceForLink(uint32_t ptr, uint32_t n, double d1, double d2, double d3, double d4, double d5,
+                  vb::WasmModule *ctx) {
+  std::stringstream ss{};
+  ss << getAsString(ptr, ctx);
+  for (size_t i = 0; i < n; i++) {
+    switch (i) {
+    case 1:
+      ss << " " << d1;
+      break;
+    case 2:
+      ss << " " << d2;
+      break;
+    case 3:
+      ss << " " << d3;
+      break;
+    case 4:
+      ss << " " << d4;
+      break;
+    case 5:
+      ss << " " << d5;
+      break;
+    }
+  }
+  std::cout << std::move(ss).str() << std::endl;
+}
+
+} // namespace
+
+std::vector<vb::NativeSymbol> createAssemblyscriptAPI() {
+  return std::vector<vb::NativeSymbol>{
+      STATIC_LINK("env", "abort", abortForLink),
+      STATIC_LINK("env", "trace", traceForLink),
+  };
+}
+
+} // namespace warpo::frontend