Move types out of the HInstructions.

lib/compiler/implementation/ssa/bailout.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.
 
 class BailoutInfo {
   int instructionId;
   int bailoutId;
   BailoutInfo(this.instructionId, this.bailoutId);
 }
 
@@ skipping 49 matching lines @@
   }
 
   bool isEmpty() => lives.isEmpty() && loopMarkers.isEmpty();
 }
 
 
 /**
  * Visits the graph in dominator order and inserts TypeGuards in places where
  * we consider the guard to be of value.
  *
- * Might modify the [:propagatedType:] fields of the instructions in an
- * inconsistent way. No further analysis should rely on them.
+ * Might modify the [types] in an inconsistent way. No further analysis should
+ * rely on them.
  */
 class SsaTypeGuardInserter extends HGraphVisitor implements OptimizationPhase {
   final Compiler compiler;
   final String name = 'SsaTypeGuardInserter';
   final WorkItem work;
+  final HTypeMap types;
   bool calledInLoop = false;
   bool isRecursiveMethod = false;
   int stateId = 1;
 
-  SsaTypeGuardInserter(this.compiler, this.work);
+  SsaTypeGuardInserter(this.compiler, this.work, this.types);
 
   void visitGraph(HGraph graph) {
     isRecursiveMethod = graph.isRecursiveMethod;
     calledInLoop = graph.calledInLoop;
     work.guards = <HTypeGuard>[];
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     block.forEachPhi(visitInstruction);
@@ skipping 54 matching lines @@
     }
 
     // To speed up computations on values loaded from arrays, we
     // insert type guards for builtin array indexing operations in
     // nested loops. Since this can blow up code size quite
     // significantly, we only do it if type guards have already been
     // inserted for this method. The code size price for an additional
     // type guard is much smaller than the first one that causes the
     // generation of a bailout method.
     if (instruction is HIndex &&
-        (instruction as HIndex).builtin &&
+        (instruction as HIndex).isBuiltin(types) &&
         hasTypeGuards) {
       HBasicBlock loopHeader = instruction.block.enclosingLoopHeader;
       if (loopHeader != null && loopHeader.parentLoopHeader != null) {
         return true;
       }
     }
 
     // Insert type guards if the method is likely to be called in a
     // loop.
     return calledInLoop;
   }
 
-  bool shouldInsertTypeGuard(HInstruction instruction) {
-    HType speculativeType = instruction.propagatedType;
-    HType computedType = instruction.computeTypeFromInputTypes();
-    // Start by reverting the propagated type. If we add a type guard then the
-    // guard will expose the speculative type. If we don't add a type guard
-    // then this avoids subsequent instructions to use the the wrong type.
-    //
-    // Note that just setting the propagatedType of the instruction is not
-    // complete since the type could lead to a phi node which in turn could
-    // change the computedType. In this case we might miss some guards we
-    // would have liked to insert. Most of the time this should however be
-    // fine, due to dominator-order visiting.
-    instruction.propagatedType = computedType;
-
+  bool shouldInsertTypeGuard(HInstruction instruction,
+                             HType speculativeType,
+                             HType computedType) {
     if (!speculativeType.isUseful()) return false;
     // If the types agree we don't need to check.
     if (speculativeType == computedType) return false;
     // If a bailout check is more expensive than doing the actual operation
     // don't do it either.
     return typeGuardWouldBeValuable(instruction, speculativeType);
   }
 
   void visitInstruction(HInstruction instruction) {
-    HType speculativeType = instruction.propagatedType;
-    if (shouldInsertTypeGuard(instruction)) {
+    HType speculativeType = types[instruction];
+    HType computedType = instruction.computeTypeFromInputTypes(types);
+    // Currently the type in [types] is the speculative type each instruction
+    // would like to have. We start by recomputing the type non-speculatively.
+    // If we add a type guard then the guard will expose the speculative type.
+    // If we don't add a type guard then this avoids that subsequent
+    // instructions use the wrong (speculative) type.
+    //
+    // Note that just setting the speculative type of the instruction is not
+    // complete since the type could lead to a phi node which in turn could
+    // change the speculative type. In this case we might miss some guards we
+    // would have liked to insert. Most of the time this should however be
+    // fine, due to dominator-order visiting.
+    types[instruction] = computedType;
+
+    if (shouldInsertTypeGuard(instruction, speculativeType, computedType)) {
       HInstruction insertionPoint;
       if (instruction is HPhi) {
         insertionPoint = instruction.block.first;
       } else if (instruction is HParameterValue) {
         // We insert the type guard at the end of the entry block
         // because if a parameter is live, it must be kept in the live
         // environment. Not doing so would mean we could visit a
         // parameter and remove it from the environment before
         // visiting a type guard.
         insertionPoint = instruction.block.last;
       } else {
         insertionPoint = instruction.next;
       }
       // If the previous instruction is also a type guard, then both
       // guards have the same environment, and can therefore share the
       // same state id.
       HBailoutTarget target;
       int state;
       if (insertionPoint.previous is HTypeGuard) {
         HTypeGuard other = insertionPoint.previous;
         target = other.bailoutTarget;
       } else {
         state = stateId++;
         target = new HBailoutTarget(state);
         insertionPoint.block.addBefore(insertionPoint, target);
       }
       HTypeGuard guard = new HTypeGuard(speculativeType, instruction, target);
-      guard.propagatedType = speculativeType;
+      types[guard] = speculativeType;
       work.guards.add(guard);
       instruction.block.rewrite(instruction, guard);
       insertionPoint.block.addBefore(insertionPoint, guard);
     }
   }
 }
 
 /**
  * Computes the environment for each SSA instruction: visits the graph
  * in post-dominator order. Removes an instruction from the environment
@@ skipping 291 matching lines @@
         hasComplexBailoutTargets = true;
       }
     } else {
       hasComplexBailoutTargets = true;
       blocks.forEach((HBasicBlock block) {
         block.bailoutTargets.add(target);
       });
     }
   }
 }