Allow multiple noinline instances with different arguments.

Author: DirtyHairy

src/pass.h

@@ -38,7 +38,11 @@ struct PassRegistry {
 
   using Creator = std::function<Pass*()>;
 
-  void registerPass(const char* name, const char* description, Creator create);
+  void registerPass(const char* name,
+                    const char* description,
+                    Creator create,
+                    bool allowMultipleInstancesWithArgs = false);
+  ;
   // Register a pass that's used for internal testing. These passes do not show
   // up in --help.
   void
@@ -47,6 +51,7 @@ struct PassRegistry {
   std::vector<std::string> getRegisteredNames();
   std::string getPassDescription(std::string name);
   bool isPassHidden(std::string name);
+  bool doesPassAllowMultipleInstancesWithArgs(std::string name);
 
 private:
   void registerPasses();
@@ -55,9 +60,14 @@ struct PassRegistry {
     std::string description;
     Creator create;
     bool hidden;
+    bool allowMultipleInstancesWithArgs;
     PassInfo() = default;
-    PassInfo(std::string description, Creator create, bool hidden = false)
-      : description(description), create(create), hidden(hidden) {}
+    PassInfo(std::string description,
+             Creator create,
+             bool hidden = false,
+             bool allowMultipleInstancesWithArgs = false)
+      : description(description), create(create), hidden(hidden),
+        allowMultipleInstancesWithArgs(allowMultipleInstancesWithArgs) {}
   };
   std::map<std::string, PassInfo> passInfos;
 };
@@ -322,9 +332,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::optional<std::string>());
 
   // Add a pass given an instance.
   void add(std::unique_ptr<Pass> pass) { doAdd(std::move(pass)); }
@@ -486,6 +495,8 @@ class Pass {
   // to imports must override this to return true.
   virtual bool addsEffects() { return false; }
 
+  void setPassArg(std::string value) { passArg = value; }
+
   std::string name;
 
   PassRunner* getPassRunner() { return runner; }
@@ -497,6 +508,8 @@ class Pass {
   PassOptions& getPassOptions() { return runner->options; }
 
 protected:
+  std::optional<std::string> passArg;
+
   Pass() = default;
   Pass(const Pass&) = default;
   Pass(Pass&&) = default;

src/passes/NoInline.cpp

@@ -48,8 +48,10 @@ 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 =
+      passArg ? *passArg
+              : getPassOptions().getArgument(
+                  name, "Usage usage:  wasm-opt --" + name + "=WILDCARD");
 
     for (auto& func : module->functions) {
       if (!String::wildcardMatch(pattern, func->name.toString())) {

src/passes/pass.cpp

@@ -43,9 +43,11 @@ PassRegistry* PassRegistry::get() { return &singleton; }
 
 void PassRegistry::registerPass(const char* name,
                                 const char* description,
-                                Creator create) {
+                                Creator create,
+                                bool allowMultipleInstancesWithArgs) {
   assert(passInfos.find(name) == passInfos.end());
-  passInfos[name] = PassInfo(description, create);
+  passInfos[name] =
+    PassInfo(description, create, false, allowMultipleInstancesWithArgs);
 }
 
 void PassRegistry::registerTestPass(const char* name,
@@ -83,6 +85,12 @@ bool PassRegistry::isPassHidden(std::string name) {
   return passInfos[name].hidden;
 }
 
+bool PassRegistry::doesPassAllowMultipleInstancesWithArgs(std::string name) {
+  assert(passInfos.find(name) != passInfos.end());
+
+  return passInfos[name].allowMultipleInstancesWithArgs;
+}
+
 // PassRunner
 
 void PassRegistry::registerPasses() {
@@ -300,7 +308,8 @@ void PassRegistry::registerPasses() {
     createMultiMemoryLoweringWithBoundsChecksPass);
   registerPass("nm", "name list", createNameListPass);
   registerPass("name-types", "(re)name all heap types", createNameTypesPass);
-  registerPass("no-inline", "mark functions as no-inline", createNoInlinePass);
+  registerPass(
+    "no-inline", "mark functions as no-inline", createNoInlinePass, true);
   registerPass("no-full-inline",
                "mark functions as no-inline (for full inlining only)",
                createNoFullInlinePass);
@@ -708,6 +717,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");

src/tools/optimization-options.h

@@ -46,6 +46,8 @@ struct OptimizationOptions : public ToolOptions {
     // The name of the pass to run.
     std::string name;
 
+    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;
@@ -315,13 +317,18 @@ 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)) {
+            if (passOptions.arguments.count(p) &&
+                !PassRegistry::get()->doesPassAllowMultipleInstancesWithArgs(
+                  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));
     }
@@ -378,7 +385,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);