1 files changed, 15 insertions, 25 deletions

diff --git a/src/passes/MergeBlocks.cpp b/src/passes/MergeBlocks.cpp
index 7518c73ca..147ba9f45 100644
--- a/src/passes/MergeBlocks.cpp
+++ b/src/passes/MergeBlocks.cpp
@@ -176,15 +176,6 @@ struct BreakValueDropper : public ControlFlowWalker<BreakValueDropper> {
   }
 };
 
-static bool hasUnreachableChild(Block* block) {
-  for (auto* test : block->list) {
-    if (test->type == Type::unreachable) {
-      return true;
-    }
-  }
-  return false;
-}
-
 // Checks for code after an unreachable element.
 static bool hasDeadCode(Block* block) {
   auto& list = block->list;
@@ -206,11 +197,6 @@ static bool optimizeDroppedBlock(Drop* drop,
                                  PassOptions& options,
                                  BranchUtils::BranchSeekerCache& branchInfo) {
   assert(drop->value == block);
-  if (hasUnreachableChild(block)) {
-    // Don't move around unreachable code, as it can change types (leave it for
-    // DCE).
-    return false;
-  }
   if (block->name.is()) {
     // There may be breaks: see if we can remove their values.
     Expression* expression = block;
@@ -241,8 +227,8 @@ static bool optimizeDroppedBlock(Drop* drop,
   return true;
 }
 
-// Core block optimizer routine.
-static void optimizeBlock(Block* curr,
+// Core block optimizer routine. Returns true when we optimize.
+static bool optimizeBlock(Block* curr,
                           Module* module,
                           PassOptions& passOptions,
                           BranchUtils::BranchSeekerCache& branchInfo) {
@@ -412,6 +398,7 @@ static void optimizeBlock(Block* curr,
   if (changed) {
     curr->finalize(curr->type);
   }
+  return changed;
 }
 
 void BreakValueDropper::visitBlock(Block* curr) {
@@ -427,6 +414,8 @@ struct MergeBlocks
     return std::make_unique<MergeBlocks>();
   }
 
+  bool refinalize = false;
+
   BranchUtils::BranchSeekerCache branchInfo;
 
   void visitBlock(Block* curr) {
@@ -438,6 +427,7 @@ struct MergeBlocks
       if (optimizeDroppedBlock(
             curr, block, *getModule(), getPassOptions(), branchInfo)) {
         replaceCurrent(block);
+        refinalize = true;
       }
     }
   }
@@ -485,13 +475,6 @@ struct MergeBlocks
     }
     if (auto* block = child->dynCast<Block>()) {
       if (!block->name.is() && block->list.size() >= 2) {
-        // if we move around unreachable code, type changes could occur. avoid
-        // that, as anyhow it means we should have run dce before getting here
-        if (curr->type == Type::none && hasUnreachableChild(block)) {
-          // moving the block to the outside would replace a none with an
-          // unreachable
-          return outer;
-        }
         auto* back = block->list.back();
         if (back->type == Type::unreachable) {
           // curr is not reachable, dce could remove it; don't try anything
@@ -510,6 +493,7 @@ struct MergeBlocks
           return outer;
         }
         child = back;
+        refinalize = true;
         if (outer == nullptr) {
           // reuse the block, move it out
           block->list.back() = curr;
@@ -600,8 +584,7 @@ struct MergeBlocks
       // too small for us to remove anything from (we cannot remove the last
       // element), or if it has unreachable code (leave that for dce), then give
       // up.
-      if (!block || block->name.is() || block->list.size() <= 1 ||
-          hasUnreachableChild(block)) {
+      if (!block || block->name.is() || block->list.size() <= 1) {
         continueEarly();
         continue;
       }
@@ -682,6 +665,7 @@ struct MergeBlocks
       outerBlock->list.push_back(curr);
       outerBlock->finalize(curr->type);
       replaceCurrent(outerBlock);
+      refinalize = true;
     }
   }
 
@@ -700,6 +684,12 @@ struct MergeBlocks
       outer = optimize(curr, curr->operands[i], outer);
     }
   }
+
+  void visitFunction(Function* curr) {
+    if (refinalize) {
+      ReFinalize().walkFunctionInModule(curr, getModule());
+    }
+  }
 };
 
 Pass* createMergeBlocksPass() { return new MergeBlocks(); }