Use deopt on some instructions that have not collected type feedback when optimizing compierl kic...

runtime/vm/opt_code_generator_ia32.cc

 // Copyright (c) 2011, 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.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/opt_code_generator.h"
 
 #include "vm/assembler_macros.h"
@@ skipping 320 matching lines @@
     result->Add(&cls);
   }
   return result;
 }
 
 
 // Debugging helper function.
 void OptimizingCodeGenerator::PrintCollectedClassesAtId(AstNode* node,
                                                         intptr_t id) {
   const ICData& ic_data = node->ICDataAtId(id);
+  OS::Print("Collected classes id %d num: %d\n", id, ic_data.NumberOfChecks());
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     Function& target = Function::Handle();
     GrowableArray<const Class*> classes;
     ic_data.GetCheckAt(i, &classes, &target);
     OS::Print("[");
     for (intptr_t c = 0; c < classes.length(); c++) {
       OS::Print("%s%s", (c > 0) ? ", " : "", classes[c]->ToCString());
     }
     OS::Print("] -> %s\n", target.ToFullyQualifiedCString());
   }
@@ skipping 315 matching lines @@
     return false;
   }
   Class& target_cls = Class::Handle();
   Function& target = Function::Handle();
   ic_data.GetOneClassCheckAt(0, &target_cls, &target);
   return target_cls.raw() == cls.raw();
 }
 
 
 
-// Implement with slow case so that it can work both with Smi and Mint types.
+// SHL: Implement with slow case so that it works both with Smi and Mint types.
+// Result is in EAX. Mangles ECX, EBX, EDX.
 void OptimizingCodeGenerator::GenerateSmiShiftBinaryOp(BinaryOpNode* node) {
+  if (node->kind() == Token::kSAR) {
+    // TODO(srdjan): Implement for Mint?
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, EAX, ECX, kDeoptSAR);
+    // EAX: value to shift, ECX: amount to shift.
+    VisitLoadTwo(node->left(), node->right(), EAX, ECX);
+    // Check if both Smi.
+    __ movl(EBX, EAX);
+    __ orl(EBX, ECX);
+    __ testl(EBX, Immediate(kSmiTagMask));
+    __ j(NOT_ZERO, deopt_blob->label());
+    Immediate count_limit = Immediate(0x1F);
+    __ SmiUntag(ECX);
+    __ cmpl(ECX, count_limit);
+    Label shift_count_ok;
+    __ j(LESS_EQUAL, &shift_count_ok, Assembler::kNearJump);
+    __ movl(ECX, count_limit);
+    __ Bind(&shift_count_ok);
+    // Shift amount must be in ECX.
+    __ SmiUntag(EAX);  // Value.
+    __ sarl(EAX, ECX);
+    __ SmiTag(EAX);
+    return;
+  }
   ASSERT(node->kind() == Token::kSHL);
   Label done;
   bool shift_generated = false;
   if (node->right()->IsLiteralNode() &&
       node->right()->AsLiteralNode()->literal().IsSmi()) {
     // Shift count is a Smi literal.
     Smi& smi = Smi::Handle();
     smi ^= node->right()->AsLiteralNode()->literal().raw();
     if (smi.Value() < Smi::kBits) {
       Label slow_case;
@@ skipping 190 matching lines @@
         // Check the corner case of dividing the 'MIN_SMI' with -1, in which
         // case we cannot tag the result.
         __ cmpl(EAX, Immediate(0x40000000));
         __ j(EQUAL, overflow_label);
         __ SmiTag(EAX);
         break;
       }
       default:
         UNREACHABLE();
     }
-  } else if (kind == Token::kSHL) {
+  } else if ((kind == Token::kSHL) || (kind == Token::kSAR)) {
     GenerateSmiShiftBinaryOp(node);
   } else {
+    // Unhandled node kind.
     TraceNotOpt(node, kOptMessage);
     node->left()->Visit(this);
     node->right()->Visit(this);
     CodeGenerator::GenerateBinaryOperatorCall(node->id(),
                                               node->token_index(),
                                               node->Name());
   }
   __ Bind(&done);
   if (CodeGenerator::IsResultNeeded(node)) {
     if (IsResultInEaxRequested(node)) {
@@ skipping 303 matching lines @@
     GenerateMintBinaryOp(node, false);
     return;
   }
 
   if (NodeHasBothReceiverClasses(node,
       smi_class_, Class::Handle(object_store->mint_class()))) {
     GenerateMintBinaryOp(node, true);
     return;
   }
 
+  // TODO(srdjan): Handle "+" for strings.
   // Type feedback tells this is not a Smi or Double operation.
   TraceNotOpt(node,
       "BinaryOp: type feedback tells this is not a Smi or Double op");
   CodeGenerator::VisitBinaryOpNode(node);
   return;
 }
 
 
 void OptimizingCodeGenerator::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   if (FLAG_enable_type_checks) {
     classes_for_locals_->SetLocalType(node->local(), Class::ZoneHandle());
     CodeGenerator::VisitIncrOpLocalNode(node);
     return;
   }
+  const ICData& ic_data = node->ICDataAtId(node->id());
+  if (ic_data.NumberOfChecks() == 0) {
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, kDeoptNoTypeFeedback);
+    __ jmp(deopt_blob->label());
+    return;
+  }
   const char* kOptMessage = "Inlines IncrOpLocal";
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   if (!AtIdNodeHasReceiverClass(node, node->id(), smi_class_)) {
     classes_for_locals_->SetLocalType(node->local(), Class::ZoneHandle());
     TraceNotOpt(node, kOptMessage);
     CodeGenerator::VisitIncrOpLocalNode(node);
     return;
   }
   TraceOpt(node, kOptMessage);
 
@@ skipping 1019 matching lines @@
 void OptimizingCodeGenerator::VisitStoreIndexedNode(StoreIndexedNode* node) {
   if (FLAG_enable_type_checks) {
     CodeGenerator::VisitStoreIndexedNode(node);
     return;
   }
   node->array()->Visit(this);
   // TODO(srdjan): Use VisitLoadTwo and check if index is smi (CodeGenInfo).
   ObjectStore* object_store = Isolate::Current()->object_store();
   const Class& object_array_class =
       Class::ZoneHandle(object_store->array_class());
+  const ICData& ic_data = node->ICDataAtId(node->id());
+  if (ic_data.NumberOfChecks() == 0) {
+    VisitLoadTwo(node->index_expr(), node->value(), EBX, ECX);
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, EBX, ECX, kDeoptNoTypeFeedback);
+    __ jmp(deopt_blob->label());
+    return;
+  }
   if (AtIdNodeHasOnlyClass(node, node->id(), object_array_class)) {
     VisitLoadTwo(node->index_expr(), node->value(), EBX, ECX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EAX, EBX, ECX, kDeoptStoreIndexed);
     __ popl(EAX);  // array.
     // ECX: value, EBX:index, EAX: array.
     // Check type of array.
     __ testl(EAX, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());  // Array is smi -> deopt.
     __ movl(EDX, FieldAddress(EAX, Object::class_offset()));
@@ skipping 513 matching lines @@
 void OptimizingCodeGenerator::VisitTryCatchNode(TryCatchNode* node) {
   // TODO(srdjan): Set classes for locals.
   classes_for_locals_->Clear();
   CodeGenerator::VisitTryCatchNode(node);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32