Prevent hoisting of certain check nodes, including [HTypeKnown].

sdk/lib/_internal/compiler/implementation/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.
 
 part of ssa;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 1225 matching lines @@
       return instruction is HGoto
           || instruction.inputs[0].isConstantTrue();
     }
     bool firstInstructionInLoop = block == loopHeader
         // Compensate for lack of code motion.
         || (blockChangesFlags[loopHeader.id] == 0
             && isLoopAlwaysTaken()
             && loopHeader.successors[0] == block);
     while (instruction != null) {
       HInstruction next = instruction.next;
-      if (instruction.useGvn()
+      if (instruction.useGvn() && instruction.isMovable
           && (!instruction.canThrow() || firstInstructionInLoop)
           && !instruction.sideEffects.dependsOn(dependsFlags)) {
         bool loopInvariantInputs = true;
         List<HInstruction> inputs = instruction.inputs;
         for (int i = 0, length = inputs.length; i < length; i++) {
           if (isInputDefinedAfterDominator(inputs[i], preheader)) {
             loopInvariantInputs = false;
             break;
           }
         }
@@ skipping 201 matching lines @@
     // which instructions can be moved to a dominator block.
     ValueSet set_ = values[block.id];
     HInstruction instruction = block.first;
     int flags = 0;
     while (instruction != null) {
       int dependsFlags = SideEffects.computeDependsOnFlags(flags);
       flags |= instruction.sideEffects.getChangesFlags();
 
       HInstruction current = instruction;
       instruction = instruction.next;
-
-      // TODO(ngeoffray): this check is needed because we currently do
-      // not have flags to express 'Gvn'able', but not movable.
-      if (current is HCheck) continue;
-      if (!current.useGvn()) continue;
+      if (!current.useGvn() || !current.isMovable) continue;
       if (current.sideEffects.dependsOn(dependsFlags)) continue;
 
       bool canBeMoved = true;
       for (final HInstruction input in current.inputs) {
         if (input.block == block) {
           canBeMoved = false;
           break;
         }
       }
       if (!canBeMoved) continue;
@@ skipping 14 matching lines @@
   final String name = "SsaTypeconversionInserter";
   final Compiler compiler;
 
   SsaTypeConversionInserter(this.compiler);
 
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   // Update users of [input] that are dominated by [:dominator.first:]
-  // to use [newInput] instead.
+  // to use [newInput] instead. As the type information depends on the
+  // control flow, we mark the inserted [HTypeKnown] nodes as non-movable.
   void changeUsesDominatedBy(HBasicBlock dominator,

[floitsch, 2014/03/20 16:07:25]

Nit: we should change the name. It's not just changing the users. It's also
inserting an HTypeKnown node.

[herhut, 2014/03/20 16:25:11]

It is now called [insertTypePropagationForDominatedUsers]

Done.

                              HInstruction input,
                              TypeMask convertedType) {
     Setlet<HInstruction> dominatedUsers = input.dominatedUsers(dominator.first);
     if (dominatedUsers.isEmpty) return;
 
-    HTypeKnown newInput = new HTypeKnown(convertedType, input);
+    HTypeKnown newInput = new HTypeKnown.pinned(convertedType, input);
     dominator.addBefore(dominator.first, newInput);
     dominatedUsers.forEach((HInstruction user) {
       user.changeUse(input, newInput);
     });
   }
 
   void visitIs(HIs instruction) {
     DartType type = instruction.typeExpression;
     Element element = type.element;
     if (!instruction.isRawCheck) {
@@ skipping 506 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }