Better tracing of deoptimization (added a reason id and printing of source). Fix a bug with exces...

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 97 matching lines @@
   GrowableArray<Pair> data_;
   DISALLOW_COPY_AND_ASSIGN(CodeGenInfo);
 };
 
 
 // Code that calls the deoptimizer, emitted as deferred code (out of line).
 // Specify the corresponding 'node' and the registers that need to
 // be pushed for the deoptimization point in unoptimized code.
 class DeoptimizationBlob : public ZoneAllocated {
  public:
-  explicit DeoptimizationBlob(AstNode* node) : node_(node), registers_(2) {}
+  DeoptimizationBlob(AstNode* node, DeoptReasonId deopt_reason_id)
+      : node_(node),
+        registers_(2),
+        label_(),
+        deopt_reason_id_(deopt_reason_id) {}
 
   void Push(Register reg) { registers_.Add(reg); }
 
   void Generate(OptimizingCodeGenerator* codegen) {
     codegen->assembler()->Bind(&label_);
     for (int i = 0; i < registers_.length(); i++) {
       codegen->assembler()->pushl(registers_[i]);
     }
+    codegen->assembler()->movl(EAX, Immediate(Smi::RawValue(deopt_reason_id_)));
     codegen->CallDeoptimize(node_->id(), node_->token_index());
 #if defined(DEBUG)
     // Check that deoptimization point exists in unoptimized code.
     const Code& unoptimized_code =
         Code::Handle(codegen->parsed_function().function().unoptimized_code());
     ASSERT(!unoptimized_code.IsNull());
     uword continue_at_pc =
         unoptimized_code.GetDeoptPcAtNodeId(node_->id());
     ASSERT(continue_at_pc != 0);
 #endif  // DEBUG
   }
 
   // Jump to this label to deoptimize.
   Label* label() { return &label_; }
 
  private:
   const AstNode* node_;
   GrowableArray<Register> registers_;
   Label label_;
+  DeoptReasonId deopt_reason_id_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptimizationBlob);
 };
 
 // TODO(srdjan): Add String_charCodeAt, String_hashCode.
 
 #define RECOGNIZED_LIST(V)                                                     \
   V(ObjectArray, get:length, ObjectArrayLength)                                \
   V(GrowableObjectArray, get:length, GrowableArrayLength)                      \
   V(StringBase, get:length, StringBaseLength)                                  \
@@ skipping 56 matching lines @@
           deoptimization_blobs_(4),
           smi_class_(Class::ZoneHandle(Isolate::Current()->object_store()
               ->smi_class())),
           double_class_(Class::ZoneHandle(Isolate::Current()->object_store()
               ->double_class())) {
   ASSERT(parsed_function.function().is_optimizable());
 }
 
 
 DeoptimizationBlob*
