DebugLocationPropagation: pass debuglocation from parent node to chil…

src/parser/wat-parser.cpp

@@ -94,52 +94,8 @@ Result<> parseDefs(Ctx& ctx,
 void propagateDebugLocations(Module& wasm) {
   // Copy debug locations from parents or previous siblings to expressions that
   // do not already have their own debug locations.
-  struct Propagator : WalkerPass<ExpressionStackWalker<Propagator>> {
-    using Super = WalkerPass<ExpressionStackWalker<Propagator>>;
-    bool isFunctionParallel() override { return true; }
-    bool modifiesBinaryenIR() override { return false; }
-    bool requiresNonNullableLocalFixups() override { return false; }
-    void runOnFunction(Module* module, Function* func) override {
-      if (!func->debugLocations.empty()) {
-        Super::runOnFunction(module, func);
-      }
-    }
-
-    // Unannotated instructions inherit either their previous sibling's location
-    // or their parent's location. Look up whichever is current for a given
-    // parent.
-    std::unordered_map<Expression*, Function::DebugLocation> parentDefaults;
-
-    static void doPreVisit(Propagator* self, Expression** currp) {
-      Super::doPreVisit(self, currp);
-      auto* curr = *currp;
-      auto& locs = self->getFunction()->debugLocations;
-      auto& parentDefaults = self->parentDefaults;
-      if (auto it = locs.find(curr); it != locs.end()) {
-        // Children will inherit this location.
-        parentDefaults[curr] = it->second;
-        if (auto* parent = self->getParent()) {
-          // Subsequent siblings will inherit this location.
-          parentDefaults[parent] = it->second;
-        }
-      } else {
-        // No annotation, see if we should inherit one.
-        if (auto* parent = self->getParent()) {
-          if (auto defaultIt = parentDefaults.find(parent);
-              defaultIt != parentDefaults.end()) {
-            // We have a default to inherit. Our children will inherit it, too.
-            locs[curr] = parentDefaults[curr] = defaultIt->second;
-          }
-        }
-      }
-    }
-
-    std::unique_ptr<Pass> create() override {
-      return std::make_unique<Propagator>();
-    }
-  };
   PassRunner runner(&wasm);
-  runner.add(std::make_unique<Propagator>());
+  runner.add("dlp");
   runner.run();
 }
 

src/passes/CMakeLists.txt

@@ -29,6 +29,7 @@ set(passes_SOURCES
   DeadArgumentElimination.cpp
   DeadCodeElimination.cpp
   DeAlign.cpp
+  DebugLocationPropagation.cpp
   DeNaN.cpp
   Directize.cpp
   DuplicateImportElimination.cpp

src/passes/DebugLocationPropagation.cpp

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2024 WebAssembly Community Group participants
+ *
+ * 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.
+ */
+
+//
+// DebugLocationPropagation aim to pass debug location from parents or
+// previous siblings to expression which has no debug location. This is
+// useful for compilers that use Binaryen API to generate WebAssembly modules.
+//
+
+#include "pass.h"
+#include "wasm-traversal.h"
+#include "wasm.h"
+#include <cassert>
+#include <unordered_map>
+
+namespace wasm {
+
+struct DebugLocationPropagation
+  : WalkerPass<PostWalker<DebugLocationPropagation>> {
+  ExpressionStack expressionStack;
+
+  using Super = WalkerPass<PostWalker<DebugLocationPropagation>>;
+  bool isFunctionParallel() override { return false; }
+  bool modifiesBinaryenIR() override { return false; }
+  bool requiresNonNullableLocalFixups() override { return false; }
+  void runOnFunction(Module* module, Function* func) override {
+    if (!func->debugLocations.empty()) {
+      Super::runOnFunction(module, func);
+    }
+  }
+
+  Expression* getPrevious() {
+    if (expressionStack.empty()) {
+      return nullptr;
+    }
+    assert(expressionStack.size() >= 1);
+    return expressionStack[expressionStack.size() - 1];
+  }
+
+  static void doPreVisit(DebugLocationPropagation* self, Expression** currp) {
+    auto* curr = *currp;
+    auto& locs = self->getFunction()->debugLocations;
+    auto& expressionStack = self->expressionStack;
+    if (locs.find(curr) == locs.end()) {
+      // No debug location, see if we should inherit one.
+      if (auto* previous = self->getPrevious()) {
+        if (auto it = locs.find(previous); it != locs.end()) {
+          locs[curr] = it->second;
+        }
+      }
+    }
+    expressionStack.push_back(curr);
+  }
+
+  static void doPostVisit(DebugLocationPropagation* self, Expression** currp) {
+    auto& exprStack = self->expressionStack;
+    while (exprStack.back() != *currp && !exprStack.empty()) {
+      exprStack.pop_back();
+    }
+    assert(!exprStack.empty());
+  }
+
+  static void scan(DebugLocationPropagation* self, Expression** currp) {
+    self->pushTask(DebugLocationPropagation::doPostVisit, currp);
+
+    PostWalker<DebugLocationPropagation,
+               Visitor<DebugLocationPropagation>>::scan(self, currp);
+
+    self->pushTask(DebugLocationPropagation::doPreVisit, currp);
+  }
+
+  std::unique_ptr<Pass> create() override {
+    return std::make_unique<DebugLocationPropagation>();
+  }
+};
+
+Pass* createDebugLocationPropagationPass() {
+  return new DebugLocationPropagation();
+}
+
+} // namespace wasm

src/passes/pass.cpp

@@ -126,6 +126,10 @@ void PassRegistry::registerPasses() {
   registerPass("dealign",
                "forces all loads and stores to have alignment 1",
                createDeAlignPass);
+  registerPass(
+    "dlp",
+    "propagate debug location from parents or previous siblings to child nodes",
+    createDebugLocationPropagationPass);
   registerPass("denan",
                "instrument the wasm to convert NaNs into 0 at runtime",
                createDeNaNPass);

src/passes/passes.h

@@ -38,6 +38,7 @@ Pass* createDataFlowOptsPass();
 Pass* createDeadCodeEliminationPass();
 Pass* createDeNaNPass();
 Pass* createDeAlignPass();
+Pass* createDebugLocationPropagationPass();
 Pass* createDirectizePass();
 Pass* createDiscardGlobalEffectsPass();
 Pass* createDWARFDumpPass();

test/example/debug-location-propagation.cpp

@@ -0,0 +1,47 @@
+#include <cassert>
+#include <iostream>
+
+#include <binaryen-c.h>
+#include <wasm.h>
+
+int main() {
+  BinaryenModuleRef module = BinaryenModuleCreate();
+
+  BinaryenType ii[2] = {BinaryenTypeInt32(), BinaryenTypeInt32()};
+  BinaryenType params = BinaryenTypeCreate(ii, 2);
+  BinaryenType results = BinaryenTypeNone();
+
+  BinaryenExpressionRef x = BinaryenLocalGet(module, 0, BinaryenTypeInt32()),
+                        y = BinaryenLocalGet(module, 1, BinaryenTypeInt32());
+  BinaryenExpressionRef add = BinaryenBinary(module, BinaryenAddInt32(), x, y);
+  BinaryenExpressionRef drop = BinaryenDrop(module, add);
+  BinaryenExpressionRef funcBody =
+    BinaryenBlock(module, "", &drop, 1, BinaryenTypeNone());
+
+  BinaryenFunctionRef adder =
+    BinaryenAddFunction(module, "adder", params, results, NULL, 0, funcBody);
+
+  BinaryenModuleAddDebugInfoFileName(module, "main");
+
+  BinaryenFunctionSetDebugLocation(adder, x, 0, 2, 13);
+  BinaryenFunctionSetDebugLocation(adder, drop, 0, 2, 2);
+
+  BinaryenModuleValidate(module);
+  BinaryenSetDebugInfo(true);
+  const char* runPasses[] = {"dlp"};
+  BinaryenModuleRunPasses(module, runPasses, 1);
+
+  auto& debugLocations = module->getFunction("adder")->debugLocations;
+  assert(debugLocations.size() == 4);
+  assert(debugLocations[x].columnNumber == 13);
+  assert(debugLocations[y].columnNumber == 13);
+  assert(debugLocations[add].columnNumber == 2);
+  assert(debugLocations[drop].columnNumber == 2);
+
+  BinaryenSetDebugInfo(false);
+  BinaryenModuleDispose(module);
+
+  std::cout << "success." << std::endl;
+
+  return 0;
+}

test/example/debug-location-propagation.txt

@@ -0,0 +1 @@
+success.

test/lit/help/wasm-opt.test

@@ -139,6 +139,10 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --discard-global-effects                      discards global effect info
 ;; CHECK-NEXT:
+;; CHECK-NEXT:   --dlp                                         propagate debug location from
+;; CHECK-NEXT:                                                 parents or previous siblings to
+;; CHECK-NEXT:                                                 child nodes
+;; CHECK-NEXT:
 ;; CHECK-NEXT:   --duplicate-function-elimination              removes duplicate functions
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --duplicate-import-elimination                removes duplicate imports

test/lit/help/wasm2js.test

@@ -93,6 +93,10 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --discard-global-effects                      discards global effect info
 ;; CHECK-NEXT:
+;; CHECK-NEXT:   --dlp                                         propagate debug location from
+;; CHECK-NEXT:                                                 parents or previous siblings to
+;; CHECK-NEXT:                                                 child nodes
+;; CHECK-NEXT:
 ;; CHECK-NEXT:   --duplicate-function-elimination              removes duplicate functions
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --duplicate-import-elimination                removes duplicate imports