[wasm-split] Support --symbolmap for --multi-split (#7791)

Author: aheejin

CHANGELOG.md

@@ -16,11 +16,11 @@ Current Trunk
 -------------
 
  - `wasm-split`'s `--multi-split` mode now supports more options:
-   `--no-placeholders`, `--import-namespace`, `--emit-module-names`, and
-   `--emit-text`. Because `--no-placeholders` is false by default and until now
-   `--multi-split` didn't use placeholders at all, this is a breaking change. If
-   you want to continue to do multi-split without placeholders, you need to
-   explicitly specify `--no-placeholders`.
+   `--no-placeholders`, `--import-namespace`, `--emit-module-names`,
+   `--emit-text`, and `--symbolmap`. Because `--no-placeholders` is false by
+   default and until now `--multi-split` didn't use placeholders at all, this is
+   a breaking change. If you want to continue to do multi-split without
+   placeholders, you need to explicitly specify `--no-placeholders`.
  - Add a `--string-lifting` pass that raises imported string operations and
    constants into stringref in Binaryen IR (which can then be fully optimized,
    and typically lowered back down with `--string-lowering`).

src/tools/wasm-split/split-options.cpp

@@ -204,7 +204,7 @@ WasmSplitOptions::WasmSplitOptions()
          "",
          "Write a symbol map file for each of the output modules.",
          WasmSplitOption,
-         {Mode::Split},
+         {Mode::Split, Mode::MultiSplit},
          Options::Arguments::Zero,
          [&](Options* o, const std::string& argument) { symbolMap = true; })
     .add(

src/tools/wasm-split/wasm-split.cpp

@@ -431,14 +431,21 @@ void multiSplitModule(const WasmSplitOptions& options) {
     }
     config.secondaryFuncs = std::set<Name>(funcs.begin(), funcs.end());
     auto splitResults = ModuleSplitting::splitFunctions(wasm, config);
-    // TODO: symbolMap, placeholderMap
+    // TODO: placeholderMap
     auto moduleName =
       options.outPrefix + mod + (options.emitBinary ? ".wasm" : ".wast");
+    if (options.symbolMap) {
+      writeSymbolMap(*splitResults.secondary, moduleName + ".symbols");
+    }
     if (options.emitModuleNames) {
       splitResults.secondary->name = Path::getBaseName(moduleName);
     }
     writeModule(*splitResults.secondary, moduleName, options);
   }
+  if (options.symbolMap) {
+    writeSymbolMap(wasm, options.output + ".symbols");
+  }
+
   writeModule(wasm, options.output, options);
 }
 

test/lit/help/wasm-split.test

@@ -64,8 +64,8 @@
 ;; CHECK-NEXT:   --secondary-output,-o2               [split] Output file for the secondary
 ;; CHECK-NEXT:                                        module.
 ;; CHECK-NEXT:
-;; CHECK-NEXT:   --symbolmap                          [split] Write a symbol map file for each
-;; CHECK-NEXT:                                        of the output modules.
+;; CHECK-NEXT:   --symbolmap                          [split, multi-split] Write a symbol map
+;; CHECK-NEXT:                                        file for each of the output modules.
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --no-placeholders                    [split, multi-split] Do not import
 ;; CHECK-NEXT:                                        placeholder functions. Calls to secondary

test/lit/wasm-split/symbolmap-multi-split.wast

@@ -0,0 +1,88 @@
+;; RUN: wasm-split -all --multi-split %s --manifest %S/multi-split.wast.manifest --out-prefix=%t --symbolmap -o %t.wasm
+;; RUN: filecheck %s --check-prefix PRIMARY-MAP < %t.wasm.symbols
+;; RUN: filecheck %s --check-prefix MOD1-MAP < %t1.wasm.symbols
+;; RUN: filecheck %s --check-prefix MOD2-MAP < %t2.wasm.symbols
+;; RUN: filecheck %s --check-prefix MOD3-MAP < %t3.wasm.symbols
+
+;; PRIMARY-MAP: 0:placeholder_0
+;; PRIMARY-MAP: 1:placeholder_0_5
+;; PRIMARY-MAP: 2:placeholder_0_6
+;; PRIMARY-MAP: 3:trampoline_A
+;; PRIMARY-MAP: 4:B
+;; PRIMARY-MAP: 5:trampoline_B
+;; PRIMARY-MAP: 6:C
+
+;; MOD1-MAP: 0:B
+;; MOD1-MAP: 1:C
+;; MOD1-MAP: 2:A
+
+;; MOD2-MAP: 0:C
+;; MOD2-MAP: 1:trampoline_A
+;; MOD2-MAP: 2:B
+
+;; MOD3-MAP: 0:trampoline_A
+;; MOD3-MAP: 1:trampoline_B
+;; MOD3-MAP: 2:C
+
+(module
+ (type $ret-i32 (func (result i32)))
+ (type $ret-i64 (func (result i64)))
+ (type $ret-f32 (func (result f32)))
+
+ (func $A (type $ret-i32) (result i32)
+  (drop
+   (call_ref $ret-i32
+    (ref.func $A)
+   )
+  )
+  (drop
+   (call_ref $ret-i64
+    (ref.func $B)
+   )
+  )
+  (drop
+   (call_ref $ret-f32
+    (ref.func $C)
+   )
+  )
+  (i32.const 0)
+ )
+
+ (func $B (type $ret-i64) (result i64)
+  (drop
+   (call_ref $ret-i32
+    (ref.func $A)
+   )
+  )
+  (drop
+   (call_ref $ret-i64
+    (ref.func $B)
+   )
+  )
+  (drop
+   (call_ref $ret-f32
+    (ref.func $C)
+   )
+  )
+  (i64.const 0)
+ )
+
+ (func $C (type $ret-f32) (result f32)
+  (drop
+   (call_ref $ret-i32
+    (ref.func $A)
+   )
+  )
+  (drop
+   (call_ref $ret-i64
+    (ref.func $B)
+   )
+  )
+  (drop
+   (call_ref $ret-f32
+    (ref.func $C)
+   )
+  )
+  (f32.const 0)
+ )
+)