-OptimizingCodeGenerator::AddDeoptimizationBlob(AstNode* node) {
-  DeoptimizationBlob* d = new DeoptimizationBlob(node);
+OptimizingCodeGenerator::AddDeoptimizationBlob(AstNode* node,
+                                               DeoptReasonId reason_id) {
+  DeoptimizationBlob* d = new DeoptimizationBlob(node, reason_id);
   deoptimization_blobs_.Add(d);
   return d;
 }
 
 
 DeoptimizationBlob*
-OptimizingCodeGenerator::AddDeoptimizationBlob(AstNode* node, Register reg) {
-  DeoptimizationBlob* d = AddDeoptimizationBlob(node);
+OptimizingCodeGenerator::AddDeoptimizationBlob(AstNode* node,
+                                               Register reg,
+                                               DeoptReasonId reason_id) {
+  DeoptimizationBlob* d = AddDeoptimizationBlob(node, reason_id);
   d->Push(reg);
   return d;
 }
 
 
 DeoptimizationBlob*
 OptimizingCodeGenerator::AddDeoptimizationBlob(AstNode* node,
                                                Register reg1,
-                                               Register reg2) {
-  DeoptimizationBlob* d = AddDeoptimizationBlob(node);
+                                               Register reg2,
+                                               DeoptReasonId reason_id) {
+  DeoptimizationBlob* d = AddDeoptimizationBlob(node, reason_id);
   d->Push(reg1);
   d->Push(reg2);
   return d;
 }
 
 
 DeoptimizationBlob*
 OptimizingCodeGenerator::AddDeoptimizationBlob(AstNode* node,
                                                Register reg1,
                                                Register reg2,
-                                               Register reg3) {
-  DeoptimizationBlob* d = AddDeoptimizationBlob(node);
+                                               Register reg3,
+                                               DeoptReasonId reason_id) {
+  DeoptimizationBlob* d = AddDeoptimizationBlob(node, reason_id);
   d->Push(reg1);
   d->Push(reg2);
   d->Push(reg3);
   return d;
 }
 
 
 void OptimizingCodeGenerator::GenerateDeferredCode() {
   CodeGenerator::GenerateDeferredCode();
   for (int i = 0; i < deoptimization_blobs_.length(); i++) {
@@ skipping 401 matching lines @@
       (kind == Token::kBIT_AND) ||
       (kind == Token::kBIT_OR) ||
       (kind == Token::kBIT_XOR)) {
     TraceOpt(node, kOptMessage);
     CodeGenInfo left_info(node->left());
     CodeGenInfo right_info(node->right());
     VisitLoadTwo(node->left(), node->right(), EAX, EDX);
     Label* overflow_label = NULL;
     Label two_smis, call_operator;
     if (left_info.IsClass(smi_class_) || right_info.IsClass(smi_class_)) {
-      DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, ECX, EDX);
+      DeoptimizationBlob* deopt_blob =
+          AddDeoptimizationBlob(node, ECX, EDX, kDeoptSmiBinaryOp);
       overflow_label = deopt_blob->label();
       __ movl(ECX, EAX);  // Save if overflow (needs original value).
       if (!left_info.IsClass(smi_class_) || !right_info.IsClass(smi_class_)) {
         Register test_reg = left_info.IsClass(smi_class_) ? EDX : EAX;
         __ testl(test_reg, Immediate(kSmiTagMask));
         __ j(NOT_ZERO, deopt_blob->label());
       }
       if (node->info() != NULL) {
         node->info()->set_is_class(&smi_class_);
       }
@@ skipping 84 matching lines @@
 // any Mint bits above the Smi range.
 // 'allow_smi' is true if Smi and Mint classes have been encountered.
 void OptimizingCodeGenerator::GenerateMintBinaryOp(BinaryOpNode* node,
                                                    bool allow_smi) {
   const char* kOptMessage = "Inline Mint binop.";
   ObjectStore* object_store = Isolate::Current()->object_store();
   const Token::Kind kind = node->kind();
   if (kind == Token::kBIT_AND) {
     TraceOpt(node, kOptMessage);
     Label is_smi, slow_case, done;
-    DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EAX, EDX);
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, EAX, EDX, kDeoptMintBinaryOp);
     VisitLoadTwo(node->left(), node->right(), EAX, EDX);
     __ testl(EDX, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, &slow_case);  // Call operator if right is not Smi.
 
     // Test left.
     __ testl(EAX, Immediate(kSmiTagMask));
     __ j(ZERO, &is_smi);
 
     __ movl(EBX, FieldAddress(EAX, Object::class_offset()));
     __ CompareObject(EBX, Class::ZoneHandle(object_store->mint_class()));
@@ skipping 101 matching lines @@
       // Use inlined temporary double object.
       const Double& double_object =
           Double::ZoneHandle(Double::New(0.0));
       __ LoadObject(result_register, double_object);
     }
     Label is_smi, extract_left;
     DeoptimizationBlob* deopt_blob = NULL;
     Label* deopt_lbl = NULL;
     if (!left_info.IsClass(double_class_) ||
         !right_info.IsClass(double_class_)) {
-      deopt_blob = AddDeoptimizationBlob(node, kLeftRegister, kRightRegister);
+      deopt_blob = AddDeoptimizationBlob(node,
+                                         kLeftRegister,
+                                         kRightRegister,
+                                         kDeoptDoubleBinaryOp);
       deopt_lbl = deopt_blob->label();
     }
 
     bool nodes_of_same_type = AreNodesOfSameType(node->left(), node->right());
     if (!left_info.IsClass(double_class_)) {
       CheckIfDoubleOrSmi(kLeftRegister, kTempRegister, deopt_lbl, deopt_lbl);
       // Fall through for double. Jump to 'deopt' if not double.
     }
     if (!right_info.IsClass(double_class_) && !nodes_of_same_type) {
       CheckIfDoubleOrSmi(kRightRegister, kTempRegister, &is_smi, deopt_lbl);
@@ skipping 177 matching lines @@
   TraceOpt(node, kOptMessage);
 
   GenerateLoadVariable(EAX, node->local());
   if (!node->prefix() && IsResultNeeded(node)) {
     // Preserve as result.
     __ movl(ECX, EAX);
   }
   const int int_value = (node->kind() == Token::kINCR) ? 1 : -1;
   const Immediate smi_value =
       Immediate(reinterpret_cast<int32_t>(Smi::New(int_value)));
-  DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node);
+  DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, kDeoptIncrLocal);
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt_blob->label());
   __ addl(EAX, smi_value);
   __ j(OVERFLOW, deopt_blob->label());
   GenerateStoreVariable(node->local(), EAX, EDX);
   if (IsResultNeeded(node)) {
     if (node->info() != NULL) {
       node->info()->set_is_class(&smi_class_);
     }
     if (node->prefix()) {
@@ skipping 42 matching lines @@
 
 void OptimizingCodeGenerator::VisitIncrOpInstanceFieldNode(
     IncrOpInstanceFieldNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   VisitLoadOne(node->receiver(), EBX);
   __ pushl(EBX);  // Duplicate receiver (preserve for setter).
   const ICData& ic_data = node->ICDataAtId(node->id());
   if (ic_data.NumberOfChecks() == 0) {
     // Deoptimization point for this node is after receiver has been
     // pushed twice on stack and before the getter (above) was executed.
-    DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EBX);
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, EBX, kDeoptIncrInstance);
     __ jmp(deopt_blob->label());
     return;
   }
   InlineInstanceGetter(node,
                        node->getter_id(),
                        node->receiver(),
                        node->field_name(),
                        EBX);
   // result is in EAX.
   __ popl(EDX);   // Get receiver.
   const bool return_original_value = !node->prefix() && IsResultNeeded(node);
   const Immediate one_value = Immediate(Smi::RawValue(1));
   // EAX: Value.
   // EDX: Receiver.
   if (AtIdNodeHasOnlyClass(node, node->operator_id(), smi_class_)) {
     // Deoptimization point for this node is after receiver has been
     // pushed twice on stack and before the getter (above) was executed.
-    DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EDX, EDX);
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, EDX, EDX, kDeoptIncrInstanceOneClass);
     if (return_original_value) {
       // Preserve pre increment result.
       __ movl(ECX, EAX);
     }
     __ testl(EAX, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt_blob->label());
     if (node->kind() == Token::kINCR) {
       __ addl(EAX, one_value);
     } else {
       __ subl(EAX, one_value);
@@ skipping 89 matching lines @@
 void OptimizingCodeGenerator::InlineInstanceGettersWithSameTarget(
     AstNode* node,
     intptr_t id,
     AstNode* receiver,
     const String& field_name,
     Register recv_reg) {
   if (recv_reg != EBX) {
     // TODO(srdjan): Do not hardwire register.
     UNIMPLEMENTED();
   }
-  DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EBX);
+  DeoptimizationBlob* deopt_blob =
+      AddDeoptimizationBlob(node, EBX, kDeoptInstanceGetterSameTarget);
   if (NodeMayBeSmi(receiver)) {
     __ testl(EBX, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());
   }
 
   __ movl(EAX, FieldAddress(EBX, Object::class_offset()));
   const ICData& ic_data = node->ICDataAtId(id);
   Function& target = Function::Handle();
   Label load_field;
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
@@ skipping 120 matching lines @@
 
 
 // TODO(srdjan): Implement for multiple getter targets.
 // For every class inline its implicit getter, or call the instance getter.
 void OptimizingCodeGenerator::VisitInstanceGetterNode(
     InstanceGetterNode* node) {
   const ICData& ic_data = node->ICDataAtId(node->id());
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     node->receiver()->Visit(this);
-    DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node);
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, kDeoptInstanceGetter);
     __ jmp(deopt_blob->label());
     return;
   }
 
   VisitLoadOne(node->receiver(), EBX);
   InlineInstanceGetter(node,
                        node->id(),
                        node->receiver(),
                        node->field_name(),
                        EBX);
   // Result is in EAX.
   if (CodeGenerator::IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 // Clobber EBX leave 'value_reg' untouched.
 void OptimizingCodeGenerator::InlineInstanceSettersWithSameTarget(
     AstNode* node,
     intptr_t id,
     AstNode* receiver,
     const String& field_name,
     Register recv_reg,
     Register value_reg) {
   ASSERT((recv_reg != EBX) && (value_reg != EBX));
-  DeoptimizationBlob* deopt_blob =
-      AddDeoptimizationBlob(node, recv_reg, value_reg);
+  DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(
+      node, recv_reg, value_reg, kDeoptInstanceSetterSameTarget);
   if (NodeMayBeSmi(receiver)) {
     __ testl(recv_reg, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());
   }
   __ movl(EBX, FieldAddress(recv_reg, Object::class_offset()));
   const ICData& ic_data = node->ICDataAtId(id);
   Function& target = Function::Handle();
   Label store_field;
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     Class& cls = Class::ZoneHandle();
@@ skipping 42 matching lines @@
     InstanceSetterNode* node) {
   // TODO(srdjan): inline setters to different targets as well.
   if (FLAG_enable_type_checks ||
       !ICDataToSameInlineableInstanceSetter(node->ICDataAtId(node->id()))) {
     CodeGenerator::VisitInstanceSetterNode(node);
     return;
   }
   VisitLoadTwo(node->receiver(), node->value(), EDX, EAX);
   const ICData& ic_data = node->ICDataAtId(node->id());
   if (ic_data.NumberOfChecks() == 0) {
-    DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EDX, EAX);
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, EDX, EAX, kDeoptInstanceSetter);
     __ jmp(deopt_blob->label());
     return;
   }
   // Value in EAX survives and will be stored on stack if result is needed.
   InlineInstanceSetter(node,
                        node->id(),
                        node->receiver(),
                        node->field_name(),
                        EDX,
                        EAX);
