Reapply "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 isNested(HBasicBlock inner, HBasicBlock outer) {
+      if (inner === outer) return false;
+      if (outer === null) return true;
+      while (inner !== null) {
+        if (inner === outer) return true;
+        inner = inner.parentLoopHeader;
+      }
+      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;
+    }
+    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);
     });
   }
 }