diff options
| author | Alon Zakai <azakai@google.com> | 2023-11-28 15:32:01 -0800 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2023-11-28 23:32:01 +0000 |
| commit | dbcac17d645d8ace8ae2cb69d6ba36b22d59b7cf (patch) | |
| tree | e1a9d96c28af13c8317f6a71846532dd54bec1cd /src/passes/pass-utils.h | |
| parent | 2ea76680ae728a3f41d493a3fc27344696bb0dcf (diff) | |
| download | binaryen-dbcac17d645d8ace8ae2cb69d6ba36b22d59b7cf.tar.gz binaryen-dbcac17d645d8ace8ae2cb69d6ba36b22d59b7cf.tar.bz2 binaryen-dbcac17d645d8ace8ae2cb69d6ba36b22d59b7cf.zip | |
[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.)
Diffstat (limited to 'src/passes/pass-utils.h')
| -rw-r--r-- | src/passes/pass-utils.h | 95 |
1 files changed, 95 insertions, 0 deletions
diff --git a/src/passes/pass-utils.h b/src/passes/pass-utils.h new file mode 100644 index 000000000..1db4f5614 --- /dev/null +++ b/src/passes/pass-utils.h @@ -0,0 +1,95 @@ +/* + * Copyright 2023 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_passes_pass_utils_h +#define wasm_passes_pass_utils_h + +#include <unordered_set> + +#include <pass.h> +#include <wasm.h> + +namespace wasm::PassUtils { + +using FuncSet = std::unordered_set<Function*>; + +// A wrapper around a parallel pass that filters it to run run only on select +// functions. +struct FilteredPass : public Pass { + std::unique_ptr<Pass> create() override { + // Function-parallel passes get a new instance per function. Create a copy + // of the wrapped pass along with ourselves. + return std::make_unique<FilteredPass>(pass->create(), relevantFuncs); + } + + FilteredPass(std::unique_ptr<Pass>&& pass, const FuncSet& relevantFuncs) + : pass(std::move(pass)), relevantFuncs(relevantFuncs) {} + + bool isFunctionParallel() override { + assert(pass->isFunctionParallel()); + return true; + } + + void runOnFunction(Module* module, Function* func) override { + if (!relevantFuncs.count(func)) { + return; + } + + // The pass runner calling us set our pass runner, which we must do for the + // wrapped pass. + pass->setPassRunner(getPassRunner()); + pass->runOnFunction(module, func); + } + + bool modifiesBinaryenIR() override { return pass->modifiesBinaryenIR(); } + + bool invalidatesDWARF() override { return pass->invalidatesDWARF(); } + + bool addsEffects() override { return pass->addsEffects(); } + + bool requiresNonNullableLocalFixups() override { + return pass->requiresNonNullableLocalFixups(); + } + +private: + std::unique_ptr<Pass> pass; + const FuncSet& relevantFuncs; +}; + +// A pass runner that wraps all passes, filtering so that they only run on +// select functions. +struct FilteredPassRunner : public PassRunner { + FilteredPassRunner(Module* wasm, const FuncSet& relevantFuncs) + : PassRunner(wasm), relevantFuncs(relevantFuncs) {} + + FilteredPassRunner(Module* wasm, + const FuncSet& relevantFuncs, + const PassOptions& options) + : PassRunner(wasm, options), relevantFuncs(relevantFuncs) {} + +protected: + void doAdd(std::unique_ptr<Pass> pass) override { + PassRunner::doAdd( + std::make_unique<FilteredPass>(std::move(pass), relevantFuncs)); + } + +private: + const FuncSet& relevantFuncs; +}; + +} // namespace wasm::PassUtils + +#endif // wasm_passes_pass_utils_h |