@@ skipping 79 matching lines @@
   CodeGenInfo left_info(node->left());
   CodeGenInfo right_info(node->right());
   VisitLoadTwo(node->left(), node->right(), EAX, EDX);
   if (!CodeGenerator::IsResultNeeded(node)) {
     return;
   }
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label evaluate_comparison;
   if (!left_info.IsClass(smi_class_)) {
-    DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EAX, EDX);
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, EAX, EDX, kDeoptSmiEquality);
     Label left_not_null;
     __ cmpl(EAX, raw_null);
     __ j(NOT_EQUAL, &left_not_null, Assembler::kNearJump);
 
     // Left is null, strict compare.
     __ cmpl(EAX, EDX);
     __ jmp(&evaluate_comparison, Assembler::kNearJump);
 
     // Deoptimize if left is not Smi.
     __ Bind(&left_not_null);
@@ skipping 71 matching lines @@
   CodeGenInfo left_info(node->left());
   CodeGenInfo right_info(node->right());
   VisitLoadTwo(node->left(), node->right(), EAX, EDX);
   if (!CodeGenerator::IsResultNeeded(node)) {
     return true;
   }
   if (left_info.IsClass(smi_class_) && right_info.IsClass(smi_class_)) {
     __ cmpl(EAX, EDX);
   } else if (left_info.IsClass(smi_class_) || right_info.IsClass(smi_class_)) {
     // One is Smi.
-    DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EAX, EDX);
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, EAX, EDX, kDeoptSmiCompareSmis);
     Register reg_to_test = left_info.IsClass(smi_class_) ? EDX : EAX;
     __ testl(reg_to_test, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt_blob->label());
     __ cmpl(EAX, EDX);
   } else {
-    DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, ECX, EDX);
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, ECX, EDX, kDeoptSmiCompareAny);
     __ movl(ECX, EAX);
     __ orl(EAX, EDX);
     __ testl(EAX, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt_blob->label());
     __ cmpl(ECX, EDX);
   }
   if (NodeInfoHasLabels(node)) {
     GenerateConditionalJumps(*(node->info()), condition);
     node->info()->set_labels_used(true);
   } else {
@@ skipping 73 matching lines @@
       TraceNotOpt(node, "Equality comparison, mixed with Smi");
       return false;
     }
   }
 
   // All targets are Object.==, i.e., '==='. Smi is not among the classes.
   VisitLoadTwo(node->left(), node->right(), EAX, EDX);
   if (!CodeGenerator::IsResultNeeded(node)) {
     return true;
   }
