dart2js: Insert HTypeKnown refinement nodes on dominated edges of HPhi nodes.

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 34 matching lines @@
         super(backend.compiler.measurer);
 
   String get name => 'SSA optimizer';
 
   Compiler get compiler => backend.compiler;
 
   void optimize(CodegenWorkItem work, HGraph graph, ClosedWorld closedWorld) {
     void runPhase(OptimizationPhase phase) {
       measureSubtask(phase.name, () => phase.visitGraph(graph));
       backend.tracer.traceGraph(phase.name, graph);
-      assert(graph.isValid());
+      assert(graph.isValid(), 'Graph not valid after ${phase.name}');
     }
 
     bool trustPrimitives = compiler.options.trustPrimitives;
     CodegenRegistry registry = work.registry;
     Set<HInstruction> boundsChecked = new Set<HInstruction>();
     SsaCodeMotion codeMotion;
     measure(() {
       List<OptimizationPhase> phases = <OptimizationPhase>[
         // Run trivial instruction simplification first to optimize
         // some patterns useful for type conversion.
@@ skipping 638 matching lines @@
     return null;
   }
 
   HInstruction visitIdentity(HIdentity node) {
     HInstruction newInstruction = handleIdentityCheck(node);
     return newInstruction == null ? super.visitIdentity(node) : newInstruction;
   }
 
   void simplifyCondition(
       HBasicBlock block, HInstruction condition, bool value) {
-    condition.dominatedUsers(block.first).forEach((user) {
-      HInstruction newCondition = graph.addConstantBool(value, closedWorld);
-      user.changeUse(condition, newCondition);
-    });
+    // `excludePhiOutEdges: true` prevents replacing a partially dominated phi
+    // node input with a constant. This tends to add unnecessary assignments, by
+    // transforming the following, which has phi(false, x),
+    //
+    //    if (x) { init(); x = false; }
+    //
+    // into this, which has phi(false, false)
+    //
+    //    if (x) { init(); x = false; } else { x = false; }
+    //
+    // which is further simplifed to:
+    //
+    //    if (x) { init(); }
+    //    ...
+    //    x = false;
+    //
+    // This is mostly harmless (if a little confusing) but does cause a lot of
+    // `x = false;` copies to be inserted when a loop body has many continue
+    // statements or ends with a switch.

[Emily Fortuna, 2017/04/03 20:48:46]

👏👏👏 (that's a hand clapping emoji in case it's not clear)

+    var uses =
+        DominatedUses.of(condition, block.first, excludePhiOutEdges: true);
+    if (uses.isEmpty) return;
+    uses.replaceWith(graph.addConstantBool(value, closedWorld));
   }
 
   HInstruction visitIf(HIf node) {
     HInstruction condition = node.condition;
     if (condition.isConstant()) return node;
     bool isNegated = condition is HNot;
 
     if (isNegated) {
       condition = condition.inputs[0];
     } else {
@@ skipping 863 matching lines @@
       // Find the index of the single live predecessor if it exists.
       int indexOfLive = -1;
       for (int i = 0; i < predecessors.length; i++) {
         if (predecessors[i].isLive) {
           if (indexOfLive >= 0) continue L;
           indexOfLive = i;
         }
       }
       // Run through the phis of the block and replace them with their input
       // that comes from the only live predecessor if that dominates the phi.
+      //
+      // TODO(sra): If the input is directly in the only live predecessor, it
+      // might be possible to move it into [block] (e.g. all its inputs are
+      // dominating.)
       block.forEachPhi((HPhi phi) {
         HInstruction replacement =
             (indexOfLive >= 0) ? phi.inputs[indexOfLive] : zapInstruction;
         if (replacement.dominates(phi)) {
           block.rewrite(phi, replacement);
           block.removePhi(phi);
         }
       });
     }
   }
@@ skipping 528 matching lines @@
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   // Update users of [input] that are dominated by [:dominator.first:]
   // to use [TypeKnown] of [input] instead. As the type information depends
   // on the control flow, we mark the inserted [HTypeKnown] nodes as
   // non-movable.
   void insertTypePropagationForDominatedUsers(
       HBasicBlock dominator, HInstruction input, TypeMask convertedType) {
-    Setlet<HInstruction> dominatedUsers = input.dominatedUsers(dominator.first);
-    if (dominatedUsers.isEmpty) return;
+    DominatedUses dominatedUses = DominatedUses.of(input, dominator.first);
+    if (dominatedUses.isEmpty) return;
 
     HTypeKnown newInput = new HTypeKnown.pinned(convertedType, input);
     dominator.addBefore(dominator.first, newInput);
-    dominatedUsers.forEach((HInstruction user) {
-      user.changeUse(input, newInput);
-    });
+    dominatedUses.replaceWith(newInput);
   }
 
   void visitIs(HIs instruction) {
     ResolutionDartType type = instruction.typeExpression;
     if (!instruction.isRawCheck) {
       return;
     } else if (type.isTypedef) {
       return;
     }
     ResolutionInterfaceType interfaceType = type;
@@ skipping 621 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }