Allow different arguments for multiple instances of a pass (#6687)

Each pass instance can now store an argument for it, which can be different.

This may be a breaking change for the corner case of running a pass multiple
times and setting the pass's argument multiple times as well (before, the last
pass argument affected them all; now, it affects the last instance only). This
only affects arguments with the name of a pass; others remain global, as
before (and multiple passes can read them, in fact). See the CHANGELOG for
details.

Fixes #6646 

31 files changed, 242 insertions, 89 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 56199c983..5f7a37581 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -41,6 +41,12 @@ v118
  - The build-time option to use legacy WasmGC opcodes is removed.
  - The strings in `string.const` instructions must now be valid WTF-8.
  - The `TraverseCalls` flag for `ExpressionRunner` is removed.
+ - Passes can now receive individual pass arguments, that is --foo=A --foo=B for
+   a pass foo will run the pass twice (which was possible before) and will now
+   run it first with argument A and second with B. --pass-arg=foo@BAR will now
+   apply to the most recent --foo pass on the commandline, if foo is a pass
+   (while global pass arguments - that are not the name of a pass - remain, as
+   before, global for all passes).
 
 v117
 ----
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index be80206f5..298a50233 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -5453,7 +5453,10 @@ void BinaryenModuleRunPasses(BinaryenModuleRef module,
   PassRunner passRunner((Module*)module);
   passRunner.options = globalPassOptions;
   for (BinaryenIndex i = 0; i < numPasses; i++) {
-    passRunner.add(passes[i]);
+    passRunner.add(passes[i],
+                   globalPassOptions.arguments.count(passes[i]) > 0
+                     ? globalPassOptions.arguments[passes[i]]
+                     : std::optional<std::string>());
   }
   passRunner.run();
 }
@@ -5704,7 +5707,10 @@ void BinaryenFunctionRunPasses(BinaryenFunctionRef func,
   PassRunner passRunner((Module*)module);
   passRunner.options = globalPassOptions;
   for (BinaryenIndex i = 0; i < numPasses; i++) {
-    passRunner.add(passes[i]);
+    passRunner.add(passes[i],
+                   globalPassOptions.arguments.count(passes[i]) > 0
+                     ? globalPassOptions.arguments[passes[i]]
+                     : std::optional<std::string>());
   }
   passRunner.runOnFunction((Function*)func);
 }