-  DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EAX, EDX);
   Label compare;
   // Comparison with NULL is "===".
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ cmpl(EAX, raw_null);
   if (num_classes == 0) {
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, EAX, EDX, kDeoptEqualityNoFeedback);
     __ j(NOT_EQUAL, deopt_blob->label());
   } else {
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, EAX, EDX, kDeoptEqualityClassCheck);
     __ j(EQUAL, &compare);
     // Smi causes deoptimization.
     __ testl(EAX, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());
     __ movl(EBX, FieldAddress(EAX, Object::class_offset()));
     for (intptr_t i = 0; i < num_classes; i++) {
       const Class& cls = *(*classes)[i];
       __ CompareObject(EBX, cls);
       if (i == (num_classes - 1)) {
         __ j(NOT_EQUAL, deopt_blob->label());
@@ skipping 35 matching lines @@
   if (!SupportedTokenKindToDoubleCondition(node->kind(), &true_condition)) {
     return false;
   }
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   CodeGenInfo left_info(node->left());
   CodeGenInfo right_info(node->right());
   VisitLoadTwo(node->left(), node->right(), EAX, EDX);
   DeoptimizationBlob* deopt_blob = NULL;
   if (!left_info.IsClass(double_class_) || !right_info.IsClass(double_class_)) {
-    deopt_blob = AddDeoptimizationBlob(node, EAX, EDX);
+    deopt_blob = AddDeoptimizationBlob(node, EAX, EDX, kDeoptDoubleComparison);
   }
   if (!left_info.IsClass(double_class_)) {
     CheckIfDoubleOrSmi(EAX, EBX, deopt_blob->label(), deopt_blob->label());
   }
   if (!right_info.IsClass(double_class_)) {
     CheckIfDoubleOrSmi(EDX, EBX, deopt_blob->label(), deopt_blob->label());
   }
   __ movsd(XMM0, FieldAddress(EAX, Double::value_offset()));
   __ movsd(XMM1, FieldAddress(EDX, Double::value_offset()));
   __ comisd(XMM0, XMM1);
@@ skipping 80 matching lines @@
 void OptimizingCodeGenerator::VisitLoadIndexedNode(LoadIndexedNode* node) {
   const char* kMessage = "Inline indexed access";
   ObjectStore* object_store = Isolate::Current()->object_store();
   const Class& object_array_class =
       Class::ZoneHandle(object_store->array_class());
   const Class& immutable_object_array_class =
       Class::ZoneHandle(object_store->immutable_array_class());
   if (AtIdNodeHasOnlyClass(node, node->id(), object_array_class) ||
       AtIdNodeHasOnlyClass(node, node->id(), immutable_object_array_class)) {
     VisitLoadTwo(node->array(), node->index_expr(), EBX, EDX);
-    DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EBX, EDX);
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, EBX, EDX, kDeoptLoadIndexedFixedArray);
     const Class& test_class =
         AtIdNodeHasOnlyClass(node, node->id(), object_array_class) ?
             object_array_class : immutable_object_array_class;
     // Type checks of array.
     __ testl(EBX, Immediate(kSmiTagMask));  // Deoptimize if Smi.
     __ j(ZERO, deopt_blob->label());
     __ movl(EAX, FieldAddress(EBX, Object::class_offset()));
     __ CompareObject(EAX, test_class);
     __ j(NOT_EQUAL, deopt_blob->label());
 
@@ skipping 21 matching lines @@
   if (AtIdNodeHasOnlyClass(node, node->id(), growable_array_class)) {
     const String& growable_array_length_field_name =
         String::Handle(String::NewSymbol(kGrowableArrayLengthFieldName));
     const String& growable_array_array_field_name =
         String::Handle(String::NewSymbol(kGrowableArrayArrayFieldName));
     intptr_t length_offset = GetFieldOffset(growable_array_class,
                                             growable_array_length_field_name);
     intptr_t array_offset = GetFieldOffset(growable_array_class,
                                            growable_array_array_field_name);
     VisitLoadTwo(node->array(), node->index_expr(), EDX, EAX);
-    DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EDX, EAX);
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, EDX, EAX, kDeoptLoadIndexedGrowableArray);
     // TODO(srdjan): Use CodeGenInfo to eliminate Smi test if possible.
     // EAX: index, EDX: array.
     __ testl(EAX, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt_blob->label());  // Not Smi index.
     __ testl(EDX, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());  // Array is Smi.
     __ movl(EBX, FieldAddress(EDX, Object::class_offset()));
     __ CompareObject(EBX, growable_array_class);
     __ j(NOT_EQUAL, deopt_blob->label());  // Array is not GrowableObjectArray.
     // Range check: deoptimize if out of bounds.
@@ skipping 20 matching lines @@
     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());
   if (AtIdNodeHasOnlyClass(node, node->id(), object_array_class)) {
     VisitLoadTwo(node->index_expr(), node->value(), EBX, ECX);
-    DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EAX, 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()));
     __ CompareObject(EDX, object_array_class);
     __ j(NOT_EQUAL, deopt_blob->label());  // Not ObjectArray -> deopt.
     // Check type of index.
     __ testl(EBX, Immediate(kSmiTagMask));
