Only emit typeguards if we think they are valuable.

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 93 matching lines @@
 
     HInstruction instruction = block.first;
     while (instruction !== null) {
       // Note that visitInstruction (from the phis and here) might insert an
       // HTypeGuard instruction. We have to skip those.
       if (instruction is !HTypeGuard) visitInstruction(instruction);
       instruction = instruction.next;
     }
   }
 
+  bool typeGuardWouldBeValuable(HInstruction instruction,
+                                HType speculativeType) {
+    bool isMoreNested(HBasicBlock loopHeader1, HBasicBlock loopHeader2) {

[kasperl, 2012/04/20 12:07:31]

isNestedInside? You're checking if loop1 is inside loop2 right? Maybe call one
outer (loop2) and one inner (loop1)?

[floitsch, 2012/04/20 12:43:47]

Done.

+      if (loopHeader1 == loopHeader2) return false;

[kasperl, 2012/04/20 12:07:31]

Is this a place where === makes sense?

[floitsch, 2012/04/20 12:43:47]

Done.

+      if (loopHeader2 == null) return true;
+      while (loopHeader1 != null) {
+        if (loopHeader1 == loopHeader2) return true;
+        loopHeader1 = loopHeader1.parentLoopHeader;
+      }
+      return false;
+    }
+
+    // If the instruction is not in a loop then the header will be null.
+    HBasicBlock currentLoopHeader = instruction.block.getEnclosingLoopHeader();
+    for (HInstruction user in instruction.usedBy) {
+      HBasicBlock userLoopHeader = user.block.getEnclosingLoopHeader();
+      if (isMoreNested(userLoopHeader, currentLoopHeader)) return true;
+    }
+    return false;
+  }
+
   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;
 
     if (!speculativeType.isUseful()) return false;
     // If the types agree we don't need to check.
     if (speculativeType == computedType) return false;
-    // TODO(floitsch): Make the creation of type guards more conditional.
-    return true;
+    // 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)) {
       List<HInstruction> inputs = <HInstruction>[instruction];
       HTypeGuard guard = new HTypeGuard(speculativeType, stateId++, inputs);
       guard.propagatedType = speculativeType;
       work.guards.add(guard);
       instruction.block.rewrite(instruction, guard);
@@ skipping 283 matching lines @@
     compiler.internalError('Control flow instructions already dealt with.',
                            instruction: instruction);
   }
 
   visitTypeGuard(HTypeGuard guard) {
     blocks.forEach((HBasicBlock block) {
       block.guards.add(guard);
     });
   }
 }