[DebugInfo] Copy debug info in call-utils.h

src/ir/CMakeLists.txt

@@ -2,6 +2,7 @@ FILE(GLOB ir_HEADERS *.h)
 set(ir_SOURCES
   ExpressionAnalyzer.cpp
   ExpressionManipulator.cpp
+  debuginfo.cpp
   drop.cpp
   effects.cpp
   eh-utils.cpp

src/ir/debug.h → src/ir/debuginfo.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 WebAssembly Community Group participants
+ * 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.
@@ -14,19 +14,16 @@
  * limitations under the License.
  */
 
-#ifndef wasm_ir_debug_h
-#define wasm_ir_debug_h
+#include "ir/debuginfo.h"
+#include "wasm-traversal.h"
+#include "wasm.h"
 
-#include <wasm-traversal.h>
+namespace wasm::debuginfo {
 
-namespace wasm::debug {
-
-// Given an expression and a copy of it in another function, copy the debug
-// info into the second function.
-inline void copyDebugInfo(Expression* origin,
-                          Expression* copy,
-                          Function* originFunc,
-                          Function* copyFunc) {
+void copyDebugInfoBetweenFunctions(Expression* origin,
+                                   Expression* copy,
+                                   Function* originFunc,
+                                   Function* copyFunc) {
   if (originFunc->debugLocations.empty()) {
     return; // No debug info to copy
   }
@@ -52,8 +49,6 @@ inline void copyDebugInfo(Expression* origin,
       copyDebug[copyList.list[i]] = location;
     }
   }
-};
-
-} // namespace wasm::debug
+}
 
-#endif // wasm_ir_debug_h
+} // namespace wasm::debuginfo

src/ir/debuginfo.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2019 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.
+ */
+
+#ifndef wasm_ir_debuginfo_h
+#define wasm_ir_debuginfo_h
+
+#include "wasm.h"
+
+namespace wasm::debuginfo {
+
+// Given an expression and another that it replaces, copy the debug info from
+// the latter to the former. Note that the expression may not be an exclusive
+// replacement of the other (the other may be replaced by several expressions,
+// all of whom may end up with the same debug info).
+inline void copyDebugInfoToReplacement(Expression* replacement,
+                                       Expression* original,
+                                       Function* func) {
+  auto& debugLocations = func->debugLocations;
+  // Early exit if there is no debug info at all. Also, leave if we already
+  // have debug info on the new replacement, which we don't want to trample:
+  // if there is no debug info we do want to copy, as a replacement operation
+  // suggests the new code plays the same role (it is an optimized version of
+  // the old), but if the code is already annotated, trust that.
+  if (debugLocations.empty() || debugLocations.count(replacement)) {
+    return;
+  }
+
+  auto iter = debugLocations.find(original);
+  if (iter != debugLocations.end()) {
+    debugLocations[replacement] = iter->second;
+    // Note that we do *not* erase the debug info of the expression being
+    // replaced, because it may still exist: we might replace
+    //
+    //  (call
+    //    (block ..
+    //
+    // with
+    //
+    //  (block
+    //    (call ..
+    //
+    // We still want the call here to have its old debug info.
+    //
+    // (In most cases, of course, we do remove the replaced expression,
+    // which means we accumulate unused garbage in debugLocations, but
+    // that's not that bad; we use arena allocation for Expressions, after
+    // all.)
+  }
+}
+
+// Given an expression and a copy of it in another function, copy the debug
+// info into the second function.
+void copyDebugInfoBetweenFunctions(Expression* origin,
+                                   Expression* copy,
+                                   Function* originFunc,
+                                   Function* copyFunc);
+} // namespace wasm::debuginfo
+
+#endif // wasm_ir_debuginfo_h

src/ir/module-utils.cpp

@@ -15,7 +15,7 @@
  */
 
 #include "module-utils.h"
-#include "ir/debug.h"
+#include "ir/debuginfo.h"
 #include "ir/intrinsics.h"
 #include "ir/manipulation.h"
 #include "ir/properties.h"