@@ skipping 133 matching lines @@
   } else {
     __ Bind(&false_label);
   }
   __ Bind(&done);
 }
 
 
 void OptimizingCodeGenerator::GenerateDirectCall(
     intptr_t node_id,
     intptr_t token_index,
-    Function& target,
+    const Function& target,
     intptr_t arg_count,
     const Array& optional_argument_names) {
   ASSERT(!target.IsNull());
   const Code& code = Code::Handle(target.code());
   ASSERT(!code.IsNull());
   ExternalLabel target_label("DirectInstanceCall", code.EntryPoint());
 
   __ LoadObject(ECX, target);
   __ LoadObject(EDX, ArgumentsDescriptor(arg_count, optional_argument_names));
   __ call(&target_label);
   AddCurrentDescriptor(PcDescriptors::kOther, node_id, token_index);
   __ addl(ESP, Immediate(arg_count * kWordSize));
 }
 
 
+// Generate inline cache calls instead of deoptimizing when no type feedback is
+// provided.
+// TODO(srdjan): Recompilation framework should recognize active IC calls
+// in optimized code and mark them for reoptimization since type feedback was
+// collected in the meantime.
+void OptimizingCodeGenerator::GenerateInlineCacheCall(
+    intptr_t node_id,
+    intptr_t token_index,
+    const ICData& ic_data,
+    intptr_t num_args,
+    const Array& optional_arguments_names) {
+  __ LoadObject(ECX, Array::ZoneHandle(ic_data.data()));
+  __ LoadObject(EDX, ArgumentsDescriptor(num_args, optional_arguments_names));
+  ExternalLabel target_label(
+      "InlineCache", StubCode::InlineCacheEntryPoint());
+
+  __ call(&target_label);
+  AddCurrentDescriptor(PcDescriptors::kIcCall,
+                       node_id,
+                       token_index);
+  __ addl(ESP, Immediate(num_args * kWordSize));
+}
+
+
+// Normalizes the ic_data class/target pairs:
+// - If Smi class exists, make it the first one.
+// - If 'null_target' not null, append null-class/'null_target'
+void OptimizingCodeGenerator::NormalizeClassChecks(
+    const ICData& ic_data,
+    const Function& null_target,
+    GrowableArray<const Class*>* classes,
+    GrowableArray<const Function*>* targets) {
+  ASSERT(classes != NULL);
+  ASSERT(targets != NULL);
+  // Check if we can add Smi class in front.
+  Class& smi_test_class = Class::Handle();
+  Function& smi_target = Function::ZoneHandle();
+  for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
+    ic_data.GetOneClassCheckAt(i, &smi_test_class, &smi_target);
+    if (smi_test_class.raw() == smi_class_.raw()) {
+      classes->Add(&Class::ZoneHandle(smi_class_.raw()));
+      targets->Add(&Function::ZoneHandle(smi_target.raw()));
+      break;
+    }
+  }
+  // Add all classes except Smi.
+  for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
+    Function& target = Function::ZoneHandle();
+    Class& cls = Class::ZoneHandle();
+    ic_data.GetOneClassCheckAt(i, &cls, &target);
+    ASSERT(!cls.IsNullClass());
+    if (cls.raw() != smi_class_.raw()) {
+      ASSERT(!cls.IsNull());
+      ASSERT(!target.IsNull());
+      classes->Add(&cls);
+      targets->Add(&target);
+    }
+  }
+  // Do not add a target that has not been compiled yet.
+  if (!null_target.IsNull() && null_target.HasCode()) {
+    ASSERT(null_target.IsZoneHandle());
+    classes->Add(&Class::ZoneHandle(Object::null_class()));
+    targets->Add(&null_target);
+  }
+}
+
+
 // Use ICData in 'node' to issues checks and calls.
 void OptimizingCodeGenerator::GenerateCheckedInstanceCalls(
     AstNode* node,
     AstNode* receiver,
     intptr_t node_id,
     intptr_t token_index,
     intptr_t num_args,
-    const Array& optional_argument_names) {
+    const Array& optional_arguments_names) {
   ASSERT(node != NULL);
   ASSERT(receiver != NULL);
   ASSERT(num_args > 0);
-  DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node);
   const ICData& ic_data = node->ICDataAtId(node_id);
   if (ic_data.NumberOfChecks() == 0) {
-    // No type feedback means node was never executed.
-    __ jmp(deopt_blob->label());
+    // No type feedback means node was never executed. However that can be
+    // a common case especially in case of large switch statements.
+    // Use a special inline cache call which can help us decide when to
+    // re-optimize this optiumized function.

[regis, 2011/11/16 23:06:45]

optiumized?
opium-ized?

+    GenerateInlineCacheCall(
+        node_id, token_index, ic_data, num_args, optional_arguments_names);
     return;
   }
   ASSERT(ic_data.NumberOfArgumentsChecked() == 1);
 
