feat(ImmutableLoadEliminating): implement ImmutableLoadEliminating optimization (#124)

Some of the data in the data segment generated by AS is immutable, but
binaryen assumes it is mutable during optimization. As a result, some
optimization passes are missed. This PR passes the immutable data
segment range from AS front-end to binaryen through an additional object
in AsModule, and uses an optimization pass to simplify the load
instruction to const instruction.

Author: HerrCai0907

assemblyscript/src/compiler.ts

@@ -219,6 +219,7 @@ import {
   liftRequiresExportRuntime,
   lowerRequiresExportRuntime
 } from "./bindings/js";
+import { markDataElementImmutable } from "./warpo";
 
 /** Features enabled by default. */
 export const defaultFeatures = Feature.MutableGlobals
@@ -2073,6 +2074,7 @@ export class Compiler extends DiagnosticEmitter {
       assert(rtInstance.writeField("_index", index, buf));
       assert(rtInstance.writeField("_env", 0, buf));
       instance.memorySegment = memorySegment = this.addRuntimeMemorySegment(buf);
+      markDataElementImmutable(i64_add(memorySegment.offset, i64_new(program.totalOverhead)), rtInstance.nextMemoryOffset);
     }
     return i64_add(memorySegment.offset, i64_new(program.totalOverhead));
   }

assemblyscript/src/warpo.ts

@@ -0,0 +1,5 @@
+declare function _WarpoMarkDataElementImmutable(begin: u32, size: u32): void;
+
+export function markDataElementImmutable(begin: i64, size: i32): void {
+  _WarpoMarkDataElementImmutable(i64_low(begin), <u32>size);
+}

common/AsModule.cpp

@@ -0,0 +1,29 @@
+// Copyright (C) 2025 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "warpo/common/AsModule.hpp"
+
+namespace warpo {
+
+bool ImmutableDataElementRanges::contains(uint32_t offset, uint32_t size) const {
+  for (DataElementRange const &range : *this) {
+    if (offset >= range.begin_ && (offset + size) <= range.end_)
+      return true;
+  }
+  return false;
+}
+
+} // namespace warpo

frontend/CompilerImpl.hpp

@@ -30,7 +30,6 @@ 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);
@@ -67,6 +66,7 @@ class FrontendCompiler {
   CompilationResult compile(std::vector<std::string> const &entryFilePaths, Config const &config);
 
   std::set<void *> allocedPtrs_;
+  AsModule asModule_;
 };
 
 } // namespace warpo::frontend

frontend/LinkedAPI.cpp

@@ -16,6 +16,7 @@ std::vector<vb::NativeSymbol> createLinkedAPI() {
   append(linkedAPI, createAssemblyscriptAPI());
   append(linkedAPI, createCppWrapperAPI());
   append(linkedAPI, createBinaryenLinkedAPI());
+  append(linkedAPI, createOptAPI());
   return linkedAPI;
 }
 

frontend/LinkedAPI.hpp

@@ -7,8 +7,9 @@
 namespace warpo::frontend {
 
 std::vector<vb::NativeSymbol> createAssemblyscriptAPI();
-std::vector<vb::NativeSymbol> createCppWrapperAPI();
 std::vector<vb::NativeSymbol> createBinaryenLinkedAPI();
+std::vector<vb::NativeSymbol> createCppWrapperAPI();
+std::vector<vb::NativeSymbol> createOptAPI();
 
 std::vector<vb::NativeSymbol> const &getLinkedAPI();
 

frontend/LinkedAPIAssemblyscript.cpp

@@ -1,3 +1,4 @@
+#include <bit>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
@@ -47,7 +48,7 @@ void traceForLink(uint32_t ptr, uint32_t n, double d1, double d2, double d3, dou
                   vb::WasmModule *ctx) {
   std::stringstream ss{};
   ss << getAsString(ptr, ctx);
-  for (size_t i = 0; i < n; i++) {
+  for (size_t i = 1U; i <= n; i++) {
     switch (i) {
     case 1:
       ss << " " << d1;

frontend/LinkedAPIOpt.cpp

@@ -0,0 +1,33 @@
+#include <cassert>
+#include <iostream>
+
+#include "CompilerImpl.hpp"
+#include "LinkedAPI.hpp"
+#include "warpo/common/AsModule.hpp"
+
+#include "src/core/common/function_traits.hpp"
+
+namespace warpo::frontend {
+
+namespace {
+
+FrontendCompiler *getFrontendCompiler(vb::WasmModule *ctx) {
+  return static_cast<FrontendCompiler *>(ctx->getContext());
+}
+
+void markDataElementImmutableForLink(uint32_t offset, uint32_t size, [[maybe_unused]] vb::WasmModule *ctx) {
+  AsModule *const m = &getFrontendCompiler(ctx)->asModule_;
+  if (m->immutableRanges_ == nullptr)
+    m->immutableRanges_ = std::make_shared<ImmutableDataElementRanges>();
+  m->immutableRanges_->insert({offset, offset + size});
+}
+
+} // namespace
+
+std::vector<vb::NativeSymbol> createOptAPI() {
+  return std::vector<vb::NativeSymbol>{
+      STATIC_LINK("warpo", "_WarpoMarkDataElementImmutable", markDataElementImmutableForLink),
+  };
+}
+
+} // namespace warpo::frontend

include/warpo/common/AsModule.hpp

@@ -19,6 +19,7 @@
 #include <binaryen/src/binaryen-c.h>
 #include <compare>
 #include <cstddef>
+#include <memory>
 #include <set>
 #include <utility>
 
@@ -44,7 +45,7 @@ class BinaryenModule {
   }
 
   BinaryenModule() noexcept : BinaryenModule(nullptr) {}
-  BinaryenModule(BinaryenModuleRef ref) noexcept : ref_(ref) {}
+  explicit BinaryenModule(BinaryenModuleRef ref) noexcept : ref_(ref) {}
   ~BinaryenModule() noexcept {
     if (ref_ != nullptr)
       BinaryenModuleDispose(ref_);
@@ -74,14 +75,21 @@ class DataElementRange {
   }
 };
 
+struct ImmutableDataElementRanges : private std::set<DataElementRange> {
+  using std::set<DataElementRange>::insert;
+  bool contains(uint32_t offset, uint32_t size) const;
+};
+
 class AsModule {
   BinaryenModule raw_;
 
 public:
-  std::set<DataElementRange> immutableRanges_;
+  std::shared_ptr<ImmutableDataElementRanges> immutableRanges_;
   // TODO: more information fields
 
   AsModule() = default;
+  explicit AsModule(BinaryenModuleRef ref) : raw_{ref}, immutableRanges_{nullptr} {}
+
   void set(BinaryenModule raw) { raw_ = std::move(raw); }
   BinaryenModuleRef get() const { return raw_.get(); }
   bool valid() const { return raw_ != nullptr; }

include/warpo/passes/Runner.hpp

@@ -5,6 +5,8 @@
 #include <string>
 #include <vector>
 
+#include "warpo/common/AsModule.hpp"
+
 namespace warpo::passes {
 
 struct Output {
@@ -20,9 +22,9 @@ struct Config {
 void init();
 
 Output runOnWat(std::string const &input, Config const &config);
-Output runOnModule(BinaryenModuleRef const m, Config const &config);
+Output runOnModule(AsModule const &m, Config const &config);
 
-void runAndEmit(BinaryenModuleRef const m, std::string const &outputPath);
+void runAndEmit(AsModule const &m, std::string const &outputPath);
 void runAndEmit(std::string const &inputPath, std::string const &outputPath);
 
 } // namespace warpo::passes