Add sourcemap support to wasm-metadce and wasm-merge

src/ir/module-utils.cpp

@@ -15,6 +15,7 @@
  */
 
 #include "module-utils.h"
+#include "ir/debug.h"
 #include "ir/intrinsics.h"
 #include "ir/manipulation.h"
 #include "ir/properties.h"
@@ -23,17 +24,46 @@
 
 namespace wasm::ModuleUtils {
 
+static void updateLocationSet(std::set<Function::DebugLocation>& locations,
+                              std::vector<Index>* indexMap) {
+  std::set<Function::DebugLocation> updatedLocations;
+
+  for (auto iter : locations) {
+    iter.fileIndex = (*indexMap)[iter.fileIndex];
+    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).
-Function* copyFunction(Function* func, Module& out, Name newName) {
+// name of the function (otherwise the original name is copied). If indexMap 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::vector<Index>* indexMap) {
   auto ret = std::make_unique<Function>();
   ret->name = newName.is() ? newName : func->name;
   ret->type = func->type;
   ret->vars = func->vars;
   ret->localNames = func->localNames;
   ret->localIndices = func->localIndices;
-  ret->debugLocations = func->debugLocations;
   ret->body = ExpressionManipulator::copy(func->body, out);
+  if (ret->body) {
+    debug::copyDebugInfo(func->body, ret->body, func, ret.get());
+  }
+  ret->prologLocation = func->prologLocation;
+  ret->epilogLocation = func->epilogLocation;
+  // Update file indices if needed
+  if (indexMap) {
+    for (auto& iter : ret->debugLocations) {
+      iter.second.fileIndex = (*indexMap)[iter.second.fileIndex];
+    }
+    updateLocationSet(ret->prologLocation, indexMap);
+    updateLocationSet(ret->epilogLocation, indexMap);
+  }
   ret->module = func->module;
   ret->base = func->base;
   ret->noFullInline = func->noFullInline;
@@ -135,9 +165,13 @@ DataSegment* copyDataSegment(const DataSegment* segment, Module& out) {
 
 // Copies named toplevel module items (things of kind ModuleItemKind). See
 // copyModule() for something that also copies exports, the start function, etc.
-void copyModuleItems(const Module& in, Module& out) {
+// The indexMap is used to update source map information when copying functions
+// from one module to another.
+void copyModuleItems(const Module& in,
+                     Module& out,
+                     std::vector<Index>* indexMap) {
   for (auto& curr : in.functions) {
-    copyFunction(curr.get(), out);
+    copyFunction(curr.get(), out, Name(), indexMap);
   }
   for (auto& curr : in.globals) {
     copyGlobal(curr.get(), out);

src/ir/module-utils.h

@@ -24,8 +24,13 @@
 namespace wasm::ModuleUtils {
 
 // 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).
-Function* copyFunction(Function* func, Module& out, Name newName = Name());
+// name of the function (otherwise the original name is copied). If indexMap 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::vector<Index>* indexMap = 0);
 
 Global* copyGlobal(Global* global, Module& out);
 
@@ -41,7 +46,11 @@ DataSegment* copyDataSegment(const DataSegment* segment, Module& out);
 
 // Copies named toplevel module items (things of kind ModuleItemKind). See
 // copyModule() for something that also copies exports, the start function, etc.
-void copyModuleItems(const Module& in, Module& out);
+// The indexMap is used to update source map information when copying functions
+// from one module to another.
+void copyModuleItems(const Module& in,
+                     Module& out,
+                     std::vector<Index>* indexMap = 0);
 
 void copyModule(const Module& in, Module& out);
 

src/tools/wasm-merge.cpp

@@ -324,9 +324,26 @@ void renameInputItems(Module& input) {
 }
 
 void copyModuleContents(Module& input, Name inputName) {
-  // First, copy the regular module items (functions, globals) etc. which we
+  // Source map filename index mapping
+  std::vector<Index> indexMap;
+  std::unordered_map<std::string, Index> debugInfoFileIndices;
+  for (Index i = 0; i < merged.debugInfoFileNames.size(); i++) {
+    debugInfoFileIndices[merged.debugInfoFileNames[i]] = i;
+  }
+  for (Index i = 0; i < input.debugInfoFileNames.size(); i++) {
+    std::string file = input.debugInfoFileNames[i];
+    auto iter = debugInfoFileIndices.find(file);
+    if (iter == debugInfoFileIndices.end()) {
+      Index index = merged.debugInfoFileNames.size();
+      merged.debugInfoFileNames.push_back(file);
+      debugInfoFileIndices[file] = index;
+    }
+    indexMap.push_back(debugInfoFileIndices[file]);
+  }
+
+  // Copy the regular module items (functions, globals) etc. which we
   // have proper names for, and can just copy.
-  ModuleUtils::copyModuleItems(input, merged);
+  ModuleUtils::copyModuleItems(input, merged, &indexMap);
 
   // We must handle exports in a special way, as we need to note their origin
   // module as we copy them in (also, they are not importable or exportable, so
@@ -452,6 +469,9 @@ int main(int argc, const char* argv[]) {
   std::vector<std::string> inputFileNames;
   bool emitBinary = true;
   bool debugInfo = false;
+  std::map<size_t, std::string> inputSourceMapFilenames;
+  std::string outputSourceMapFilename;
+  std::string outputSourceMapUrl;
 
   const std::string WasmMergeOption = "wasm-merge options";
 
@@ -464,7 +484,11 @@ For example,
 
 will read foo.wasm and bar.wasm, with names 'foo' and 'bar' respectively, so if the second imports from 'foo', we will see that as an import from the first module after the merge. The merged output will be written to merged.wasm.
 
-Note that filenames and modules names are interleaved (which is hopefully less confusing).)");
+Note that filenames and modules names are interleaved (which is hopefully less confusing).
+
+Input source maps can be specified by adding an --ism option right after the module name:
+
+  wasm-merge foo.wasm foo --ism foo.wasm.map ...)");
 
   options
     .add("--output",
@@ -485,6 +509,37 @@ Note that filenames and modules names are interleaved (which is hopefully less c
                         inputFileNames.push_back(argument);
                       }
                     })
+    .add("--input-source-map",
+         "-ism",
+         "Consume source maps from the specified files",
+         WasmMergeOption,
+         Options::Arguments::N,
+         [&](Options* o, const std::string& argument) {
+           size_t pos = inputFiles.size();
+           if (pos == 0 || pos != inputFileNames.size() ||
+               inputSourceMapFilenames.count(pos - 1)) {
+             std::cerr << "Option '-ism " << argument
+                       << "' should be right after the module name\n";
+             exit(EXIT_FAILURE);
+           }
+           inputSourceMapFilenames.insert({pos - 1, argument});
+         })
+    .add("--output-source-map",
+         "-osm",
+         "Emit source map to the specified file",
+         WasmMergeOption,
+         Options::Arguments::One,
+         [&outputSourceMapFilename](Options* o, const std::string& argument) {
+           outputSourceMapFilename = argument;
+         })
+    .add("--output-source-map-url",
+         "-osu",
+         "Emit specified string as source map URL",
+         WasmMergeOption,
+         Options::Arguments::One,
+         [&outputSourceMapUrl](Options* o, const std::string& argument) {
+           outputSourceMapUrl = argument;
+         })
     .add("--rename-export-conflicts",
          "-rec",
          "Rename exports to avoid conflicts (rather than error)",
@@ -529,6 +584,9 @@ Note that filenames and modules names are interleaved (which is hopefully less c
   for (Index i = 0; i < inputFiles.size(); i++) {
     auto inputFile = inputFiles[i];
     auto inputFileName = inputFileNames[i];
+    auto iter = inputSourceMapFilenames.find(i);
+    auto inputSourceMapFilename =
+      (iter == inputSourceMapFilenames.end()) ? "" : iter->second;
 
     if (options.debug) {
       std::cerr << "reading input '" << inputFile << "' as '" << inputFileName
@@ -550,7 +608,7 @@ Note that filenames and modules names are interleaved (which is hopefully less c
 
     ModuleReader reader;
     try {
-      reader.read(inputFile, *currModule);
+      reader.read(inputFile, *currModule, inputSourceMapFilename);
     } catch (ParseException& p) {
       p.dump(std::cerr);
       Fatal() << "error in parsing wasm input: " << inputFile;
@@ -606,6 +664,10 @@ Note that filenames and modules names are interleaved (which is hopefully less c
     ModuleWriter writer;
     writer.setBinary(emitBinary);
     writer.setDebugInfo(debugInfo);
+    if (outputSourceMapFilename.size()) {
+      writer.setSourceMapFilename(outputSourceMapFilename);
+      writer.setSourceMapUrl(outputSourceMapUrl);
+    }
     writer.write(merged, options.extra["output"]);
   }
 }

src/tools/wasm-metadce.cpp

@@ -365,6 +365,9 @@ int main(int argc, const char* argv[]) {
   bool debugInfo = false;
   std::string graphFile;
   bool dump = false;
+  std::string inputSourceMapFilename;
+  std::string outputSourceMapFilename;
+  std::string outputSourceMapUrl;
 
   const std::string WasmMetaDCEOption = "wasm-opt options";
 
@@ -423,6 +426,30 @@ int main(int argc, const char* argv[]) {
            o->extra["output"] = argument;
            Colors::setEnabled(false);
          })
+    .add("--input-source-map",
+         "-ism",
+         "Consume source map from the specified file",
+         WasmMetaDCEOption,
+         Options::Arguments::One,
+         [&inputSourceMapFilename](Options* o, const std::string& argument) {
+           inputSourceMapFilename = argument;
+         })
+    .add("--output-source-map",
+         "-osm",
+         "Emit source map to the specified file",
+         WasmMetaDCEOption,
+         Options::Arguments::One,
+         [&outputSourceMapFilename](Options* o, const std::string& argument) {
+           outputSourceMapFilename = argument;
+         })
+    .add("--output-source-map-url",
+         "-osu",
+         "Emit specified string as source map URL",
+         WasmMetaDCEOption,
+         Options::Arguments::One,
+         [&outputSourceMapUrl](Options* o, const std::string& argument) {
+           outputSourceMapUrl = argument;
+         })
     .add("--emit-text",
          "-S",
          "Emit text instead of binary for the output file",
@@ -470,7 +497,7 @@ int main(int argc, const char* argv[]) {
     ModuleReader reader;
     reader.setDWARF(debugInfo);
     try {
-      reader.read(options.extra["infile"], wasm);
+      reader.read(options.extra["infile"], wasm, input);
     } catch (ParseException& p) {
       p.dump(std::cerr);
       Fatal() << "error in parsing wasm input";
@@ -578,6 +605,10 @@ int main(int argc, const char* argv[]) {
     ModuleWriter writer;
     writer.setBinary(emitBinary);
     writer.setDebugInfo(debugInfo);
+    if (outputSourceMapFilename.size()) {
+      writer.setSourceMapFilename(outputSourceMapFilename);
+      writer.setSourceMapUrl(outputSourceMapUrl);
+    }
     writer.write(wasm, options.extra["output"]);
   }
 

test/lit/help/wasm-merge.test

@@ -14,6 +14,11 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT: Note that filenames and modules names are interleaved (which is hopefully less
 ;; CHECK-NEXT: confusing).
+;; CHECK-NEXT:  
+;; CHECK-NEXT: Input source maps can be specified by adding an --ism option right after the 
+;; CHECK-NEXT: module name: 
+;; CHECK-NEXT:  
+;; CHECK-NEXT:   wasm-merge foo.wasm foo --ism foo.wasm.map ... 
 ;; CHECK-NEXT: ================================================================================
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:
@@ -22,6 +27,13 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --output,-o                          Output file (stdout if not specified)
 ;; CHECK-NEXT:
+;; CHECK-NEXT:   --input-source-map,-ism              Consume source maps from the specified
+;; CHECK-NEXT:                                        file
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --output-source-map,-osm             Emit source map to the specified file
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --output-source-map-url,-osu         Emit specified string as source map URL
+;; CHECK-NEXT:
 ;; CHECK-NEXT:   --rename-export-conflicts,-rec       Rename exports to avoid conflicts (rather
 ;; CHECK-NEXT:                                        than error)
 ;; CHECK-NEXT:

test/lit/help/wasm-metadce.test

@@ -53,6 +53,13 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --output,-o                          Output file (stdout if not specified)
 ;; CHECK-NEXT:
+;; CHECK-NEXT:   --input-source-map,-ism              Consume source map from the specified
+;; CHECK-NEXT:                                        file
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --output-source-map,-osm             Emit source map to the specified file
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --output-source-map-url,-osu         Emit specified string as source map URL
+;; CHECK-NEXT:
 ;; CHECK-NEXT:   --emit-text,-S                       Emit text instead of binary for the
 ;; CHECK-NEXT:                                        output file
 ;; CHECK-NEXT:

test/lit/merge/sourcemap.wat

@@ -0,0 +1,33 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
+
+;; RUN: wasm-merge %s first %s.second second -S -o - | filecheck %s
+
+;; Test that sourcemap information is preserved
+
+(module
+  ;;@ a:1:1
+  (func (export "f")
+     ;;@ a:2:1
+     (nop)
+     ;;@ a:3:1
+  )
+)
+;; CHECK:      (type $0 (func))
+
+;; CHECK:      (export "f" (func $0))
+
+;; CHECK:      (export "g" (func $0_1))
+
+;; CHECK:      ;;@ a:1:1
+;; CHECK-NEXT: (func $0
+;; CHECK-NEXT:  ;;@ a:2:1
+;; CHECK-NEXT:  (nop)
+;; CHECK-NEXT:  ;;@ a:3:1
+;; CHECK-NEXT: )
+
+;; CHECK:      ;;@ b:1:2
+;; CHECK-NEXT: (func $0_1
+;; CHECK-NEXT:  ;;@ b:2:2
+;; CHECK-NEXT:  (nop)
+;; CHECK-NEXT:  ;;@ b:3:2
+;; CHECK-NEXT: )

test/lit/merge/sourcemap.wat.second

@@ -0,0 +1,8 @@
+(module
+  ;;@ b:1:2
+  (func (export "g")
+     ;;@ b:2:2
+     (nop)
+     ;;@ b:3:2
+  )
+)