-  // First test for Smi. Null object will cause deoptimization.
-  intptr_t smi_class_index = -1;
-  Class& smi_test_class = Class::Handle();
-  Function& smi_target = Function::ZoneHandle();
-  for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
-    ic_data.GetOneClassCheckAt(i, &smi_test_class, &smi_target);
-    if (smi_test_class.raw() == smi_class_.raw()) {
-      smi_class_index = i;
-      break;
-    }
-  }
+  Function& target_for_null = Function::ZoneHandle();
+  ObjectStore* object_store = Isolate::Current()->object_store();
+  int num_optional_args =
+      optional_arguments_names.IsNull() ? 0 : optional_arguments_names.Length();
+  target_for_null = Resolver::ResolveDynamicForReceiverClass(
+      Class::Handle(object_store->object_class()),
+      String::Handle(ic_data.FunctionName()),
+      num_args,
+      num_optional_args);
+  GrowableArray<const Class*> classes;
+  GrowableArray<const Function*> targets;
+  NormalizeClassChecks(ic_data, target_for_null, &classes, &targets);
+  ASSERT(!classes.is_empty());
+  ASSERT(classes.length() == targets.length());
+  intptr_t start_ix = 0;
 
   Label done;
   __ movl(EAX, Address(ESP, (num_args - 1) * kWordSize));  // Load receiver.