@@ -54,7 +54,8 @@ Function* copyFunction(Function* func,
   ret->localNames = func->localNames;
   ret->localIndices = func->localIndices;
   ret->body = ExpressionManipulator::copy(func->body, out);
-  debug::copyDebugInfo(func->body, ret->body, func, ret.get());
+  debuginfo::copyDebugInfoBetweenFunctions(
+    func->body, ret->body, func, ret.get());
   ret->prologLocation = func->prologLocation;
   ret->epilogLocation = func->epilogLocation;
   // Update file indices if needed

src/passes/Inlining.cpp

@@ -31,7 +31,7 @@
 #include <atomic>
 
 #include "ir/branch-utils.h"
-#include "ir/debug.h"
+#include "ir/debuginfo.h"
 #include "ir/drop.h"
 #include "ir/eh-utils.h"
 #include "ir/element-utils.h"
@@ -579,7 +579,7 @@ static Expression* doInlining(Module* module,
 
   // Generate and update the inlined contents
   auto* contents = ExpressionManipulator::copy(from->body, *module);
-  debug::copyDebugInfo(from->body, contents, from, into);
+  debuginfo::copyDebugInfoBetweenFunctions(from->body, contents, from, into);
   updater.walk(contents);
   block->list.push_back(contents);
   block->type = retType;

src/passes/call-utils.h

@@ -19,6 +19,7 @@
 
 #include <variant>
 
+#include "ir/debuginfo.h"
 #include "ir/type-updating.h"
 #include "wasm.h"
 
@@ -130,14 +131,17 @@ convertToDirectCalls(T* curr,
   };
 
   auto makeCall = [&](IndirectCallInfo info) -> Expression* {
+    Expression* ret;
     if (std::get_if<Trap>(&info)) {
-      return builder.makeUnreachable();
+      ret = builder.makeUnreachable();
     } else {
-      return builder.makeCall(std::get<Known>(info).target,
-                              getOperands(),
-                              curr->type,
-                              curr->isReturn);
+      ret = builder.makeCall(std::get<Known>(info).target,
+                             getOperands(),
+                             curr->type,
+                             curr->isReturn);
     }
+    debuginfo::copyDebugInfoToReplacement(ret, curr, &func);
+    return ret;
   };
   auto* ifTrueCall = makeCall(ifTrueCallInfo);
   auto* ifFalseCall = makeCall(ifFalseCallInfo);

src/wasm-traversal.h

@@ -27,6 +27,7 @@
 #ifndef wasm_wasm_traversal_h
 #define wasm_wasm_traversal_h
 
+#include "ir/debuginfo.h"
 #include "support/small_vector.h"
 #include "support/threads.h"
 #include "wasm.h"
@@ -123,36 +124,8 @@ struct Walker : public VisitorType {
   Expression* replaceCurrent(Expression* expression) {
     // Copy debug info, if present.
     if (currFunction) {
-      auto& debugLocations = currFunction->debugLocations;
-      // Early exit if there is no debug info at all. Also, leave if we already
-      // have debug info on the new expression, which we don't want to trample:
-      // if there is no debug info we do want to copy, as a replacement
-      // operation suggests the new code plays the same role (it is an optimized
-      // version of the old), but if the code is already annotated, trust that.
-      if (!debugLocations.empty() && !debugLocations.count(expression)) {
-        auto* curr = getCurrent();
-        auto iter = debugLocations.find(curr);
-        if (iter != debugLocations.end()) {
-          debugLocations[expression] = iter->second;
-          // Note that we do *not* erase the debug info of the expression being
-          // replaced, because it may still exist: we might replace
-          //
-          //  (call
-          //    (block ..
-          //
-          // with
-          //
-          //  (block
-          //    (call ..
-          //
-          // We still want the call here to have its old debug info.
-          //
-          // (In most cases, of course, we do remove the replaced expression,
-          // which means we accumulate unused garbage in debugLocations, but
-          // that's not that bad; we use arena allocation for Expressions, after
-          // all.)
-        }
-      }
+      debuginfo::copyDebugInfoToReplacement(
+        expression, getCurrent(), currFunction);
     }
     return *replacep = expression;
   }

test/lit/passes/optimize-instructions-call_ref.wast

@@ -44,13 +44,16 @@
  )
 
  ;; CHECK:      (func $call_ref-to-direct (type $i32_i32_=>_none) (param $x i32) (param $y i32)
+ ;; CHECK-NEXT:  ;;@ file.cpp:10:1
  ;; CHECK-NEXT:  (call $foo
  ;; CHECK-NEXT:   (local.get $x)
  ;; CHECK-NEXT:   (local.get $y)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $call_ref-to-direct (param $x i32) (param $y i32)
-  ;; This call_ref should become a direct call.
+  ;; This call_ref should become a direct call. The debuginfo should transfer as
+  ;; well.
+  ;;@ file.cpp:10:1
   (call_ref $i32_i32_=>_none
    (local.get $x)
    (local.get $y)
@@ -253,29 +256,42 @@
  ;; CHECK:      (func $call_ref-to-select (type $5) (param $x i32) (param $y i32) (param $z i32) (param $f (ref $i32_i32_=>_none))
  ;; CHECK-NEXT:  (local $4 i32)
  ;; CHECK-NEXT:  (local $5 i32)
+ ;; CHECK-NEXT:  ;;@ file.cpp:20:2
  ;; CHECK-NEXT:  (block
+ ;; CHECK-NEXT:   ;;@
  ;; CHECK-NEXT:   (local.set $4
+ ;; CHECK-NEXT:    ;;@ file.cpp:20:2
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   ;;@
  ;; CHECK-NEXT:   (local.set $5
+ ;; CHECK-NEXT:    ;;@ file.cpp:20:2
  ;; CHECK-NEXT:    (local.get $y)
  ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   ;;@
  ;; CHECK-NEXT:   (if
+ ;; CHECK-NEXT:    ;;@ file.cpp:20:2
  ;; CHECK-NEXT:    (local.get $z)
  ;; CHECK-NEXT:    (then
  ;; CHECK-NEXT:     (call $foo
+ ;; CHECK-NEXT:      ;;@
  ;; CHECK-NEXT:      (local.get $4)
+ ;; CHECK-NEXT:      ;;@
  ;; CHECK-NEXT:      (local.get $5)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (else
+ ;; CHECK-NEXT:     ;;@ file.cpp:20:2
  ;; CHECK-NEXT:     (call $bar
+ ;; CHECK-NEXT:      ;;@
  ;; CHECK-NEXT:      (local.get $4)
+ ;; CHECK-NEXT:      ;;@
  ;; CHECK-NEXT:      (local.get $5)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  ;;@ file.cpp:30:3
  ;; CHECK-NEXT:  (call_ref $i32_i32_=>_none
  ;; CHECK-NEXT:   (local.get $x)
  ;; CHECK-NEXT:   (local.get $y)
@@ -287,7 +303,11 @@
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $call_ref-to-select (param $x i32) (param $y i32) (param $z i32) (param $f (ref $i32_i32_=>_none))
-  ;; This call_ref should become an if over two direct calls.
+  ;; This call_ref should become an if over two direct calls. The debuginfo
+  ;; should transfer as well to the two new calls (and some of the new helper
+  ;; code that is generated, but the critical part is the call_ref is being
+  ;; replaced by two calls, which should have the same info).
+  ;;@ file.cpp:20:2
   (call_ref $i32_i32_=>_none
    (local.get $x)
    (local.get $y)
@@ -299,6 +319,7 @@
   )
 
   ;; But here one arm is not constant, so we do not optimize.
+  ;;@ file.cpp:30:3
   (call_ref $i32_i32_=>_none
    (local.get $x)
    (local.get $y)