Extend drop.h and use it in Directize (#5713)

This adds an option to ignore effects in the parent in
getDroppedChildrenAndAppend. With that, this becomes usable in more
places, like Directize, basically in situations where we know we can ignore
effects in the parent (since we've inferred they are not needed). This lets
us get rid of some boilerplate code in Directize.

Diff without whitespace is a lot smaller. A large other part of the diff is a
rename of curr => parent which I think it makes it more readable as then
parent/children is a clear contrast, and then the new parameter "ignore/
notice parent effects" is obviously connected to "parent".

The top comment in drop.cpp is removed as it just duplicated the top
comment in the header drop.h.

This is basically NFC but using drop.h does bring the advantage of
emitting less code, see the test changes, so it is noticeable in the IR.

This is a refactoring PR in preparation for a larger improvement to
Directize that will also benefit from this new drop capability.

1 files changed, 24 insertions, 30 deletions

diff --git a/src/ir/drop.cpp b/src/ir/drop.cpp
index 5a860fa29..f732e3730 100644
--- a/src/ir/drop.cpp
+++ b/src/ir/drop.cpp
@@ -14,9 +14,7 @@
  * limitations under the License.
  */
 
-#ifndef wasm_ir_drop_h
-#define wasm_ir_drop_h
-
+#include "ir/drop.h"
 #include "ir/branch-utils.h"
 #include "ir/effects.h"
 #include "ir/iteration.h"
@@ -25,27 +23,26 @@
 
 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. Note that this only operates on children that execute
-// unconditionally. That is the case in almost all expressions, except for those
-// with conditional execution, like if, which unconditionally executes the
-// condition but then conditionally executes one of the two arms.
-Expression* getDroppedChildrenAndAppend(Expression* curr,
+Expression* getDroppedChildrenAndAppend(Expression* parent,
                                         Module& wasm,
                                         const PassOptions& options,
-                                        Expression* last) {
-  // We check for shallow effects here, since we may be able to remove |curr|
+                                        Expression* last,
+                                        DropMode mode) {
+  // We check for shallow effects here, since we may be able to remove |parent|
   // itself but keep its children around - we don't want effects in the children
   // to stop us from improving the code. Note that there are cases where the
-  // combined curr+children has fewer effects than curr itself, such as if curr
-  // is a block and the child branches to it, but in such cases we cannot remove
-  // curr anyhow (those cases are ruled out below), so looking at non-shallow
-  // effects would never help us (and would be slower to run).
-  ShallowEffectAnalyzer effects(options, wasm, curr);
-  // Ignore a trap, as the unreachable replacement would trap too.
-  if (last->is<Unreachable>()) {
-    effects.trap = false;
+  // combined parent+children has fewer effects than parent itself, such as if
+  // parent is a block and the child branches to it, but in such cases we cannot
+  // remove parent anyhow (those cases are ruled out below), so looking at
+  // non-shallow effects would never help us (and would be slower to run).
+  bool keepParent = false;
+  if (mode == DropMode::NoticeParentEffects) {
+    ShallowEffectAnalyzer effects(options, wasm, parent);
+    // Ignore a trap, as the unreachable replacement would trap too.
+    if (last->is<Unreachable>()) {
+      effects.trap = false;
+    }
+    keepParent = effects.hasUnremovableSideEffects();
   }
 
   // We cannot remove
@@ -56,19 +53,18 @@ Expression* getDroppedChildrenAndAppend(Expression* curr,
   // 5. Branch targets: We will need the target for the branches to it to
   //                    validate.
   Builder builder(wasm);
-  if (effects.hasUnremovableSideEffects() || curr->is<If>() ||
-      curr->is<Try>() || curr->is<Pop>() ||
-      BranchUtils::getDefinedName(curr).is()) {
-    // If curr is concrete we must drop it. Or, if it is unreachable or none,
+  if (keepParent || parent->is<If>() || parent->is<Try>() ||
+      parent->is<Pop>() || BranchUtils::getDefinedName(parent).is()) {
+    // If parent is concrete we must drop it. Or, if it is unreachable or none,
     // then we can leave it as it is.
-    if (curr->type.isConcrete()) {
-      curr = builder.makeDrop(curr);
+    if (parent->type.isConcrete()) {
+      parent = builder.makeDrop(parent);
     }
-    return builder.makeSequence(curr, last);
+    return builder.makeSequence(parent, last);
   }
 
   std::vector<Expression*> contents;
-  for (auto* child : ChildIterator(curr)) {
+  for (auto* child : ChildIterator(parent)) {
     if (!EffectAnalyzer(options, wasm, child).hasUnremovableSideEffects()) {
       continue;
     }
@@ -87,5 +83,3 @@ Expression* getDroppedChildrenAndAppend(Expression* curr,
 }
 
 } // namespace wasm
-
-#endif // wasm_ir_drop_h