Propagate more local variable types.

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 626 matching lines @@
         return true;
       }
     }
   }
   return false;
 }
 
 
 // Look only at the first class in all check groups. Returns true if all
 // receiver classes are 'cls'.
-static bool AtIdNodeHasReceiverClass(AstNode* node,
-                                     intptr_t id,
-                                     const Class& cls) {
+static bool AtIdNodeHasClassAt(AstNode* node,
+                               intptr_t id,
+                               const Class& cls,
+                               intptr_t arg_index) {
   ASSERT(node != NULL);
   ASSERT(!cls.IsNull());
   const ICData& ic_data = node->ICDataAtId(id);
   if (ic_data.NumberOfChecks() == 0) {
     return false;
   }
+  ASSERT(ic_data.NumberOfArgumentsChecked() > arg_index);
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     GrowableArray<const Class*> classes;
     Function& target = Function::Handle();
     ic_data.GetCheckAt(i, &classes, &target);
     if (classes.is_empty()) {
       return false;
     }
-    if (classes[0]->raw() != cls.raw()) {
+    if (classes[arg_index]->raw() != cls.raw()) {
       return false;
     }
   }
   return true;
 }
 
 
 // IC data may have only one check, and it has to contain the two classes in
 // specified order.
 static bool AtIdNodeHasTwoClasses(AstNode* node,
@@ skipping 165 matching lines @@
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback.
     __ jmp(deopt_blob->label());
     return;
   }
   ASSERT(ic_data.NumberOfChecks() == 1);
   CheckIfDoubleOrSmi(kOperandRegister,
                      kTempRegister,
                      deopt_blob->label(),
                      deopt_blob->label());
+  PropagateBackLocalClass(node->operand(), double_class_);
   // TODO(srdjan): check if we could reuse a temporary object instead of
   // allocating a new one.
   const Code& stub =
       Code::Handle(StubCode::GetAllocationStubForClass(double_class_));
   const ExternalLabel label(double_class_.ToCString(), stub.EntryPoint());
   __ pushl(kOperandRegister);
   GenerateCall(node->token_index(), &label);
   ASSERT(kResultRegister == EAX);
   __ popl(kOperandRegister);
   __ movsd(XMM0, FieldAddress(kOperandRegister, Double::value_offset()));
@@ skipping 37 matching lines @@
         (classes[1]->raw() == smi_class_.raw()));
     CodeGenInfo left_info(node->left());
     CodeGenInfo right_info(node->right());
     VisitLoadTwo(node->left(), node->right(), EAX, EDX);
     Label two_smis, call_operator;
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, ECX, EDX, kDeoptSmiBinaryOp);
     __ movl(ECX, EAX);  // Save if overflow (needs original value).
 
     if (left_info.IsClass(smi_class_) || right_info.IsClass(smi_class_)) {
-      if (!left_info.IsClass(smi_class_) || !right_info.IsClass(smi_class_)) {
-        // One of the type is not known (statically) to be Smi. Check it.
-        Register test_reg = left_info.IsClass(smi_class_) ? EDX : EAX;
-        __ testl(test_reg, Immediate(kSmiTagMask));
+      if (!left_info.IsClass(smi_class_)) {
+        __ testl(EAX, Immediate(kSmiTagMask));
         __ j(NOT_ZERO, deopt_blob->label());
+        PropagateBackLocalClass(node->left(), smi_class_);
+      }
+      if (!right_info.IsClass(smi_class_)) {
+        __ testl(EDX, Immediate(kSmiTagMask));
+        __ j(NOT_ZERO, deopt_blob->label());
+        PropagateBackLocalClass(node->right(), smi_class_);
       }
     } else {
       // Type feedback says both types are Smi, but static type analysis
       // does not know if any of them is Smi, therefore check.
       __ orl(EAX, EDX);
       __ testl(EAX, Immediate(kSmiTagMask));
       __ j(NOT_ZERO, deopt_blob->label());
       __ movl(EAX, ECX);
+      PropagateBackLocalClass(node->left(), smi_class_);
+      PropagateBackLocalClass(node->right(), smi_class_);
     }
     if (node->info() != NULL) {
       node->info()->set_is_class(&smi_class_);
     }
     switch (kind) {
       case Token::kADD: {
         __ addl(EAX, EDX);
         __ j(OVERFLOW, deopt_blob->label());
         break;
       }
@@ skipping 126 matching lines @@
 // Conservative approach:
 // - true if both nodes are LoadLocalNodes with the same index.
 static bool AreNodesOfSameType(AstNode* a, AstNode* b) {
   ASSERT((a != NULL) && (b != NULL));
   if (a->IsLoadLocalNode() && b->IsLoadLocalNode()) {
     return a->AsLoadLocalNode()->local().Equals(b->AsLoadLocalNode()->local());
   }
   return false;
 }
 
+
+// If possible propagate node type back to the local.
+void OptimizingCodeGenerator::PropagateBackLocalClass(AstNode* node,
+                                                      const Class& cls) {
+  if (node->IsLoadLocalNode()) {
+    LoadLocalNode* local_node = node->AsLoadLocalNode();
+    classes_for_locals_->SetLocalType(local_node->local(), cls);
+  }
+}
+
+
 // 'reg' is not modified, 'temp' is trashed.
 // Fall through if double, jump to 'is_smi' if Smi and
 // jump to 'not_double_or_smi' if neither double nor Smi.
 void OptimizingCodeGenerator::CheckIfDoubleOrSmi(Register reg,
                                                  Register temp,
                                                  Label* is_smi,
                                                  Label* not_double_or_smi) {
   __ testl(reg, Immediate(kSmiTagMask));
   __ j(ZERO, is_smi);
   __ movl(temp, FieldAddress(reg, Object::class_offset()));
@@ skipping 17 matching lines @@
   if ((kind == Token::kADD) ||
       (kind == Token::kSUB) ||
       (kind == Token::kMUL) ||
       (kind == Token::kDIV)) {
     TraceOpt(node, kOptMessage);
     // All four register below must be different.
     const Register kLeftRegister = EAX;
     const Register kRightRegister = EDX;
     const Register kAllocatedRegister = ECX;
     const Register kTempRegister = EBX;
-    CodeGenInfo left_info(node->left());
+    CodeGenInfo left_info(node->left());  // Receiver.
     CodeGenInfo right_info(node->right());
     VisitLoadTwo(node->left(), node->right(), kLeftRegister, kRightRegister);
     // First allocate result object or specify an existing object as result.
     Register result_register = kNoRegister;
     if (node->info() == NULL) {
       // Parent node cannot handle a temporary double object, allocate one
       // each time.
       result_register = kAllocatedRegister;
       const Code& stub =
           Code::Handle(StubCode::GetAllocationStubForClass(double_class_));
@@ skipping 29 matching lines @@
     }
 
     if (receiver_can_be_smi) {
       // Only deoptimize if both argument are Smi.
       __ movl(kTempRegister, kLeftRegister);
       __ orl(kTempRegister, kRightRegister);
       __ testl(kTempRegister, Immediate(kSmiTagMask));
       __ j(ZERO, deopt_lbl);
     }
 
-    bool nodes_of_same_type = AreNodesOfSameType(node->left(), node->right());
-    if (!left_info.IsClass(double_class_)) {
-      Label is_smi, done;
-      CheckIfDoubleOrSmi(kLeftRegister, kTempRegister, &is_smi, deopt_lbl);
-      // Fall through for double. Jump to 'is_smi' if double, jump to
-      // 'deopt' if neither smi nor double.
+    bool args_of_same_type = AreNodesOfSameType(node->left(), node->right());
+    if (left_info.IsClass(double_class_)) {
       __ movsd(XMM0, FieldAddress(kLeftRegister, Double::value_offset()));
-      __ jmp(&done);
-      __ Bind(&is_smi);
-      __ SmiUntag(kLeftRegister);
-      __ cvtsi2sd(XMM0, kLeftRegister);
-      __ Bind(&done);
     } else {
-      __ movsd(XMM0, FieldAddress(kLeftRegister, Double::value_offset()));
+      if (receiver_can_be_smi) {
+        Label is_smi, done;
+        CheckIfDoubleOrSmi(kLeftRegister, kTempRegister, &is_smi, deopt_lbl);
+        // Fall through for double. Jump to 'is_smi' if double, jump to
+        // 'deopt' if neither smi nor double.
+        __ movsd(XMM0, FieldAddress(kLeftRegister, Double::value_offset()));
+        __ jmp(&done);
+        __ Bind(&is_smi);
+        __ SmiUntag(kLeftRegister);
+        __ cvtsi2sd(XMM0, kLeftRegister);
+        __ Bind(&done);
+      } else {
+        CheckIfDoubleOrSmi(kLeftRegister, kTempRegister, deopt_lbl, deopt_lbl);
+        __ movsd(XMM0, FieldAddress(kLeftRegister, Double::value_offset()));
+        PropagateBackLocalClass(node->left(), double_class_);
+      }
     }
-    if (!right_info.IsClass(double_class_) && !nodes_of_same_type) {
-      Label is_smi, done;
-      CheckIfDoubleOrSmi(kRightRegister, kTempRegister, &is_smi, deopt_lbl);
-      // Fall through for double. Jump to 'is_smi' if double, jump to
-      // 'deopt' if neither smi nor double.
+
+    const bool right_must_be_double =
+        AtIdNodeHasClassAt(node, node->id(), double_class_, 1);
+
+    // If arguments are of same type (e.g., same local), then the test of left
+    // argument was sufficient.
+    if (right_info.IsClass(double_class_) || args_of_same_type) {
       __ movsd(XMM1, FieldAddress(kRightRegister, Double::value_offset()));
-      __ jmp(&done);
-      __ Bind(&is_smi);
-      __ SmiUntag(kRightRegister);
-      __ cvtsi2sd(XMM1, kRightRegister);
-      __ Bind(&done);
+      if (!right_info.IsClass(double_class_)) {
+        PropagateBackLocalClass(node->right(), double_class_);
+      }
     } else {
-      __ movsd(XMM1, FieldAddress(kRightRegister, Double::value_offset()));
+      if (right_must_be_double) {
+        CheckIfDoubleOrSmi(kRightRegister, kTempRegister, deopt_lbl, deopt_lbl);
+        __ movsd(XMM1, FieldAddress(kRightRegister, Double::value_offset()));
+        PropagateBackLocalClass(node->right(), double_class_);
+      } else {
+        Label is_smi, done;
+        CheckIfDoubleOrSmi(kRightRegister, kTempRegister, &is_smi, deopt_lbl);
+        // Fall through for double. Jump to 'is_smi' if double, jump to
+        // 'deopt' if neither smi nor double.
+        __ movsd(XMM1, FieldAddress(kRightRegister, Double::value_offset()));
+        __ jmp(&done);
+        __ Bind(&is_smi);
+        __ SmiUntag(kRightRegister);
+        __ cvtsi2sd(XMM1, kRightRegister);
+        __ Bind(&done);
+      }
     }
 
     switch (kind) {
       case Token::kADD: __ addsd(XMM0, XMM1); break;
       case Token::kSUB: __ subsd(XMM0, XMM1); break;
       case Token::kMUL: __ mulsd(XMM0, XMM1); break;
       case Token::kDIV: __ divsd(XMM0, XMM1); break;
       default: UNREACHABLE();
     }
     __ movsd(FieldAddress(result_register, Double::value_offset()), XMM0);
@@ skipping 104 matching lines @@
 
   const ICData& ic_data = node->ICDataAtId(node->id());
   if (ic_data.NumberOfChecks() == 0) {
     VisitLoadTwo(node->left(), node->right(), EAX, EDX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EAX, EDX, kDeoptNoTypeFeedback);
     __ jmp(deopt_blob->label());
     return;
   }
 
+  ASSERT(ic_data.NumberOfArgumentsChecked() == 2);
+
   if (AtIdNodeHasTwoClasses(node, node->id(), smi_class_, smi_class_)) {
     GenerateSmiBinaryOp(node);
     return;
   }
 
-  if (AtIdNodeHasReceiverClass(node, node->id(), double_class_)) {
+  if (AtIdNodeHasClassAt(node, node->id(), double_class_, 0)) {
     const bool receiver_can_be_smi = false;
     GenerateDoubleBinaryOp(node, receiver_can_be_smi);
     return;
   }
 
   if (AtIdNodeHasTwoClasses(node, node->id(), smi_class_, double_class_)) {
     const bool receiver_can_be_smi = true;
     GenerateDoubleBinaryOp(node, receiver_can_be_smi);
     return;
   }
 
   const Class& mint_class =
       Class::Handle(Isolate::Current()->object_store()->mint_class());
-  if (AtIdNodeHasReceiverClass(node, node->id(), mint_class)) {
+  if (AtIdNodeHasClassAt(node, node->id(), mint_class, 0)) {
     GenerateMintBinaryOp(node, false);
     return;
   }
 
   if (NodeHasBothReceiverClasses(node, smi_class_, mint_class)) {
     GenerateMintBinaryOp(node, true);
     return;
   }
 
   // TODO(srdjan): Implement "+" for Strings.
@@ skipping 23 matching lines @@
   }
   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_)) {
+  if (!AtIdNodeHasClassAt(node, node->id(), smi_class_, 0)) {
     classes_for_locals_->SetLocalType(node->local(), Class::ZoneHandle());
     TraceNotOpt(node, kOptMessage);
     CodeGenerator::VisitIncrOpLocalNode(node);
     return;
   }
   TraceOpt(node, kOptMessage);
 
   GenerateLoadVariable(EAX, node->local());
   if (!node->prefix() && IsResultNeeded(node)) {
     // Preserve as result.
@@ skipping 75 matching lines @@
                        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 (AtIdNodeHasReceiverClass(node, node->operator_id(), smi_class_)) {
+  if (AtIdNodeHasClassAt(node, node->operator_id(), smi_class_, 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, EDX, EDX, kDeoptIncrInstanceOneClass);
     if (return_original_value) {
       // Preserve pre increment result.
       __ movl(ECX, EAX);
     }
     __ testl(EAX, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt_blob->label());
@@ skipping 737 matching lines @@
   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, kDeoptDoubleComparison);
   }
   if (!left_info.IsClass(double_class_)) {
     CheckIfDoubleOrSmi(EAX, EBX, deopt_blob->label(), deopt_blob->label());
+    PropagateBackLocalClass(node->left(), double_class_);
   }
   if (!right_info.IsClass(double_class_)) {
     CheckIfDoubleOrSmi(EDX, EBX, deopt_blob->label(), deopt_blob->label());
+    PropagateBackLocalClass(node->right(), double_class_);
   }
   __ movsd(XMM0, FieldAddress(EAX, Double::value_offset()));
   __ movsd(XMM1, FieldAddress(EDX, Double::value_offset()));
   __ comisd(XMM0, XMM1);
   if (NodeInfoHasLabels(node)) {
     __ j(PARITY_EVEN, node->info()->false_label());  // NaN -> false;
     GenerateConditionalJumps(*(node->info()), true_condition);
     node->info()->set_labels_used(true);
   } else {
     Label is_false, is_true, done;
@@ skipping 54 matching lines @@
     GenerateInstanceOf(node->id(),
                        node->token_index(),
                        node->right()->AsTypeNode()->type(),
                        (node->kind() == Token::kISNOT));
     if (!IsResultNeeded(node)) {
       __ popl(EAX);  // Pop the result of the instanceof operation.
     }
     return;
   }
 
-  if (AtIdNodeHasReceiverClass(node, node->id(), smi_class_)) {
+  if (AtIdNodeHasClassAt(node, node->id(), smi_class_, 0)) {
     if (GenerateSmiComparison(node)) {
       // The comparison was handled, code was emitted.
       return;
     }
     // Fall through if condition is not supported.
-  } else if (AtIdNodeHasReceiverClass(node, node->id(), double_class_)) {
+  } else if (AtIdNodeHasClassAt(node, node->id(), double_class_, 0)) {
     // Double comparison
     if (GenerateDoubleComparison(node)) {
       return;
     }
   } else if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
     // Equality, not-equality comparison of any other type.
     if (GenerateEqualityComparison(node)) {
       return;
     }
   }
 
   // Fall through here if a comparison was not implemented.
   // TODO(srdjan): Implement for Strings.
   CodeGenerator::VisitComparisonNode(node);
 }
 
 
 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 (AtIdNodeHasReceiverClass(node, node->id(), object_array_class) ||
-      AtIdNodeHasReceiverClass(node, node->id(),
-          immutable_object_array_class)) {
+  if (AtIdNodeHasClassAt(node, node->id(), object_array_class, 0) ||
+      AtIdNodeHasClassAt(node, node->id(),
+          immutable_object_array_class, 0)) {
     VisitLoadTwo(node->array(), node->index_expr(), EBX, EDX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EBX, EDX, kDeoptLoadIndexedFixedArray);
     const Class& test_class =
-        AtIdNodeHasReceiverClass(node, node->id(), object_array_class) ?
+        AtIdNodeHasClassAt(node, node->id(), object_array_class, 0) ?
             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());
 
     // Type check of index.
     __ testl(EDX, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt_blob->label());
     // Range check.
     __ cmpl(EDX, FieldAddress(EBX, Array::length_offset()));
     __ j(ABOVE_EQUAL, deopt_blob->label());
     // Note that EDX is Smi, i.e, times 2.
     ASSERT(kSmiTagShift == 1);
     __ movl(EAX, FieldAddress(EBX, EDX, TIMES_2, sizeof(RawArray)));
     HandleResult(node, EAX);
     TraceOpt(node, kMessage);
     return;
   }
 
   const String& growable_object_array_class_name = String::Handle(
       String::NewSymbol(kGrowableArrayClassName));
   const Class& growable_array_class = Class::ZoneHandle(
       Library::Handle(Library::CoreImplLibrary()).
           LookupClass(growable_object_array_class_name));
   ASSERT(!growable_array_class.IsNull());
-  if (AtIdNodeHasReceiverClass(node, node->id(), growable_array_class)) {
+  if (AtIdNodeHasClassAt(node, node->id(), growable_array_class, 0)) {
     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 =
@@ skipping 36 matching lines @@
       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 (AtIdNodeHasReceiverClass(node, node->id(), object_array_class)) {
+  if (AtIdNodeHasClassAt(node, node->id(), object_array_class, 0)) {
     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 class 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);
@@ skipping 11 matching lines @@
     HandleResult(node, ECX);
     return;
   }
 
   const String& growable_object_array_class_name = String::Handle(
       String::NewSymbol(kGrowableArrayClassName));
   const Class& growable_array_class = Class::ZoneHandle(
       Library::Handle(Library::CoreImplLibrary()).
           LookupClass(growable_object_array_class_name));
   ASSERT(!growable_array_class.IsNull());
-  if (AtIdNodeHasReceiverClass(node, node->id(), growable_array_class)) {
+  if (AtIdNodeHasClassAt(node, node->id(), growable_array_class, 0)) {
     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->index_expr(), node->value(), EBX, ECX);
     DeoptimizationBlob* deopt_blob =
@@ skipping 378 matching lines @@
                                                  node->function_name(),
                                                  num_arguments,
                                                  num_named_arguments));
     Recognizer::Kind recognized = Recognizer::RecognizeKind(target);
     if (FLAG_trace_optimization) {
       OS::Print("Monomorphic inline candidate: %s -> %s\n",
           target.ToFullyQualifiedCString(),
           Recognizer::KindToCString(recognized));
     }
     if ((recognized == Recognizer::kIntegerToDouble) &&
-        AtIdNodeHasReceiverClass(node, node->id(), smi_class_)) {
+        AtIdNodeHasClassAt(node, node->id(), smi_class_, 0)) {
       // 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, 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) &&
-        AtIdNodeHasReceiverClass(node, node->id(), double_class_)) {
+        AtIdNodeHasClassAt(node, node->id(), double_class_, 0)) {
       DeoptimizationBlob* deopt_blob =
           AddDeoptimizationBlob(node, EAX, kDeoptDoubleToDouble);
       __ popl(EAX);
       CheckIfDoubleOrSmi(EAX, EBX, deopt_blob->label(), deopt_blob->label());
       return true;
     }
   }
   return false;
 }
 
@@ skipping 123 matching lines @@
     __ LoadObject(EAX, Bool::ZoneHandle(Bool::True()));
     __ cmpl(EDX, EAX);
     __ j(NOT_EQUAL, &done, Assembler::kNearJump);
     __ LoadObject(EAX, Bool::ZoneHandle(Bool::False()));
     __ Bind(&done);
     HandleResult(node, EAX);
     return;
   }
 
   if ((node->kind() == Token::kSUB) || (node->kind() == Token::kBIT_NOT)) {
-    if (AtIdNodeHasReceiverClass(node, node->id(), smi_class_)) {
+    if (AtIdNodeHasClassAt(node, node->id(), smi_class_, 0)) {
       const ICData& ic_data = node->ICDataAtId(node->id());
       ASSERT(ic_data.NumberOfArgumentsChecked() == 1);
       GenerateSmiUnaryOp(node);
       return;
     }
   }
   if (node->kind() == Token::kSUB) {
-    if (AtIdNodeHasReceiverClass(node, node->id(), double_class_)) {
+    if (AtIdNodeHasClassAt(node, node->id(), double_class_, 0)) {
       const ICData& ic_data = node->ICDataAtId(node->id());
       ASSERT(ic_data.NumberOfArgumentsChecked() == 1);
       GenerateDoubleUnaryOp(node);
       return;
     }
   }
   // TODO(srdjan): Implement unary kSUB (negate) Mint.
   CodeGenerator::VisitUnaryOpNode(node);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32