-  if (smi_class_index >= 0) {
+  if (classes[0]->raw() == smi_class_.raw()) {
+    start_ix++;
     // Smi test is needed.
     __ testl(EAX, Immediate(kSmiTagMask));
-    if (ic_data.NumberOfChecks() == 1) {
-      // Only the Smi test.
+    if (classes.length() == 1) {
+      // Only Smi test.
+      DeoptimizationBlob* deopt_blob =
+          AddDeoptimizationBlob(node, kDeoptCheckedInstanceCallSmiOnly);
       __ j(NOT_ZERO, deopt_blob->label());
       GenerateDirectCall(node_id,
                          token_index,
-                         smi_target,
+                         *targets[0],
                          num_args,
-                         optional_argument_names);
+                         optional_arguments_names);
       return;
     }
     Label not_smi;
     __ j(NOT_ZERO, &not_smi);
     GenerateDirectCall(node_id,
                        token_index,
-                       smi_target,
+                       *targets[0],
                        num_args,
-                       optional_argument_names);
+                       optional_arguments_names);
     __ jmp(&done);
     __ Bind(&not_smi);  // Continue with other test below.
   } else if (NodeMayBeSmi(receiver)) {
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, kDeoptCheckedInstanceCallSmiFail);
     __ testl(EAX, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());
   } else {
     // Receiver cannot be Smi, no need to test it.
   }
