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:] of the work item 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 JavaScriptWorkItem work;
   bool calledInLoop = false;
   bool isRecursiveMethod = false;
   int stateId = 1;
 
   SsaTypeGuardInserter(this.compiler, this.work);
 
   void visitGraph(HGraph graph) {
     isRecursiveMethod = graph.isRecursiveMethod;
     calledInLoop = graph.calledInLoop;
     work.guards = <HTypeGuard>[];
@@ skipping 51 matching lines @@
       return false;
     }
 
     // If the instruction is not in a loop then the header will be null.
     HBasicBlock currentLoopHeader = instruction.block.enclosingLoopHeader;
     for (HInstruction user in instruction.usedBy) {
       HBasicBlock userLoopHeader = user.block.enclosingLoopHeader;
       if (isNested(userLoopHeader, currentLoopHeader)) return true;
     }
 
+    HTypeMap types = work.types;
     // 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)) {
+    HTypeMap types = work.types;
+    HType speculativeType = types[instruction];
+    HType computedType = instruction.computeTypeFromInputTypes(types);
+    // Start by reverting the propagated type. If we add a type guard then the

[Lasse Reichstein Nielsen, 2012/08/08 07:44:53]

How do you revert a type?
"propagated" isn't mentioned later, so what is its relevance here?

[floitsch, 2012/08/08 19:18:37]

Done.

+    // 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.

[Lasse Reichstein Nielsen, 2012/08/08 07:44:53]

"avoids ... to use" -> "avoids ... using"
"the the" -> "the"

[floitsch, 2012/08/08 19:18:37]

reworded.

+    //
+    // 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);
       });
     }
   }
 }