[NFC] Move InstrumentedPass logic out and use it in another place (#6132)

Asyncify gained a way to wrap a pass so that it only runs on a given set of
functions, rather than on all functions, so the wrapper "filters" what the pass
operates on. That was useful in Asyncify as we wanted to only do work on
functions that Asyncify actually instrumented.

There is another place in the code that needs such functionality,
optimizeAfterInlining, which runs optimizations after we inline; again, we
only want to optimize on the functions we know are relevant because they
changed. To do that, move that logic out to a general place so it can be
reused. This makes the code there a lot less hackish.

While doing so make the logic only work on function-parallel passes. It
never did anyhow, but now it asserts on that. (It can't run on a general
pass because a general one does not provide an interface to affect which
functions it operates on; a general pass is entirely opaque in that way.)

1 files changed, 6 insertions, 23 deletions

diff --git a/src/passes/opt-utils.h b/src/passes/opt-utils.h
index 1945167b0..7bb733b03 100644
--- a/src/passes/opt-utils.h
+++ b/src/passes/opt-utils.h
@@ -23,37 +23,21 @@
 #include <ir/element-utils.h>
 #include <ir/module-utils.h>
 #include <pass.h>
+#include <passes/pass-utils.h>
 #include <wasm.h>
 
-namespace wasm {
+namespace wasm::OptUtils {
 
-namespace OptUtils {
-
-// Run useful optimizations after inlining new code into a set
-// of functions.
-inline void optimizeAfterInlining(const std::unordered_set<Function*>& funcs,
+// Run useful optimizations after inlining new code into a set of functions.
+inline void optimizeAfterInlining(const PassUtils::FuncSet& funcs,
                                   Module* module,
                                   PassRunner* parentRunner) {
-  // save the full list of functions on the side
-  std::vector<std::unique_ptr<Function>> all;
-  all.swap(module->functions);
-  module->updateFunctionsMap();
-  for (auto& func : funcs) {
-    module->addFunction(func);
-  }
-  PassRunner runner(module, parentRunner->options);
+  PassUtils::FilteredPassRunner runner(module, funcs, parentRunner->options);
   runner.setIsNested(true);
-  runner.setValidateGlobally(false); // not a full valid module
   // this is especially useful after inlining
   runner.add("precompute-propagate");
   runner.addDefaultFunctionOptimizationPasses(); // do all the usual stuff
   runner.run();
-  // restore all the funcs
-  for (auto& func : module->functions) {
-    func.release();
-  }
-  all.swap(module->functions);
-  module->updateFunctionsMap();
 }
 
 struct FunctionRefReplacer
@@ -102,7 +86,6 @@ inline void replaceFunctions(PassRunner* runner,
   }
 }
 
-} // namespace OptUtils
-} // namespace wasm
+} // namespace wasm::OptUtils
 
 #endif // wasm_passes_opt_utils_h