-
-  intptr_t last_check_at = (smi_class_index == ic_data.NumberOfChecks() - 1) ?
-      ic_data.NumberOfChecks() - 2 : ic_data.NumberOfChecks() - 1;
-  // Every class may appear only once in the 'classes' array. Therefore, if
-  // Smi class is last, it cannot be the second to last.
   __ movl(EAX, FieldAddress(EAX, Object::class_offset()));  // Receiver's class.
-  for (intptr_t i = 0; i <= last_check_at; i++) {
-    Function& target = Function::ZoneHandle();
-    Class& cls = Class::ZoneHandle();
-    ic_data.GetOneClassCheckAt(i, &cls, &target);
-    ASSERT(!cls.IsNullClass());
-    if (cls.raw() == smi_class_.raw()) {
-      ASSERT(i < last_check_at);  // Smi class may not be last.
-      continue;  // Skip Smi test.
-    }
+  for (intptr_t i = start_ix; i < classes.length(); i++) {
+    const Class& cls = *classes[i];
+    const Function& target = *targets[i];
     __ CompareObject(EAX, cls);
-    if (i == last_check_at) {
+    if (i == (classes.length() - 1)) {
+      // Last check.
+      DeoptimizationBlob* deopt_blob =
+          AddDeoptimizationBlob(node, kDeoptCheckedInstanceCallCheckFail);
       __ j(NOT_EQUAL, deopt_blob->label());
       GenerateDirectCall(node_id,
                          token_index,
                          target,
                          num_args,
-                         optional_argument_names);
+                         optional_arguments_names);
     } else {
       Label next;
       __ j(NOT_EQUAL, &next);
       GenerateDirectCall(node_id,
                          token_index,
                          target,
                          num_args,
-                         optional_argument_names);
+                         optional_arguments_names);
       __ jmp(&done);
       __ Bind(&next);
     }
   }
   __ Bind(&done);
 }
 
 
 void OptimizingCodeGenerator::VisitInstanceCallNode(InstanceCallNode* node) {
   const int number_of_arguments = node->arguments()->length() + 1;
@@ skipping 39 matching lines @@
     }
     if ((recognized == Recognizer::kIntegerToDouble) &&
         AtIdNodeHasOnlyClass(node, node->id(), smi_class_)) {
       // TODO(srdjan): Check if we could use temporary double instead of
       // allocating a new object every time.
       const Code& stub =
           Code::Handle(StubCode::GetAllocationStubForClass(double_class_));
       const ExternalLabel label(double_class_.ToCString(), stub.EntryPoint());
       GenerateCall(node->token_index(), &label);
       // EAX is double object.
-      DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EBX);
+      DeoptimizationBlob* deopt_blob =
+          AddDeoptimizationBlob(node, EBX, kDeoptIntegerToDouble);
       __ popl(EBX);  // Receiver
       __ testl(EBX, Immediate(kSmiTagMask));
       __ j(NOT_ZERO, deopt_blob->label());  // Deoptimize if not Smi.
       __ SmiUntag(EBX);
       __ cvtsi2sd(XMM0, EBX);
       __ movsd(FieldAddress(EAX, Double::value_offset()), XMM0);
       return true;
     }
 
     if ((recognized == Recognizer::kDoubleToDouble) &&
         AtIdNodeHasOnlyClass(node, node->id(), double_class_)) {
-      DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(node, EAX);
+      DeoptimizationBlob* deopt_blob =
+          AddDeoptimizationBlob(node, EAX, kDeoptDoubleToDouble);
       __ popl(EAX);
       CheckIfDoubleOrSmi(EAX, EBX, deopt_blob->label(), deopt_blob->label());
       return true;
     }
   }
   return false;
 }
 
 
 // TODO(srdjan): For Math.sqrt read type feedback in Math.sqrt and decide
@@ skipping 39 matching lines @@
   __ addl(ESP, Immediate(node->arguments()->length() * kWordSize));
   // Result is in EAX.
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32