Support 5 segment source mappings

src/binaryen-c.cpp

@@ -5662,6 +5662,14 @@ void BinaryenModuleInterpret(BinaryenModuleRef module) {
   ModuleRunner instance(*(Module*)module, &interface, {});
 }
 
+BinaryenIndex BinaryenModuleAddDebugInfoSymbolName(BinaryenModuleRef module,
+                                                   const char* symbolname) {
+  auto& debugInfoSymbolNames = ((Module*)module)->debugInfoSymbolNames;
+  BinaryenIndex index = debugInfoSymbolNames.size();
+  debugInfoSymbolNames.push_back(symbolname);
+  return index;
+}
+
 BinaryenIndex BinaryenModuleAddDebugInfoFileName(BinaryenModuleRef module,
                                                  const char* filename) {
   auto& debugInfoFileNames = ((Module*)module)->debugInfoFileNames;
@@ -5670,6 +5678,14 @@ BinaryenIndex BinaryenModuleAddDebugInfoFileName(BinaryenModuleRef module,
   return index;
 }
 
+const char* BinaryenModuleGetDebugInfoSymbolName(BinaryenModuleRef module,
+                                                 BinaryenIndex index) {
+  const auto& debugInfoSymbolNames = ((Module*)module)->debugInfoSymbolNames;
+  return index < debugInfoSymbolNames.size()
+           ? debugInfoSymbolNames.at(index).c_str()
+           : nullptr;
+}
+
 const char* BinaryenModuleGetDebugInfoFileName(BinaryenModuleRef module,
                                                BinaryenIndex index) {
   const auto& debugInfoFileNames = ((Module*)module)->debugInfoFileNames;

src/ir/module-utils.cpp

@@ -38,23 +38,40 @@ static void updateLocationSet(std::set<Function::DebugLocation>& locations,
   std::swap(locations, updatedLocations);
 }
 
+static void updateSymbolSet(std::set<Function::DebugLocation>& locations,
+                            std::vector<Index>& symbolIndexMap) {
+  std::set<Function::DebugLocation> updatedLocations;
+
+  for (auto iter : locations) {
+    if (iter.symbolNameIndex.has_value()) {
+      iter.symbolNameIndex = symbolIndexMap[*iter.symbolNameIndex];
+    }
+    updatedLocations.insert(iter);
+  }
+  locations.clear();
+  std::swap(locations, updatedLocations);
+}
+
 // Copies a function into a module. If newName is provided it is used as the
 // name of the function (otherwise the original name is copied). If fileIndexMap
 // is specified, it is used to rename source map filename indices when copying
 // the function from one module to another one.
 Function* copyFunction(Function* func,
                        Module& out,
                        Name newName,
-                       std::optional<std::vector<Index>> fileIndexMap) {
-  auto ret = copyFunctionWithoutAdd(func, out, newName, fileIndexMap);
+                       std::optional<std::vector<Index>> fileIndexMap,
+                       std::optional<std::vector<Index>> symbolNameIndexMap) {
+  auto ret = copyFunctionWithoutAdd(
+    func, out, newName, fileIndexMap, symbolNameIndexMap);
   return out.addFunction(std::move(ret));
 }
 
 std::unique_ptr<Function>
 copyFunctionWithoutAdd(Function* func,
                        Module& out,
                        Name newName,
-                       std::optional<std::vector<Index>> fileIndexMap) {
+                       std::optional<std::vector<Index>> fileIndexMap,
+                       std::optional<std::vector<Index>> symbolNameIndexMap) {
   auto ret = std::make_unique<Function>();
   ret->name = newName.is() ? newName : func->name;
   ret->hasExplicitName = func->hasExplicitName;
@@ -76,6 +93,18 @@ copyFunctionWithoutAdd(Function* func,
     updateLocationSet(ret->prologLocation, *fileIndexMap);
     updateLocationSet(ret->epilogLocation, *fileIndexMap);
   }
+  if (symbolNameIndexMap) {
+    for (auto& iter : ret->debugLocations) {
+      if (iter.second) {
+        if (iter.second->symbolNameIndex.has_value()) {
+          iter.second->symbolNameIndex =
+            (*symbolNameIndexMap)[*(iter.second->symbolNameIndex)];
+        }
+      }
+      updateSymbolSet(ret->prologLocation, *symbolNameIndexMap);
+      updateSymbolSet(ret->epilogLocation, *symbolNameIndexMap);
+    }
+  }
   ret->module = func->module;
   ret->base = func->base;
   ret->noFullInline = func->noFullInline;
@@ -199,8 +228,27 @@ void copyModuleItems(const Module& in, Module& out) {
     }
   }
 
+  std::optional<std::vector<Index>> symbolNameIndexMap;
+  if (!in.debugInfoSymbolNames.empty()) {
+    std::unordered_map<std::string, Index> debugInfoSymbolNameIndices;
+    for (Index i = 0; i < out.debugInfoSymbolNames.size(); i++) {
+      debugInfoSymbolNameIndices[out.debugInfoSymbolNames[i]] = i;
+    }
+    symbolNameIndexMap.emplace();
+    for (Index i = 0; i < in.debugInfoSymbolNames.size(); i++) {
+      std::string file = in.debugInfoSymbolNames[i];
+      auto iter = debugInfoSymbolNameIndices.find(file);
+      if (iter == debugInfoSymbolNameIndices.end()) {
+        Index index = out.debugInfoSymbolNames.size();
+        out.debugInfoSymbolNames.push_back(file);
+        debugInfoSymbolNameIndices[file] = index;
+      }
+      symbolNameIndexMap->push_back(debugInfoSymbolNameIndices[file]);
+    }
+  }
+
   for (auto& curr : in.functions) {
-    copyFunction(curr.get(), out, Name(), fileIndexMap);
+    copyFunction(curr.get(), out, Name(), fileIndexMap, symbolNameIndexMap);
   }
   for (auto& curr : in.globals) {
     copyGlobal(curr.get(), out);
@@ -241,6 +289,7 @@ void copyModule(const Module& in, Module& out) {
   out.start = in.start;
   out.customSections = in.customSections;
   out.debugInfoFileNames = in.debugInfoFileNames;
+  out.debugInfoSymbolNames = in.debugInfoSymbolNames;
   out.features = in.features;
 }
 

src/ir/module-utils.h

@@ -28,18 +28,20 @@ namespace wasm::ModuleUtils {
 // name of the function (otherwise the original name is copied). If fileIndexMap
 // is specified, it is used to rename source map filename indices when copying
 // the function from one module to another one.
-Function*
-copyFunction(Function* func,
-             Module& out,
-             Name newName = Name(),
-             std::optional<std::vector<Index>> fileIndexMap = std::nullopt);
+Function* copyFunction(
+  Function* func,
+  Module& out,
+  Name newName = Name(),
+  std::optional<std::vector<Index>> fileIndexMap = std::nullopt,
+  std::optional<std::vector<Index>> symbolNameIndexMap = std::nullopt);
 
 // As above, but does not add the copy to the module.
 std::unique_ptr<Function> copyFunctionWithoutAdd(
   Function* func,
   Module& out,
   Name newName = Name(),
-  std::optional<std::vector<Index>> fileIndexMap = std::nullopt);
+  std::optional<std::vector<Index>> fileIndexMap = std::nullopt,
+  std::optional<std::vector<Index>> symbolNameIndexMap = std::nullopt);
 
 Global* copyGlobal(Global* global, Module& out);
 

src/parser/contexts.h

@@ -1398,6 +1398,7 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
     typeNames;
   const std::unordered_map<Index, Index>& implicitElemIndices;
 
+  std::unordered_map<std::string_view, Index> debugSymbolNameIndices;
   std::unordered_map<std::string_view, Index> debugFileIndices;
 
   // The index of the current module element.
@@ -1777,11 +1778,34 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
     }
     contents = contents.substr(lineSize + 1);
 
-    lexer = Lexer(contents);
+    auto colSize = contents.find(':');
+    auto rest = std::string_view();
+    if (colSize == contents.npos) {
+      colSize = contents.size();
+      if (colSize == 0) {
+        return;
+      }
+    } else {
+      rest = contents.substr(colSize + 1);
+    }
+    lexer = Lexer(contents.substr(0, colSize));
     auto col = lexer.takeU32();
-    if (!col || !lexer.empty()) {
+    if (!col) {
       return;
     }
+    contents = rest;
+
+    std::optional<BinaryLocation> symbolNameIndex;
+    if (!contents.empty()) {
+      auto symbolName = contents;
+      auto [it, inserted] = debugSymbolNameIndices.insert(
+        {symbolName, debugSymbolNameIndices.size()});
+      if (inserted) {
+        assert(wasm.debugInfoSymbolNames.size() == it->second);
+        wasm.debugInfoSymbolNames.push_back(std::string(symbolName));
+      }
+      symbolNameIndex = it->second;
+    }
 
     // TODO: If we ever parallelize the parse, access to
     // `wasm.debugInfoFileNames` will have to be protected by a lock.
@@ -1792,7 +1816,7 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
       wasm.debugInfoFileNames.push_back(std::string(file));
     }
     irBuilder.setDebugLocation(
-      Function::DebugLocation({it->second, *line, *col}));
+      Function::DebugLocation({it->second, *line, *col, symbolNameIndex}));
   }
 
   Result<> makeBlock(Index pos,

src/passes/Print.cpp

@@ -2516,7 +2516,15 @@ void PrintSExpression::printDebugLocation(
   } else {
     auto fileName = currModule->debugInfoFileNames[location->fileIndex];
     o << ";;@ " << fileName << ":" << location->lineNumber << ":"
-      << location->columnNumber << '\n';
+      << location->columnNumber;
+
+    if (location->symbolNameIndex.has_value()) {
+      auto symbolName =
+        currModule->debugInfoSymbolNames[*(location->symbolNameIndex)];
+      o << ":" << symbolName;
+    }
+
+    o << '\n';
   }
   doIndent(o, indent);
 }

