diff options
| -rw-r--r-- | src/ir/drop.h | 62 | ||||
| -rw-r--r-- | src/passes/OptimizeInstructions.cpp | 13 | ||||
| -rw-r--r-- | test/lit/passes/optimize-instructions-gc.wast | 29 |
3 files changed, 101 insertions, 3 deletions
diff --git a/src/ir/drop.h b/src/ir/drop.h new file mode 100644 index 000000000..9ed5276ff --- /dev/null +++ b/src/ir/drop.h @@ -0,0 +1,62 @@ +/* + * Copyright 2022 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_ir_drop_h +#define wasm_ir_drop_h + +#include "ir/effects.h" +#include "ir/iteration.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +// Given an expression, returns a new expression that drops the given +// expression's children that cannot be removed outright due to their side +// effects. This is useful if we know the node is not needed but may need to +// keep the children around; this utility will automatically remove any children +// we do not actually need to keep, based on their effects. +// +// The caller must also pass in a last item to append to the output (which is +// typically what the original expression is replaced with). +Expression* getDroppedChildrenAndAppend(Expression* curr, + Module& wasm, + const PassOptions& options, + Expression* last) { + Builder builder(wasm); + std::vector<Expression*> contents; + for (auto* child : ChildIterator(curr)) { + if (!EffectAnalyzer(options, wasm, child).hasUnremovableSideEffects()) { + continue; + } + if (child->type.isConcrete()) { + contents.push_back(builder.makeDrop(child)); + } else { + // The child is unreachable, or none (none is possible as a child of a + // block or loop, etc.); in both cases we do not need a drop. + contents.push_back(child); + } + } + contents.push_back(last); + if (contents.size() == 1) { + return contents[0]; + } + return builder.makeBlock(contents); +} + +} // namespace wasm + +#endif // wasm_ir_drop_h diff --git a/src/passes/OptimizeInstructions.cpp b/src/passes/OptimizeInstructions.cpp index f2ca4e0be..400ed6af0 100644 --- a/src/passes/OptimizeInstructions.cpp +++ b/src/passes/OptimizeInstructions.cpp @@ -25,6 +25,7 @@ #include <ir/abstract.h> #include <ir/bits.h> #include <ir/cost.h> +#include <ir/drop.h> #include <ir/effects.h> #include <ir/eh-utils.h> #include <ir/find_all.h> @@ -1377,9 +1378,15 @@ struct OptimizeInstructions skipCast(curr->right, Type::eqref); // Identical references compare equal. - if (areConsecutiveInputsEqualAndRemovable(curr->left, curr->right)) { - replaceCurrent( - Builder(*getModule()).makeConst(Literal::makeOne(Type::i32))); + // (Technically we do not need to check if the inputs are also foldable into + // a single one, but we do not have utility code to handle non-foldable + // cases yet; the foldable case we do handle is the common one of the first + // child being a tee and the second a get of that tee. TODO) + if (areConsecutiveInputsEqualAndFoldable(curr->left, curr->right)) { + auto* result = + Builder(*getModule()).makeConst(Literal::makeOne(Type::i32)); + replaceCurrent(getDroppedChildrenAndAppend( + curr, *getModule(), getPassOptions(), result)); return; } diff --git a/test/lit/passes/optimize-instructions-gc.wast b/test/lit/passes/optimize-instructions-gc.wast index 64213d930..2c6498ec3 100644 --- a/test/lit/passes/optimize-instructions-gc.wast +++ b/test/lit/passes/optimize-instructions-gc.wast @@ -979,6 +979,16 @@ ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (i32.const 1) ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (block (result i32) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (local.tee $x + ;; CHECK-NEXT: (local.get $x) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (i32.const 1) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; NOMNL: (func $ref-eq-corner-cases (type $eqref_=>_none) (param $x eqref) ;; NOMNL-NEXT: (drop @@ -1006,6 +1016,16 @@ ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (i32.const 1) ;; NOMNL-NEXT: ) + ;; NOMNL-NEXT: (drop + ;; NOMNL-NEXT: (block (result i32) + ;; NOMNL-NEXT: (drop + ;; NOMNL-NEXT: (local.tee $x + ;; NOMNL-NEXT: (local.get $x) + ;; NOMNL-NEXT: ) + ;; NOMNL-NEXT: ) + ;; NOMNL-NEXT: (i32.const 1) + ;; NOMNL-NEXT: ) + ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) (func $ref-eq-corner-cases (param $x eqref) ;; side effects prevent optimization @@ -1058,6 +1078,15 @@ ) ) ) + ;; a tee does not prevent optimization, as we can fold the tee and the get. + (drop + (ref.eq + (local.tee $x + (local.get $x) + ) + (local.get $x) + ) + ) ) ;; CHECK: (func $ref-eq-ref-cast (param $x eqref) |