diff --git a/src/pass.h b/src/pass.h
index ab060309b..9352319ad 100644
--- a/src/pass.h
+++ b/src/pass.h
@@ -39,12 +39,14 @@ struct PassRegistry {
   using Creator = std::function<Pass*()>;
 
   void registerPass(const char* name, const char* description, Creator create);
+
   // Register a pass that's used for internal testing. These passes do not show
   // up in --help.
   void
   registerTestPass(const char* name, const char* description, Creator create);
   std::unique_ptr<Pass> createPass(std::string name);
   std::vector<std::string> getRegisteredNames();
+  bool containsPass(const std::string& name);
   std::string getPassDescription(std::string name);
   bool isPassHidden(std::string name);
 
@@ -103,6 +105,8 @@ class EffectAnalyzer;
 using FuncEffectsMap = std::unordered_map<Name, EffectAnalyzer>;
 
 struct PassOptions {
+  friend Pass;
+
   // Run passes in debug mode, doing extra validation and timing checks.
   bool debug = false;
   // Whether to run the validator to check for errors.
@@ -269,6 +273,7 @@ struct PassOptions {
     return PassOptions(); // defaults are to not optimize
   }
 
+private:
   bool hasArgument(std::string key) { return arguments.count(key) > 0; }
 
   std::string getArgument(std::string key, std::string errorTextIfMissing) {
@@ -322,9 +327,8 @@ struct PassRunner {
   }
 
   // Add a pass using its name.
-  void add(std::string passName) {
-    doAdd(PassRegistry::get()->createPass(passName));
-  }
+  void add(std::string passName,
+           std::optional<std::string> passArg = std::nullopt);
 
   // Add a pass given an instance.
   void add(std::unique_ptr<Pass> pass) { doAdd(std::move(pass)); }
@@ -486,6 +490,8 @@ public:
   // to imports must override this to return true.
   virtual bool addsEffects() { return false; }
 
+  void setPassArg(const std::string& value) { passArg = value; }
+
   std::string name;
 
   PassRunner* getPassRunner() { return runner; }
@@ -497,6 +503,19 @@ public:
   PassOptions& getPassOptions() { return runner->options; }
 
 protected:
+  bool hasArgument(const std::string& key);
+  std::string getArgument(const std::string& key,
+                          const std::string& errorTextIfMissing);
+  std::string getArgumentOrDefault(const std::string& key,
+                                   const std::string& defaultValue);
+
+  // The main argument of the pass, which can be specified individually for
+  // every pass . getArgument() and friends will refer to this value if queried
+  // for a key that matches the pass name. All other arguments are taken from
+  // the runner / passOptions and therefore are global for all instances of a
+  // pass.
+  std::optional<std::string> passArg;
+
   Pass() = default;
   Pass(const Pass&) = default;
   Pass(Pass&&) = default;
diff --git a/src/passes/Asyncify.cpp b/src/passes/Asyncify.cpp
index 1ba764387..7ac9cf489 100644
--- a/src/passes/Asyncify.cpp
+++ b/src/passes/Asyncify.cpp
@@ -1608,54 +1608,49 @@ struct Asyncify : public Pass {
   bool addsEffects() override { return true; }
 
   void run(Module* module) override {
-    auto& options = getPassOptions();
-    bool optimize = options.optimizeLevel > 0;
+    bool optimize = getPassOptions().optimizeLevel > 0;
 
     // Find which things can change the state.
     auto stateChangingImports = String::trim(read_possible_response_file(
-      options.getArgumentOrDefault("asyncify-imports", "")));
-    auto ignoreImports =
-      options.getArgumentOrDefault("asyncify-ignore-imports", "");
+      getArgumentOrDefault("asyncify-imports", "")));
+    auto ignoreImports = getArgumentOrDefault("asyncify-ignore-imports", "");
     bool allImportsCanChangeState =
       stateChangingImports == "" && ignoreImports == "";
     String::Split listedImports(stateChangingImports,
                                 String::Split::NewLineOr(","));
     // canIndirectChangeState is the default.  asyncify-ignore-indirect sets it
     // to false.
-    auto canIndirectChangeState =
-      !options.hasArgument("asyncify-ignore-indirect");
+    auto canIndirectChangeState = !hasArgument("asyncify-ignore-indirect");
     std::string removeListInput =
-      options.getArgumentOrDefault("asyncify-removelist", "");
+      getArgumentOrDefault("asyncify-removelist", "");
     if (removeListInput.empty()) {
       // Support old name for now to avoid immediate breakage TODO remove
-      removeListInput = options.getArgumentOrDefault("asyncify-blacklist", "");
+      removeListInput = getArgumentOrDefault("asyncify-blacklist", "");
     }
     String::Split removeList(
       String::trim(read_possible_response_file(removeListInput)),
       String::Split::NewLineOr(","));
-    String::Split addList(
-      String::trim(read_possible_response_file(
-        options.getArgumentOrDefault("asyncify-addlist", ""))),
-      String::Split::NewLineOr(","));
-    std::string onlyListInput =
-      options.getArgumentOrDefault("asyncify-onlylist", "");
+    String::Split addList(String::trim(read_possible_response_file(
+                            getArgumentOrDefault("asyncify-addlist", ""))),
+                          String::Split::NewLineOr(","));
+    std::string onlyListInput = getArgumentOrDefault("asyncify-onlylist", "");
     if (onlyListInput.empty()) {
       // Support old name for now to avoid immediate breakage TODO remove
-      onlyListInput = options.getArgumentOrDefault("asyncify-whitelist", "");
+      onlyListInput = getArgumentOrDefault("asyncify-whitelist", "");
     }
     String::Split onlyList(
       String::trim(read_possible_response_file(onlyListInput)),
       String::Split::NewLineOr(","));
-    auto asserts = options.hasArgument("asyncify-asserts");
-    auto verbose = options.hasArgument("asyncify-verbose");
-    auto relocatable = options.hasArgument("asyncify-relocatable");
-    auto secondaryMemory = options.hasArgument("asyncify-in-secondary-memory");
-    auto propagateAddList = options.hasArgument("asyncify-propagate-addlist");
+    auto asserts = hasArgument("asyncify-asserts");
+    auto verbose = hasArgument("asyncify-verbose");
+    auto relocatable = hasArgument("asyncify-relocatable");
+    auto secondaryMemory = hasArgument("asyncify-in-secondary-memory");
+    auto propagateAddList = hasArgument("asyncify-propagate-addlist");
 
     // Ensure there is a memory, as we need it.
     if (secondaryMemory) {
       auto secondaryMemorySizeString =
-        options.getArgumentOrDefault("asyncify-secondary-memory-size", "1");
+        getArgumentOrDefault("asyncify-secondary-memory-size", "1");
       Address secondaryMemorySize = std::stoi(secondaryMemorySizeString);
       asyncifyMemory = createSecondaryMemory(module, secondaryMemorySize);
     } else {
diff --git a/src/passes/Directize.cpp b/src/passes/Directize.cpp
index 66b42d386..6cb4e46d8 100644
--- a/src/passes/Directize.cpp
+++ b/src/passes/Directize.cpp
@@ -203,7 +203,7 @@ struct Directize : public Pass {
 
     // TODO: consider a per-table option here
     auto initialContentsImmutable =
-      getPassOptions().hasArgument("directize-initial-contents-immutable");
+      hasArgument("directize-initial-contents-immutable");
 
     // Set up the initial info.
     TableInfoMap tables;
diff --git a/src/passes/ExtractFunction.cpp b/src/passes/ExtractFunction.cpp
index 440468ede..df53afbf2 100644
--- a/src/passes/ExtractFunction.cpp
+++ b/src/passes/ExtractFunction.cpp
@@ -62,7 +62,7 @@ struct ExtractFunction : public Pass {
   bool addsEffects() override { return true; }
 
   void run(Module* module) override {
-    Name name = getPassOptions().getArgument(
+    Name name = getArgument(
       "extract-function",
       "ExtractFunction usage:  wasm-opt --extract-function=FUNCTION_NAME");
     extract(getPassRunner(), module, name);
@@ -74,10 +74,9 @@ struct ExtractFunctionIndex : public Pass {
   bool addsEffects() override { return true; }
 
   void run(Module* module) override {
-    std::string index =
-      getPassOptions().getArgument("extract-function-index",
-                                   "ExtractFunctionIndex usage: wasm-opt "
-                                   "--extract-function-index=FUNCTION_INDEX");
+    std::string index = getArgument("extract-function-index",
+                                    "ExtractFunctionIndex usage: wasm-opt "
+                                    "--extract-function-index=FUNCTION_INDEX");
     for (char c : index) {
       if (!std::isdigit(c)) {
         Fatal() << "Expected numeric function index";
diff --git a/src/passes/FuncCastEmulation.cpp b/src/passes/FuncCastEmulation.cpp
index 23eb98a8c..972cf719c 100644
--- a/src/passes/FuncCastEmulation.cpp
+++ b/src/passes/FuncCastEmulation.cpp
@@ -157,8 +157,7 @@ struct FuncCastEmulation : public Pass {
   bool addsEffects() override { return true; }
 
   void run(Module* module) override {
-    Index numParams = std::stoul(
-      getPassOptions().getArgumentOrDefault("max-func-params", "16"));
+    Index numParams = std::stoul(getArgumentOrDefault("max-func-params", "16"));
     // we just need the one ABI function type for all indirect calls
     HeapType ABIType(
       Signature(Type(std::vector<Type>(numParams, Type::i64)), Type::i64));
diff --git a/src/passes/JSPI.cpp b/src/passes/JSPI.cpp
index 1adf0de4c..d5fed1faf 100644
--- a/src/passes/JSPI.cpp
+++ b/src/passes/JSPI.cpp
@@ -83,18 +83,17 @@ struct JSPI : public Pass {
   void run(Module* module) override {
     Builder builder(*module);
 
-    auto& options = getPassOptions();
     // Find which imports can suspend.
-    auto stateChangingImports = String::trim(read_possible_response_file(
-      options.getArgumentOrDefault("jspi-imports", "")));
+    auto stateChangingImports = String::trim(
+      read_possible_response_file(getArgumentOrDefault("jspi-imports", "")));
     String::Split listedImports(stateChangingImports, ",");
 
     // Find which exports should create a promise.
-    auto stateChangingExports = String::trim(read_possible_response_file(
-      options.getArgumentOrDefault("jspi-exports", "")));
+    auto stateChangingExports = String::trim(
+      read_possible_response_file(getArgumentOrDefault("jspi-exports", "")));
     String::Split listedExports(stateChangingExports, ",");
 
-    bool wasmSplit = options.hasArgument("jspi-split-module");
+    bool wasmSplit = hasArgument("jspi-split-module");
     if (wasmSplit) {
       // Make an import for the load secondary module function so a JSPI wrapper
       // version will be created.
diff --git a/src/passes/LegalizeJSInterface.cpp b/src/passes/LegalizeJSInterface.cpp
index a0b526a81..bfc7e192b 100644
--- a/src/passes/LegalizeJSInterface.cpp
+++ b/src/passes/LegalizeJSInterface.cpp
@@ -64,9 +64,8 @@ struct LegalizeJSInterface : public Pass {
     setTempRet0 = nullptr;
     getTempRet0 = nullptr;
     auto exportOriginals =
-      getPassOptions().hasArgument("legalize-js-interface-export-originals");
-    exportedHelpers =
-      getPassOptions().hasArgument("legalize-js-interface-exported-helpers");
+      hasArgument("legalize-js-interface-export-originals");
+    exportedHelpers = hasArgument("legalize-js-interface-exported-helpers");
     // for each illegal export, we must export a legalized stub instead
     std::vector<std::unique_ptr<Export>> newExports;
     for (auto& ex : module->exports) {
diff --git a/src/passes/LogExecution.cpp b/src/passes/LogExecution.cpp
index f1d48012f..aa7948963 100644
--- a/src/passes/LogExecution.cpp
+++ b/src/passes/LogExecution.cpp
@@ -46,8 +46,7 @@ struct LogExecution : public WalkerPass<PostWalker<LogExecution>> {
   bool addsEffects() override { return true; }
 
   void run(Module* module) override {
-    auto& options = getPassOptions();
-    loggerModule = options.getArgumentOrDefault("log-execution", "");
+    loggerModule = getArgumentOrDefault("log-execution", "");
     super::run(module);
   }
 
diff --git a/src/passes/NoInline.cpp b/src/passes/NoInline.cpp
index 59e4f7e2c..34f693e29 100644
--- a/src/passes/NoInline.cpp
+++ b/src/passes/NoInline.cpp
@@ -48,8 +48,8 @@ struct NoInline : public Pass {
   NoInline(NoInlineMode mode) : mode(mode) {}
 
   void run(Module* module) override {
-    std::string pattern = getPassOptions().getArgument(
-      name, "Usage usage:  wasm-opt --" + name + "=WILDCARD");
+    std::string pattern =
+      getArgument(name, "Usage usage:  wasm-opt --" + name + "=WILDCARD");
 
     for (auto& func : module->functions) {
       if (!String::wildcardMatch(pattern, func->name.toString())) {
diff --git a/src/passes/PostEmscripten.cpp b/src/passes/PostEmscripten.cpp
index 7ade801cc..0e2c268de 100644
--- a/src/passes/PostEmscripten.cpp
+++ b/src/passes/PostEmscripten.cpp
@@ -214,8 +214,7 @@ struct PostEmscripten : public Pass {
     std::vector<Address> segmentOffsets; // segment index => address offset
     calcSegmentOffsets(module, segmentOffsets);
 
-    auto& options = getPassOptions();
-    auto sideModule = options.hasArgument("post-emscripten-side-module");
+    auto sideModule = hasArgument("post-emscripten-side-module");
     if (!sideModule) {
       removeData(module, segmentOffsets, "__start_em_asm", "__stop_em_asm");
       removeData(module, segmentOffsets, "__start_em_js", "__stop_em_js");
@@ -235,8 +234,7 @@ struct PostEmscripten : public Pass {
   }
 
   void removeEmJsExports(Module& module) {
-    auto& options = getPassOptions();
-    auto sideModule = options.hasArgument("post-emscripten-side-module");
+    auto sideModule = hasArgument("post-emscripten-side-module");
     EmJsWalker walker(sideModule);
     walker.walkModule(&module);
     for (const Export& exp : walker.toRemove) {
diff --git a/src/passes/PrintFunctionMap.cpp b/src/passes/PrintFunctionMap.cpp
index 08f5a359b..4fe266ec0 100644
--- a/src/passes/PrintFunctionMap.cpp
+++ b/src/passes/PrintFunctionMap.cpp
@@ -37,7 +37,7 @@ struct PrintFunctionMap : public Pass {
   void run(Module* module) override {
     // If an argument is provided, write to that file; otherwise write to
     // stdout.
-    auto outFile = getPassOptions().getArgumentOrDefault("symbolmap", "");
+    auto outFile = getArgumentOrDefault("symbolmap", "");
     Output output(outFile, Flags::Text);
     auto& o = output.getStream();
     Index i = 0;
diff --git a/src/passes/SeparateDataSegments.cpp b/src/passes/SeparateDataSegments.cpp
index 3e48d14bc..bd684dbe8 100644
--- a/src/passes/SeparateDataSegments.cpp
+++ b/src/passes/SeparateDataSegments.cpp
@@ -33,14 +33,14 @@ struct SeparateDataSegments : public Pass {
 
   void run(Module* module) override {
     std::string outfileName =
-      getPassOptions().getArgument("separate-data-segments",
-                                   "SeparateDataSegments usage: wasm-opt "
-                                   "--separate-data-segments@FILENAME");
+      getArgument("separate-data-segments",
+                  "SeparateDataSegments usage: wasm-opt "
+                  "--separate-data-segments@FILENAME");
     Output outfile(outfileName, Flags::Binary);
-    std::string baseStr = getPassOptions().getArgument(
-      "separate-data-segments-global-base",
-      "SeparateDataSegments usage: wasm-opt "
-      "--pass-arg=separate-data-segments-global-base@NUMBER");
+    std::string baseStr =
+      getArgument("separate-data-segments-global-base",
+                  "SeparateDataSegments usage: wasm-opt "
+                  "--pass-arg=separate-data-segments-global-base@NUMBER");
     Address base = std::stoi(baseStr);
     size_t lastEnd = 0;
     for (auto& seg : module->dataSegments) {
diff --git a/src/passes/SetGlobals.cpp b/src/passes/SetGlobals.cpp
index 5e24184fa..4c0718e84 100644
--- a/src/passes/SetGlobals.cpp
+++ b/src/passes/SetGlobals.cpp
@@ -29,9 +29,9 @@ struct SetGlobals : public Pass {
   bool requiresNonNullableLocalFixups() override { return false; }
 
   void run(Module* module) override {
-    Name input = getPassRunner()->options.getArgument(
-      "set-globals",
-      "SetGlobals usage:  wasm-opt --pass-arg=set-globals@x=y,z=w");
+    Name input =
+      getArgument("set-globals",
+                  "SetGlobals usage:  wasm-opt --pass-arg=set-globals@x=y,z=w");
 
     // The input is a set of X=Y pairs separated by commas.
     String::Split pairs(input.toString(), ",");
diff --git a/src/passes/StackCheck.cpp b/src/passes/StackCheck.cpp
index 229a97f26..ce5d346b9 100644
--- a/src/passes/StackCheck.cpp
+++ b/src/passes/StackCheck.cpp
@@ -141,8 +141,7 @@ struct StackCheck : public Pass {
     auto stackLimitName = Names::getValidGlobalName(*module, "__stack_limit");
 
     Name handler;
-    auto handlerName =
-      getPassOptions().getArgumentOrDefault("stack-check-handler", "");
+    auto handlerName = getArgumentOrDefault("stack-check-handler", "");
     if (handlerName != "") {
       handler = handlerName;
       importStackOverflowHandler(
diff --git a/src/passes/TraceCalls.cpp b/src/passes/TraceCalls.cpp
index 01278c2e9..44bc16e95 100644
--- a/src/passes/TraceCalls.cpp
+++ b/src/passes/TraceCalls.cpp
@@ -124,10 +124,10 @@ struct TraceCalls : public Pass {
   bool addsEffects() override { return true; }
 
   void run(Module* module) override {
-    auto functionsDefinitions = getPassOptions().getArgument(
-      "trace-calls",
-      "TraceCalls usage: wasm-opt "
-      "--trace-calls=FUNCTION_TO_TRACE[:TRACER_NAME][,...]");
+    auto functionsDefinitions =
+      getArgument("trace-calls",
+                  "TraceCalls usage: wasm-opt "
+                  "--trace-calls=FUNCTION_TO_TRACE[:TRACER_NAME][,...]");
 
     auto tracedFunctions = parseArgument(functionsDefinitions);
 
diff --git a/src/passes/pass.cpp b/src/passes/pass.cpp
index b226d6ec9..ec6077941 100644
--- a/src/passes/pass.cpp
+++ b/src/passes/pass.cpp
@@ -73,6 +73,10 @@ std::vector<std::string> PassRegistry::getRegisteredNames() {
   return ret;
 }
 
+bool PassRegistry::containsPass(const std::string& name) {
+  return passInfos.count(name) > 0;
+}
+
 std::string PassRegistry::getPassDescription(std::string name) {
   assert(passInfos.find(name) != passInfos.end());
   return passInfos[name].description;
@@ -715,6 +719,15 @@ void PassRunner::addDefaultGlobalOptimizationPrePasses() {
   //       which can lead to more opportunities for global effects to matter.
 }
 
+void PassRunner::add(std::string passName, std::optional<std::string> passArg) {
+  auto pass = PassRegistry::get()->createPass(passName);
+  if (passArg) {
+    pass->setPassArg(*passArg);
+  }
+
+  doAdd(std::move(pass));
+}
+
 void PassRunner::addDefaultGlobalOptimizationPostPasses() {
   if (options.optimizeLevel >= 2 || options.shrinkLevel >= 1) {
     addIfNoDWARFIssues("dae-optimizing");
@@ -1025,4 +1038,29 @@ bool PassRunner::shouldPreserveDWARF() {
   return true;
 }
 
+bool Pass::hasArgument(const std::string& key) {
+  // An argument with the name of the pass is stored on the instance. Other
+  // arguments are in the global storage.
+  return key == name ? passArg.has_value() : getPassOptions().hasArgument(key);
+}
+
+std::string Pass::getArgument(const std::string& key,
+                              const std::string& errorTextIfMissing) {
+  if (!hasArgument(key)) {
+    Fatal() << errorTextIfMissing;
+  }
+
+  return (key == name) ? *passArg
+                       : getPassOptions().getArgument(key, errorTextIfMissing);
+}
+
+std::string Pass::getArgumentOrDefault(const std::string& key,
+                                       const std::string& defaultValue) {
+  if (key == name) {
+    return passArg.value_or(defaultValue);
+  }
+
+  return getPassOptions().getArgumentOrDefault(key, defaultValue);
+}
+
 } // namespace wasm
diff --git a/src/tools/optimization-options.h b/src/tools/optimization-options.h
index af468769d..f04b73211 100644
--- a/src/tools/optimization-options.h
+++ b/src/tools/optimization-options.h
@@ -51,6 +51,9 @@ struct OptimizationOptions : public ToolOptions {
     // The name of the pass to run.
     std::string name;
 
+    // The main argument of the pass, if applicable.
+    std::optional<std::string> argument;
+
     // The optimize and shrink levels to run the pass with, if specified. If not
     // specified then the defaults are used.
     std::optional<int> optimizeLevel;
@@ -330,18 +333,47 @@ struct OptimizationOptions : public ToolOptions {
         //   --foo --pass-arg=foo@ARG
         Options::Arguments::Optional,
         [this, p](Options*, const std::string& arg) {
+          PassInfo info(p);
           if (!arg.empty()) {
-            if (passOptions.arguments.count(p)) {
-              Fatal() << "Cannot pass multiple pass arguments to " << p;
-            }
-            passOptions.arguments[p] = arg;
+            info.argument = arg;
           }
-          passes.push_back(p);
+
+          passes.push_back(info);
         },
         PassRegistry::get()->isPassHidden(p));
     }
   }
 
+  // Pass arguments with the same name as the pass are stored per-instance on
+  // PassInfo, while all other arguments are stored globally on
+  // passOptions.arguments (which is what the overriden method on ToolOptions
+  // does).
+  void addPassArg(const std::string& key, const std::string& value) override {
+    // Scan the current pass list for the last defined instance of a pass named
+    // like the argument under consideration.
+    for (auto i = passes.rbegin(); i != passes.rend(); i++) {
+      if (i->name != key) {
+        continue;
+      }
+
+      if (i->argument.has_value()) {
+        Fatal() << i->name << " already set to " << *(i->argument);
+      }
+
+      // Found? Store the argument value there and return.
+      i->argument = value;
+      return;
+    }
+
+    // Not found? Store it globally if there is no pass with the same name.
+    if (!PassRegistry::get()->containsPass(key)) {
+      return ToolOptions::addPassArg(key, value);
+    }
+
+    // Not found, but we have a pass with the same name? Bail out.
+    Fatal() << "can't set " << key << ": pass not enabled";
+  }
+
   bool runningDefaultOptimizationPasses() {
     for (auto& pass : passes) {
       if (pass.name == DEFAULT_OPT_PASSES) {
@@ -393,7 +425,7 @@ struct OptimizationOptions : public ToolOptions {
         passRunner.options.shrinkLevel = passOptions.shrinkLevel;
       } else {
         // This is a normal pass. Add it to the queue for execution.
-        passRunner.add(pass.name);
+        passRunner.add(pass.name, pass.argument);
 
         // Normal passes do not set their own optimize/shrinkLevels.
         assert(!pass.optimizeLevel);
diff --git a/src/tools/tool-options.h b/src/tools/tool-options.h
index 10a03acc7..c9d891a00 100644
--- a/src/tools/tool-options.h
+++ b/src/tools/tool-options.h
@@ -126,7 +126,10 @@ struct ToolOptions : public Options {
       .add("--pass-arg",
            "-pa",
            "An argument passed along to optimization passes being run. Must be "
-           "in the form KEY@VALUE",
+           "in the form KEY@VALUE.  If KEY is the name of a pass then it "
+           "applies to the closest instance of that pass before us. If KEY is "
+           "not the name of a pass then it is a global option that applies to "
+           "all pass instances that read it.",
            ToolOptionsCategory,
            Options::Arguments::N,
            [this](Options*, const std::string& argument) {
@@ -139,7 +142,8 @@ struct ToolOptions : public Options {
                key = argument.substr(0, colon);
                value = argument.substr(colon + 1);
              }
-             passOptions.arguments[key] = value;
+
+             addPassArg(key, value);
            })
       .add(
         "--closed-world",
@@ -213,6 +217,12 @@ struct ToolOptions : public Options {
     module.features.disable(disabledFeatures);
   }
 
+  virtual void addPassArg(const std::string& key, const std::string& value) {
+    passOptions.arguments[key] = value;
+  }
+
+  virtual ~ToolOptions() = default;
+
 private:
   FeatureSet enabledFeatures = FeatureSet::Default;
   FeatureSet disabledFeatures = FeatureSet::None;
diff --git a/src/tools/wasm-split/wasm-split.cpp b/src/tools/wasm-split/wasm-split.cpp
index abb1646c1..eed26f1e1 100644
--- a/src/tools/wasm-split/wasm-split.cpp
+++ b/src/tools/wasm-split/wasm-split.cpp
@@ -192,9 +192,8 @@ void getFunctionsToKeepAndSplit(Module& wasm,
 
 void writeSymbolMap(Module& wasm, std::string filename) {
   PassOptions options;
-  options.arguments["symbolmap"] = filename;
   PassRunner runner(&wasm, options);
-  runner.add("symbolmap");
+  runner.add("symbolmap", filename);
   runner.run();
 }
 
diff --git a/test/lit/help/wasm-as.test b/test/lit/help/wasm-as.test
index 114064576..3a863dbd6 100644
--- a/test/lit/help/wasm-as.test
+++ b/test/lit/help/wasm-as.test
@@ -121,7 +121,12 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization
 ;; CHECK-NEXT:                                        passes being run. Must be in the form
-;; CHECK-NEXT:                                        KEY@VALUE
+;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass
+;; CHECK-NEXT:                                        then it applies to the closest instance
+;; CHECK-NEXT:                                        of that pass before us. If KEY is not the
+;; CHECK-NEXT:                                        name of a pass then it is a global option
+;; CHECK-NEXT:                                        that applies to all pass instances that
+;; CHECK-NEXT:                                        read it.
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does
 ;; CHECK-NEXT:                                        not inspect or interact with GC and
diff --git a/test/lit/help/wasm-ctor-eval.test b/test/lit/help/wasm-ctor-eval.test
index 93b5654ed..2d57e3e8c 100644
--- a/test/lit/help/wasm-ctor-eval.test
+++ b/test/lit/help/wasm-ctor-eval.test
@@ -128,7 +128,12 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization
 ;; CHECK-NEXT:                                        passes being run. Must be in the form
-;; CHECK-NEXT:                                        KEY@VALUE
+;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass
+;; CHECK-NEXT:                                        then it applies to the closest instance
+;; CHECK-NEXT:                                        of that pass before us. If KEY is not the
+;; CHECK-NEXT:                                        name of a pass then it is a global option
+;; CHECK-NEXT:                                        that applies to all pass instances that
+;; CHECK-NEXT:                                        read it.
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does
 ;; CHECK-NEXT:                                        not inspect or interact with GC and
diff --git a/test/lit/help/wasm-dis.test b/test/lit/help/wasm-dis.test
index 06dda9e96..63c7f8bd0 100644
--- a/test/lit/help/wasm-dis.test
+++ b/test/lit/help/wasm-dis.test
@@ -114,7 +114,12 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization
 ;; CHECK-NEXT:                                        passes being run. Must be in the form
-;; CHECK-NEXT:                                        KEY@VALUE
+;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass
+;; CHECK-NEXT:                                        then it applies to the closest instance
+;; CHECK-NEXT:                                        of that pass before us. If KEY is not the
+;; CHECK-NEXT:                                        name of a pass then it is a global option
+;; CHECK-NEXT:                                        that applies to all pass instances that
+;; CHECK-NEXT:                                        read it.
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does
 ;; CHECK-NEXT:                                        not inspect or interact with GC and
diff --git a/test/lit/help/wasm-emscripten-finalize.test b/test/lit/help/wasm-emscripten-finalize.test
index 1b31e1e44..c92960dfb 100644
--- a/test/lit/help/wasm-emscripten-finalize.test
+++ b/test/lit/help/wasm-emscripten-finalize.test
@@ -156,7 +156,12 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization
 ;; CHECK-NEXT:                                        passes being run. Must be in the form
-;; CHECK-NEXT:                                        KEY@VALUE
+;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass
+;; CHECK-NEXT:                                        then it applies to the closest instance
+;; CHECK-NEXT:                                        of that pass before us. If KEY is not the
+;; CHECK-NEXT:                                        name of a pass then it is a global option
+;; CHECK-NEXT:                                        that applies to all pass instances that
+;; CHECK-NEXT:                                        read it.
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does
 ;; CHECK-NEXT:                                        not inspect or interact with GC and
diff --git a/test/lit/help/wasm-merge.test b/test/lit/help/wasm-merge.test
index 293bdbff0..fe3f1cdb2 100644
--- a/test/lit/help/wasm-merge.test
+++ b/test/lit/help/wasm-merge.test
@@ -144,7 +144,12 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization
 ;; CHECK-NEXT:                                        passes being run. Must be in the form
-;; CHECK-NEXT:                                        KEY@VALUE
+;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass
+;; CHECK-NEXT:                                        then it applies to the closest instance
+;; CHECK-NEXT:                                        of that pass before us. If KEY is not the
+;; CHECK-NEXT:                                        name of a pass then it is a global option
+;; CHECK-NEXT:                                        that applies to all pass instances that
+;; CHECK-NEXT:                                        read it.
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does
 ;; CHECK-NEXT:                                        not inspect or interact with GC and
diff --git a/test/lit/help/wasm-metadce.test b/test/lit/help/wasm-metadce.test
index 5b621caf5..66013f81a 100644
--- a/test/lit/help/wasm-metadce.test
+++ b/test/lit/help/wasm-metadce.test
@@ -733,7 +733,14 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --pass-arg,-pa                                An argument passed along to
 ;; CHECK-NEXT:                                                 optimization passes being run.
-;; CHECK-NEXT:                                                 Must be in the form KEY@VALUE
+;; CHECK-NEXT:                                                 Must be in the form KEY@VALUE.
+;; CHECK-NEXT:                                                 If KEY is the name of a pass
+;; CHECK-NEXT:                                                 then it applies to the closest
+;; CHECK-NEXT:                                                 instance of that pass before us.
+;; CHECK-NEXT:                                                 If KEY is not the name of a pass
+;; CHECK-NEXT:                                                 then it is a global option that
+;; CHECK-NEXT:                                                 applies to all pass instances
+;; CHECK-NEXT:                                                 that read it.
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --closed-world,-cw                            Assume code outside of the
 ;; CHECK-NEXT:                                                 module does not inspect or
diff --git a/test/lit/help/wasm-opt.test b/test/lit/help/wasm-opt.test
index 9f7caf98b..c89baaf4a 100644
--- a/test/lit/help/wasm-opt.test
+++ b/test/lit/help/wasm-opt.test
@@ -742,7 +742,14 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --pass-arg,-pa                                An argument passed along to
 ;; CHECK-NEXT:                                                 optimization passes being run.
-;; CHECK-NEXT:                                                 Must be in the form KEY@VALUE
+;; CHECK-NEXT:                                                 Must be in the form KEY@VALUE.
+;; CHECK-NEXT:                                                 If KEY is the name of a pass
+;; CHECK-NEXT:                                                 then it applies to the closest
+;; CHECK-NEXT:                                                 instance of that pass before us.
+;; CHECK-NEXT:                                                 If KEY is not the name of a pass
+;; CHECK-NEXT:                                                 then it is a global option that
+;; CHECK-NEXT:                                                 applies to all pass instances
+;; CHECK-NEXT:                                                 that read it.
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --closed-world,-cw                            Assume code outside of the
 ;; CHECK-NEXT:                                                 module does not inspect or
diff --git a/test/lit/help/wasm-reduce.test b/test/lit/help/wasm-reduce.test
index 397952855..cacf260fa 100644
--- a/test/lit/help/wasm-reduce.test
+++ b/test/lit/help/wasm-reduce.test
@@ -150,7 +150,12 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization
 ;; CHECK-NEXT:                                        passes being run. Must be in the form
-;; CHECK-NEXT:                                        KEY@VALUE
+;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass
+;; CHECK-NEXT:                                        then it applies to the closest instance
+;; CHECK-NEXT:                                        of that pass before us. If KEY is not the
+;; CHECK-NEXT:                                        name of a pass then it is a global option
+;; CHECK-NEXT:                                        that applies to all pass instances that
+;; CHECK-NEXT:                                        read it.
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does
 ;; CHECK-NEXT:                                        not inspect or interact with GC and
diff --git a/test/lit/help/wasm-split.test b/test/lit/help/wasm-split.test
index c118d302d..bc09796d7 100644
--- a/test/lit/help/wasm-split.test
+++ b/test/lit/help/wasm-split.test
@@ -231,7 +231,12 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization
 ;; CHECK-NEXT:                                        passes being run. Must be in the form
-;; CHECK-NEXT:                                        KEY@VALUE
+;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass
+;; CHECK-NEXT:                                        then it applies to the closest instance
+;; CHECK-NEXT:                                        of that pass before us. If KEY is not the
+;; CHECK-NEXT:                                        name of a pass then it is a global option
+;; CHECK-NEXT:                                        that applies to all pass instances that
+;; CHECK-NEXT:                                        read it.
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does
 ;; CHECK-NEXT:                                        not inspect or interact with GC and
diff --git a/test/lit/help/wasm2js.test b/test/lit/help/wasm2js.test
index ca731d277..45bef7d73 100644
--- a/test/lit/help/wasm2js.test
+++ b/test/lit/help/wasm2js.test
@@ -696,7 +696,14 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --pass-arg,-pa                                An argument passed along to
 ;; CHECK-NEXT:                                                 optimization passes being run.
-;; CHECK-NEXT:                                                 Must be in the form KEY@VALUE
+;; CHECK-NEXT:                                                 Must be in the form KEY@VALUE.
+;; CHECK-NEXT:                                                 If KEY is the name of a pass
+;; CHECK-NEXT:                                                 then it applies to the closest
+;; CHECK-NEXT:                                                 instance of that pass before us.
+;; CHECK-NEXT:                                                 If KEY is not the name of a pass
+;; CHECK-NEXT:                                                 then it is a global option that
+;; CHECK-NEXT:                                                 applies to all pass instances
+;; CHECK-NEXT:                                                 that read it.
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --closed-world,-cw                            Assume code outside of the
 ;; CHECK-NEXT:                                                 module does not inspect or