dart2js: Move always-taken branch code to dominate join

pkg/compiler/lib/src/ssa/optimize.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart' show Selectors;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
@@ skipping 1605 matching lines @@
         eliminatedSideEffects =
             eliminatedSideEffects || instruction.sideEffects.hasSideEffects();
         removeUsers(instruction);
         block.remove(instruction);
       } else if (isDeadCode(instruction)) {
         block.remove(instruction);
       }
       instruction = previous;
     }
     block.forEachPhi(simplifyPhi);
+    evacuateTakenBranch(block);
   }
 
   void simplifyPhi(HPhi phi) {
     // If the phi is of the form `phi(x, HTypeKnown(x))`, it does not strengthen
     // `x`.  We can replace the phi with `x` to potentially make the HTypeKnown
     // refinement node dead and potentially make a HIf control no HPhis.
 
     // TODO(sra): Implement version of this test that works for a subgraph of
     // HPhi nodes.
     HInstruction base = null;
@@ skipping 59 matching lines @@
     // Do a simple single-block region test first.
     if (start.last is HGoto &&
         start.successors.length == 1 &&
         start.successors.single == end) {
       return 1;
     }
     // TODO(sra): Implement fuller test.
     return null;
   }
 
+  /// If [block] is an always-taken branch, move the code from the taken branch
+  /// into [block]. This has the effect of making the instructions available for
+  /// further optimizations by moving them to a position that dominates the join
+  /// point of the if-then-else.
+  // TODO(29475): Delete dead blocks instead.
+  void evacuateTakenBranch(HBasicBlock block) {
+    if (!block.isLive) return;
+    HControlFlow branch = block.last;
+    if (branch is HIf) {
+      if (branch.thenBlock.isLive == branch.elseBlock.isLive) return;
+      assert(branch.condition.isConstant());
+      HBasicBlock target =
+          branch.thenBlock.isLive ? branch.thenBlock : branch.elseBlock;
+      HInstruction instruction = target.first;
+      while (!instruction.isControlFlow()) {
+        HInstruction next = instruction.next;
+        if (instruction is HTypeKnown && instruction.isPinned) break;
+        instruction.block.detach(instruction);
+        block.moveAtExit(instruction);
+        instruction = next;
+      }
+    }
+  }
+
   void cleanPhis() {
     L:
     for (HBasicBlock block in _graph.blocks) {
       List<HBasicBlock> predecessors = block.predecessors;
       // Zap all inputs to phis that correspond to dead blocks.
       block.forEachPhi((HPhi phi) {
         for (int i = 0; i < phi.inputs.length; ++i) {
           if (!predecessors[i].isLive && phi.inputs[i] != zapInstruction) {
             replaceInput(i, phi, zapInstruction);
           }
@@ skipping 1236 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }