Don't generate redundant unreachables in Flatten

scripts/fuzz_opt.py

@@ -40,7 +40,7 @@
 
 INPUT_SIZE_LIMIT = 150 * 1024
 
-LOG_LIMIT = 125
+LOG_LIMIT = 500
 
 
 # utilities

src/ir/flat.h

@@ -69,6 +69,41 @@ inline bool isControlFlowStructure(Expression* curr) {
          curr->is<Try>();
 }
 
+// Returns true if the given control flow structure preserves all its childrens'
+// preludes within it. For example, blocks satisfy this property, because when
+// the original block is in the form of
+// (block
+//   (some expression)
+//   ...
+// )
+// and we replace (some expression) with a local.get whose prelude is (some
+// expression), the final block will be in the form of
+// (block
+//   (some expression)
+//   (local.get ...)
+//   ...
+// )
+// So the block's children's preludes do not escape the boundary of the block.
+// 'if' does not satisfy this property, because the prelude of its condition
+// ends up preceding (= escaping) the 'if'. For example, if the original 'if' is
+// in the form of
+// (if
+//   (some expression)
+//   ...
+// )
+// and (some expression) is replaced with a local.get whose prelude is (some
+// expression), the final 'if' will be in the form of
+// (some expression)
+// (if
+//   (local.get ...)
+//   ...
+// )
+// So 'if''s condition's preludes escapes the boundary of 'if'. Refer to Flatten
+// pass for detailed algorithms.
+inline bool containsChildrensPreludes(Expression* curr) {
+  return curr->is<Block>() || curr->is<Loop>() || curr->is<Try>();
+}
+
 inline void verifyFlatness(Function* func) {
   struct VerifyFlatness
     : public PostWalker<VerifyFlatness,

src/passes/Flatten.cpp

@@ -230,10 +230,12 @@ struct Flatten
 
             if (br->condition) {
               // the value must also flow out
-              ourPreludes.push_back(br);
+              Expression* parent = getParent();
               if (br->type.isConcrete()) {
+                ourPreludes.push_back(br);
                 replaceCurrent(builder.makeLocalGet(temp, type));
-              } else {
+              } else if (parent && !Flat::containsChildrensPreludes(parent)) {
+                ourPreludes.push_back(br);
                 assert(br->type == Type::unreachable);
                 replaceCurrent(builder.makeUnreachable());
               }
@@ -277,7 +279,9 @@ struct Flatten
     curr = getCurrent(); // we may have replaced it
     // we have changed children
     ReFinalizeNode().visit(curr);
-    if (curr->type == Type::unreachable) {
+    Expression* parent = getParent();
+    if (curr->type == Type::unreachable && !curr->is<Unreachable>() && parent &&
+        !Flat::containsChildrensPreludes(parent)) {
       ourPreludes.push_back(curr);
       replaceCurrent(builder.makeUnreachable());
     } else if (curr->type.isConcrete()) {

test/passes/flatten.bin.txt

@@ -104,7 +104,6 @@
    (nop)
    (unreachable)
   )
-  (unreachable)
  )
  (func $9 (; 9 ;) (param $0 i64) (param $1 f32) (param $2 f64) (param $3 i32) (param $4 i32) (result f64)
   (local $5 i64)