[wasm-split] Set import namespace only when given in multi-split

Currently, in the case of two-way split, we set `config.importNamespace`
only when `--import-namespace` option is given, and otherwise just use
the default namespace "primary". But in the case of multi split, we set
it regardless of whether the option is given, resulting in the ""
namespace when no option is given.

The default import namespace for multi-split was "" when the multi-split
function was first added (#6943), so I'm not sure whether this
difference was intentional. In case it wasn't, I think it makes sense to
be consistent between two-way split and multi-split. So this in effect
changes the import namespace in multi split tests from "" to `primary`.

This also factors out the part that moves `WasmSplitOptions` into
`Config` to a function.

Author: aheejin

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

@@ -231,7 +231,7 @@ WasmSplitOptions::WasmSplitOptions()
          "module into the secondary module. In instrument mode, refers to the "
          "namespace from which to import the secondary memory, if any.",
          WasmSplitOption,
-         {Mode::Split, Mode::Instrument, Mode::MultiSplit},
+         {Mode::Split, Mode::MultiSplit, Mode::Instrument},
          Options::Arguments::One,
          [&](Options* o, const std::string& argument) {
            importNamespace = argument;

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

@@ -222,6 +222,16 @@ void writePlaceholderMap(
   }
 }
 
+void setCommonSplitConfigs(ModuleSplitting::Config& config,
+                           const WasmSplitOptions& options) {
+  config.usePlaceholders = options.usePlaceholders;
+  config.minimizeNewExportNames = !options.passOptions.debugInfo;
+  if (options.importNamespace.size()) {
+    config.importNamespace = options.importNamespace;
+  }
+  // TODO Add more configs here
+}
+
 void splitModule(const WasmSplitOptions& options) {
   Module wasm;
   parseInput(wasm, options);
@@ -329,18 +339,14 @@ void splitModule(const WasmSplitOptions& options) {
 
   // Actually perform the splitting
   ModuleSplitting::Config config;
+  setCommonSplitConfigs(config, options);
   config.secondaryFuncs.push_back(std::move(splitFuncs));
-  if (options.importNamespace.size()) {
-    config.importNamespace = options.importNamespace;
-  }
   if (options.placeholderNamespace.size()) {
     config.placeholderNamespace = options.placeholderNamespace;
   }
   if (options.exportPrefix.size()) {
     config.newExportPrefix = options.exportPrefix;
   }
-  config.usePlaceholders = options.usePlaceholders;
-  config.minimizeNewExportNames = !options.passOptions.debugInfo;
   config.jspi = options.jspi;
   auto splitResults = ModuleSplitting::splitFunctions(wasm, config);
   auto& secondary = *splitResults.secondaries.begin();
@@ -398,6 +404,8 @@ void multiSplitModule(const WasmSplitOptions& options) {
   std::unordered_map<Name, Name> funcModules;
 
   ModuleSplitting::Config config;
+  setCommonSplitConfigs(config, options);
+
   std::string line;
   bool newSection = true;
   std::vector<Name> moduleNames;
@@ -436,9 +444,6 @@ void multiSplitModule(const WasmSplitOptions& options) {
     }
   }
 
-  config.usePlaceholders = options.usePlaceholders;
-  config.importNamespace = options.importNamespace;
-  config.minimizeNewExportNames = !options.passOptions.debugInfo;
   if (options.emitModuleNames && !wasm.name) {
     wasm.name = Path::getBaseName(options.output);
   }

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

@@ -34,11 +34,11 @@
 
  ;; MOD1:      (type $2 (func (result i32)))
 
- ;; MOD1:      (import "" "table" (table $timport$0 3 funcref))
+ ;; MOD1:      (import "primary" "table" (table $timport$0 3 funcref))
 
- ;; MOD1:      (import "" "trampoline_B" (func $trampoline_B (result i64)))
+ ;; MOD1:      (import "primary" "trampoline_B" (func $trampoline_B (result i64)))
 
- ;; MOD1:      (import "" "trampoline_C" (func $trampoline_C (result f32)))
+ ;; MOD1:      (import "primary" "trampoline_C" (func $trampoline_C (result f32)))
 
  ;; MOD1:      (elem $0 (i32.const 2) $A)
 
@@ -117,11 +117,11 @@
 
  ;; MOD2:      (type $2 (func (result i64)))
 
- ;; MOD2:      (import "" "table" (table $timport$0 3 funcref))
+ ;; MOD2:      (import "primary" "table" (table $timport$0 3 funcref))
 
- ;; MOD2:      (import "" "trampoline_A" (func $trampoline_A (result i32)))
+ ;; MOD2:      (import "primary" "trampoline_A" (func $trampoline_A (result i32)))
 
- ;; MOD2:      (import "" "trampoline_C" (func $trampoline_C (result f32)))
+ ;; MOD2:      (import "primary" "trampoline_C" (func $trampoline_C (result f32)))
 
  ;; MOD2:      (elem $0 (i32.const 0) $B)
 
@@ -200,11 +200,11 @@
 
  ;; MOD3:      (type $2 (func (result f32)))
 
- ;; MOD3:      (import "" "table" (table $timport$0 3 funcref))
+ ;; MOD3:      (import "primary" "table" (table $timport$0 3 funcref))
 
- ;; MOD3:      (import "" "trampoline_A" (func $trampoline_A (result i32)))
+ ;; MOD3:      (import "primary" "trampoline_A" (func $trampoline_A (result i32)))
 
- ;; MOD3:      (import "" "trampoline_B" (func $trampoline_B (result i64)))
+ ;; MOD3:      (import "primary" "trampoline_B" (func $trampoline_B (result i64)))
 
  ;; MOD3:      (elem $0 (i32.const 1) $C)