src/wasm-binary.h

@@ -1674,6 +1674,7 @@ class WasmBinaryReader {
   // Debug information reading helpers
   void setDebugLocations(std::istream* sourceMap_) { sourceMap = sourceMap_; }
   std::unordered_map<std::string, Index> debugInfoFileIndices;
+  std::unordered_map<std::string, Index> debugInfoSymbolNameIndices;
   void readNextDebugLocation();
   void readSourceMapHeader();
 

src/wasm.h

@@ -2076,19 +2076,21 @@ class Function : public Importable {
   // Source maps debugging info: map expression nodes to their file, line, col.
   struct DebugLocation {
     BinaryLocation fileIndex, lineNumber, columnNumber;
+    std::optional<BinaryLocation> symbolNameIndex;
     bool operator==(const DebugLocation& other) const {
       return fileIndex == other.fileIndex && lineNumber == other.lineNumber &&
-             columnNumber == other.columnNumber;
+             columnNumber == other.columnNumber &&
+             symbolNameIndex == other.symbolNameIndex;
     }
     bool operator!=(const DebugLocation& other) const {
       return !(*this == other);
     }
     bool operator<(const DebugLocation& other) const {
-      return fileIndex != other.fileIndex
-               ? fileIndex < other.fileIndex
-               : lineNumber != other.lineNumber
-                   ? lineNumber < other.lineNumber
-                   : columnNumber < other.columnNumber;
+      return fileIndex != other.fileIndex     ? fileIndex < other.fileIndex
+             : lineNumber != other.lineNumber ? lineNumber < other.lineNumber
+             : columnNumber != other.columnNumber
+               ? columnNumber < other.columnNumber
+               : symbolNameIndex < other.symbolNameIndex;
     }
   };
   // One can explicitly set the debug location of an expression to
@@ -2300,6 +2302,7 @@ class Module {
 
   // Source maps debug info.
   std::vector<std::string> debugInfoFileNames;
+  std::vector<std::string> debugInfoSymbolNames;
 
   // `features` are the features allowed to be used in this module and should be
   // respected regardless of the value of`hasFeaturesSection`.