With removal of increment operations, each node has a unique id.

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 302 matching lines @@
 
 bool OptimizingCodeGenerator::IsResultInEaxRequested(AstNode* node) const {
   return (node->info() != NULL) && node->info()->request_result_in_eax();
 }
 
 
 static const ZoneGrowableArray<const Class*>*
     CollectedClassesAtNode(AstNode* node) {
   ZoneGrowableArray<const Class*>* result =
       new ZoneGrowableArray<const Class*>();
-  const ICData& ic_data = node->ICDataAtId(node->id());
+  const ICData& ic_data = node->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     return result;
   }
   ASSERT(ic_data.num_args_tested() == 1);
   Function& target = Function::Handle();
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     Class& cls = Class::ZoneHandle();
     ic_data.GetOneClassCheckAt(i, &cls, &target);
     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());
+void OptimizingCodeGenerator::PrintCollectedClasses(AstNode* node) {
+  const ICData& ic_data = node->ic_data();
+  OS::Print("Collected classes id %d num: %d\n",
+      node->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 191 matching lines @@
   HandleResult(node, EAX);
   classes_for_locals_->SetLocalType(node->local(), *value_info.is_class());
 }
 
 
 static bool NodeHasBothReceiverClasses(AstNode* node,
                                        const Class& cls1,
                                        const Class& cls2) {
   ASSERT(node != NULL);
   ASSERT(!cls1.IsNull() && !cls2.IsNull());
-  const ICData& ic_data = node->ICDataAtId(node->id());
+  const ICData& ic_data = node->ic_data();
   bool cls1_found = false;
   bool cls2_found = false;
   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()) {
       if (classes[0]->raw() == cls1.raw()) {
         cls1_found = true;
       }
       if (classes[0]->raw() == cls2.raw()) {
         cls2_found = true;
       }
       if (cls1_found && cls2_found) {
         return true;
       }
     }
   }
   return false;
 }
 
 
 // Look only at the first class in all check groups. Returns true if all
 // receiver classes are 'cls'.
-static bool AtIdNodeHasClassAt(AstNode* node,
-                               intptr_t id,
-                               const Class& cls,
-                               intptr_t arg_index) {
+static bool NodeHasClassAt(AstNode* node,
+                           const Class& cls,
+                           intptr_t arg_index) {
   ASSERT(node != NULL);
   ASSERT(!cls.IsNull());
-  const ICData& ic_data = node->ICDataAtId(id);
+  const ICData& ic_data = node->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     return false;
   }
   ASSERT(ic_data.num_args_tested() > 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[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,
-                                  intptr_t id,
-                                  const Class& cls0,
-                                  const Class& cls1) {
+static bool NodeHasTwoClasses(AstNode* node,
+                              const Class& cls0,
+                              const Class& cls1) {
   ASSERT(node != NULL);
   ASSERT(!cls0.IsNull() && !cls1.IsNull());
-  const ICData& ic_data = node->ICDataAtId(id);
+  const ICData& ic_data = node->ic_data();
   ASSERT(ic_data.num_args_tested() == 2);
   if (ic_data.NumberOfChecks() != 1) {
     return false;
   }
   Function& target = Function::Handle();
   GrowableArray<const Class*> classes;
   ic_data.GetCheckAt(0, &classes, &target);
   if ((cls0.raw() == classes[0]->raw()) && (cls1.raw() == classes[1]->raw())) {
     return true;
   }
@@ skipping 58 matching lines @@
       __ j(NOT_EQUAL, &slow_case, Assembler::kNearJump);  // Overflow.
       __ shll(EAX, imm);  // Shift for result now we know there is no overflow.
       __ jmp(&done);
       __ Bind(&slow_case);
       __ pushl(EAX);
       __ pushl(Immediate(reinterpret_cast<int32_t>(smi.raw())));
       const int number_of_arguments = 2;
       const Array& no_optional_argument_names = Array::Handle();
       GenerateCheckedInstanceCalls(node,
                                    node->left(),
-                                   node->id(),
                                    node->token_index(),
                                    number_of_arguments,
                                    no_optional_argument_names);
       __ Bind(&done);
       return;
     }
   }
 
   Label slow_case, done;
   CodeGenInfo left_info(node->left());
@@ skipping 24 matching lines @@
   __ shll(EAX, ECX);  // Shift for result now we know there is no overflow.
   // EAX is the correctly tagged Smi.
   __ jmp(&done);
   __ Bind(&slow_case);
   __ pushl(EAX);
   __ pushl(EDX);
   const int number_of_arguments = 2;
   const Array& no_optional_argument_names = Array::Handle();
   GenerateCheckedInstanceCalls(node,
                                node->left(),
-                               node->id(),
                                node->token_index(),
                                number_of_arguments,
                                no_optional_argument_names);
   __ Bind(&done);
 }
 
 
 // Implement Token::kSUB and Token::kBIT_NOT.
 void OptimizingCodeGenerator::GenerateSmiUnaryOp(UnaryOpNode* node) {
-  const ICData& ic_data = node->ICDataAtId(node->id());
+  const ICData& ic_data = node->ic_data();
   ASSERT(ic_data.num_args_tested() == 1);
   DeoptReasonId deopt_reason_id = ic_data.NumberOfChecks() == 0 ?
       kDeoptNoTypeFeedback : kDeoptUnaryOp;
   DeoptimizationBlob* deopt_blob =
       AddDeoptimizationBlob(node, EAX, deopt_reason_id);
   CodeGenInfo info(node->operand());
   VisitLoadOne(node->operand(), EAX);
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback.
     __ jmp(deopt_blob->label());
@@ skipping 14 matching lines @@
     __ andl(EAX, Immediate(~kSmiTagMask));  // Remove inverted smi-tag.
   }
   HandleResult(node, EAX);
 }
 
 
 void OptimizingCodeGenerator::GenerateDoubleUnaryOp(UnaryOpNode* node) {
   const Register kOperandRegister = ECX;
   const Register kTempRegister = EBX;
   const Register kResultRegister = EAX;
-  const ICData& ic_data = node->ICDataAtId(node->id());
+  const ICData& ic_data = node->ic_data();
   DeoptReasonId deopt_reason_id = ic_data.NumberOfChecks() == 0 ?
       kDeoptNoTypeFeedback : kDeoptUnaryOp;
   DeoptimizationBlob* deopt_blob =
       AddDeoptimizationBlob(node, kOperandRegister, deopt_reason_id);
   CodeGenInfo info(node->operand());
   info.set_allow_temp(true);
   VisitLoadOne(node->operand(), kOperandRegister);
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback.
     __ jmp(deopt_blob->label());
@@ skipping 48 matching lines @@
   const Token::Kind kind = node->kind();
   if ((kind == Token::kADD) ||
       (kind == Token::kSUB) ||
       (kind == Token::kMUL) ||
       (kind == Token::kTRUNCDIV) ||
       (kind == Token::kBIT_AND) ||
       (kind == Token::kBIT_OR) ||
       (kind == Token::kBIT_XOR)) {
     TraceOpt(node, kOptMessage);
     // Check if both arguments are expected to be Smi.
-    const ICData& ic_data = node->ICDataAtId(node->id());
+    const ICData& ic_data = node->ic_data();
     ASSERT(ic_data.num_args_tested() == 2);
     ASSERT(ic_data.NumberOfChecks() > 0);
     Function& target = Function::Handle();
     GrowableArray<const Class*> classes;
     ic_data.GetCheckAt(0, &classes, &target);
     ASSERT(ic_data.NumberOfChecks() == 1);
     ASSERT((classes[0]->raw() == smi_class_.raw()) &&
         (classes[1]->raw() == smi_class_.raw()));
     CodeGenInfo left_info(node->left());
     CodeGenInfo right_info(node->right());
@@ skipping 136 matching lines @@
     __ Bind(&is_smi);
     __ andl(EAX, EDX);
     __ jmp(&done);
     __ Bind(&slow_case);
     __ pushl(EAX);
     __ pushl(EDX);
     const int number_of_arguments = 2;
     const Array& no_optional_argument_names = Array::Handle();
     GenerateCheckedInstanceCalls(node,
                                  node->left(),
-                                 node->id(),
                                  node->token_index(),
                                  number_of_arguments,
                                  no_optional_argument_names);
     __ Bind(&done);
     HandleResult(node, EAX);
     return;
   }
   if ((kind == Token::kSHL) && allow_smi) {
     GenerateSmiShiftBinaryOp(node);
     HandleResult(node, EAX);
@@ skipping 132 matching lines @@
         __ 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_);
       }
     }
 
-    const bool right_must_be_double =
-        AtIdNodeHasClassAt(node, node->id(), double_class_, 1);
+    const bool right_must_be_double = NodeHasClassAt(node, 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()));
       if (!right_info.IsClass(double_class_)) {
         PropagateBackLocalClass(node->right(), double_class_);
       }
     } else {
       if (right_must_be_double) {
@@ skipping 122 matching lines @@
     // TODO(srdjan): Test in checked mode if they are Booleans otherwise
     // throw exception.
     if (FLAG_enable_type_checks) {
       CodeGenerator::VisitBinaryOpNode(node);
       return;
     }
     GenerateLogicalBinaryOp(node);
     return;
   }
 
-  const ICData& ic_data = node->ICDataAtId(node->id());
+  const ICData& ic_data = node->ic_data();
   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.num_args_tested() == 2);
 
-  if (AtIdNodeHasTwoClasses(node, node->id(), smi_class_, smi_class_)) {
+  if (NodeHasTwoClasses(node, smi_class_, smi_class_)) {
     GenerateSmiBinaryOp(node);
     return;
   }
 
-  if (AtIdNodeHasClassAt(node, node->id(), double_class_, 0)) {
+  if (NodeHasClassAt(node, 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_)) {
+  if (NodeHasTwoClasses(node, 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 (AtIdNodeHasClassAt(node, node->id(), mint_class, 0)) {
+  if (NodeHasClassAt(node, mint_class, 0)) {
     GenerateMintBinaryOp(node, false);
     return;
   }
 
   if (NodeHasBothReceiverClasses(node, smi_class_, mint_class)) {
     GenerateMintBinaryOp(node, true);
     return;
   }
 
   // TODO(srdjan): Implement "+" for Strings.
   // Type feedback tells this is not a Smi or Double operation.
   TraceNotOpt(node,
       "BinaryOp: type feedback tells this is not a Smi, Mint or Double op");
   node->left()->Visit(this);
   node->right()->Visit(this);
   const int number_of_arguments = 2;
   const Array& no_optional_argument_names = Array::Handle();
   GenerateCheckedInstanceCalls(node,
                                node->left(),
-                               node->id(),
                                node->token_index(),
                                number_of_arguments,
                                no_optional_argument_names);
   HandleResult(node, EAX);
   return;
 }
 
 
 // Return offset of a field or -1 if field is not found.
 static intptr_t GetFieldOffset(const Class& field_class,
@@ skipping 37 matching lines @@
   return true;
 }
 
 
 // Emits code for an instance getter that has one or more collected classes,
 // all with the same target. Deoptimizes for Smi or unexpected class.
 //  EBX: loaded receiver.
 // Result is returned in EAX.
 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, 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);
+  const ICData& ic_data = node->ic_data();
   Function& target = Function::Handle();
   Label load_field;
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     Class& cls = Class::ZoneHandle();
     ic_data.GetOneClassCheckAt(i, &cls, &target);
     __ CompareObject(EAX, cls);
     if (i == (ic_data.NumberOfChecks() - 1)) {
       __ j(NOT_EQUAL, deopt_blob->label());
     } else {
       __ j(EQUAL, &load_field);
@@ skipping 69 matching lines @@
 
 // Return true if all targets in 'ic_data' point to same
 // inlineable getter target.
 static bool ICDataToSameInlineableInstanceGetter(const ICData& ic_data) {
   const Function& target = Function::Handle(GetUniqueTarget(ic_data));
   return !target.IsNull() && IsInlineableInstanceGetter(target);
 }
 
 
 void OptimizingCodeGenerator::InlineInstanceGetter(AstNode* node,
-                                                   intptr_t id,
                                                    AstNode* receiver,
                                                    const String& field_name,
                                                    Register recv_reg) {
-  if (ICDataToSameInlineableInstanceGetter(node->ICDataAtId(id))) {
+  if (ICDataToSameInlineableInstanceGetter(node->ic_data())) {
     InlineInstanceGettersWithSameTarget(node,
-                                        id,
                                         receiver,
                                         field_name,
                                         recv_reg);
   } else {
     // TODO(srdjan): Inline access.
     __ pushl(recv_reg);
     const int kNumberOfArguments = 1;
     const Array& kNoArgumentNames = Array::Handle();
     GenerateCheckedInstanceCalls(node,
                                  receiver,
-                                 id,
                                  node->token_index(),
                                  kNumberOfArguments,
                                  kNoArgumentNames);
   }
 }
 
 
 // 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());
+  const ICData& ic_data = node->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     node->receiver()->Visit(this);
     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.
   HandleResult(node, EAX);
 }
 
 
 // Helper struct to pass arguments to 'GenerateInstanceSetter'.
 struct InstanceSetterArgs {
@@ skipping 26 matching lines @@
                        *(args.target),
                        2,
                        no_optional_argument_names);
     __ popl(args.value_reg);
   }
 }
 
 
 // Returns value in 'value_reg', clobbers EBX.
 void OptimizingCodeGenerator::InlineInstanceSetter(AstNode* node,
-                                                   intptr_t id,
                                                    AstNode* receiver,
                                                    const String& field_name,
                                                    Register recv_reg,
                                                    Register value_reg) {
   // EBX is used as temporary register for class.
   ASSERT((recv_reg != EBX) && (value_reg != EBX));
   GrowableArray<Class*> classes;
   GrowableArray<Function*> targets;
   bool unique_target = true;
   {
-    const ICData& ic_data = node->ICDataAtId(id);
+    const ICData& ic_data = node->ic_data();
     ASSERT(ic_data.NumberOfChecks() > 0);
     ASSERT(ic_data.num_args_tested() == 1);
     for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
       Class& cls = Class::ZoneHandle();
       Function& target = Function::ZoneHandle();
       ic_data.GetOneClassCheckAt(i, &cls, &target);
       classes.Add(&cls);
       targets.Add(&target);
     }
     for (intptr_t i = 1; i < targets.length(); i++) {
       if (targets[i - 1]->raw() != targets[i]->raw()) {
         unique_target = false;
         break;
       }
     }
   }
   // TODO(srdjan): sort classes/target by their invocation count.
   DeoptimizationBlob* deopt_blob = AddDeoptimizationBlob(
       node, recv_reg, value_reg, kDeoptInstanceSetterSameTarget);
   // Deoptimize if Smi, since they do not have setters.
   if (NodeMayBeSmi(receiver)) {
     __ testl(recv_reg, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());
   }
   __ movl(EBX, FieldAddress(recv_reg, Object::class_offset()));
   // Initialize setter arguments, but leave the class and target fields NULL.
   InstanceSetterArgs setter_args =
-      {NULL, NULL, &field_name, recv_reg, value_reg, id, node->token_index()};
+      {NULL, NULL, &field_name, recv_reg, value_reg,
+      node->id(), node->token_index()};
 
   if (unique_target) {
     Label store_field;
     for (intptr_t i = 0; i < classes.length(); i++) {
       __ CompareObject(EBX, *classes[i]);
       if (i == (classes.length() - 1)) {
         __ j(NOT_EQUAL, deopt_blob->label());
       } else {
         __ j(EQUAL, &store_field);
       }
@@ skipping 28 matching lines @@
 // The call to the instance setter implements the assignment to a field.
 // The result of the assignment to a field is the value being stored.
 void OptimizingCodeGenerator::VisitInstanceSetterNode(
     InstanceSetterNode* node) {
   // TODO(srdjan): inline setters to different targets as well.
   if (FLAG_enable_type_checks) {
     CodeGenerator::VisitInstanceSetterNode(node);
     return;
   }
   VisitLoadTwo(node->receiver(), node->value(), EDX, EAX);
-  const ICData& ic_data = node->ICDataAtId(node->id());
+  const ICData& ic_data = node->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     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);
 
   HandleResult(node, EAX);
 }
 
 
 // Return false if condition is not supported.
@@ skipping 114 matching lines @@
     __ jmp(&evaluate_comparison);
 
     __ Bind(&call_operator);
     // Left is Smi.
     const int kNumberOfArguments = 2;
     const Array& kNoArgumentNames = Array::Handle();
     __ pushl(EAX);
     __ pushl(EDX);
     GenerateCheckedInstanceCalls(node,
                                  node->left(),
-                                 node->id(),
                                  node->token_index(),
                                  kNumberOfArguments,
                                  kNoArgumentNames);
     __ CompareObject(EAX, bool_true);
     // Fall through to evaluate result.
   }
   __ Bind(&evaluate_comparison);
   // Condition is set by a previous comparison operation.
   Condition condition = OVERFLOW;  // Initialize to something.
   bool ok = SupportedTokenKindToSmiCondition(node->kind(), &condition);
@@ skipping 284 matching lines @@
                        node->token_index(),
                        node->left(),
                        node->right()->AsTypeNode()->type(),
                        (node->kind() == Token::kISNOT));
     if (!IsResultNeeded(node)) {
       __ popl(EAX);  // Pop the result of the instanceof operation.
     }
     return;
   }
 
-  if (AtIdNodeHasClassAt(node, node->id(), smi_class_, 0)) {
+  if (NodeHasClassAt(node, smi_class_, 0)) {
     if (GenerateSmiComparison(node)) {
       // The comparison was handled, code was emitted.
       return;
     }
     // Fall through if condition is not supported.
-  } else if (AtIdNodeHasClassAt(node, node->id(), double_class_, 0)) {
+  } else if (NodeHasClassAt(node, 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 (AtIdNodeHasClassAt(node, node->id(), object_array_class, 0) ||
-      AtIdNodeHasClassAt(node, node->id(),
-          immutable_object_array_class, 0)) {
+  if (NodeHasClassAt(node, object_array_class, 0) ||
+      NodeHasClassAt(node, immutable_object_array_class, 0)) {
     CodeGenInfo array_info(node->array());
     CodeGenInfo index_info(node->index_expr());
     VisitLoadTwo(node->array(), node->index_expr(), EBX, EDX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EBX, EDX, kDeoptLoadIndexedFixedArray);
-    const Class& test_class =
-        AtIdNodeHasClassAt(node, node->id(), object_array_class, 0) ?
-            object_array_class : immutable_object_array_class;
+    const Class& test_class = NodeHasClassAt(node, object_array_class, 0) ?
+        object_array_class : immutable_object_array_class;
     // Type checks of array.
     if (!array_info.IsClass(test_class)) {
       __ 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());
       PropagateBackLocalClass(node->array(), test_class);
     }
 
     // Type check of index.
     if (!index_info.IsClass(smi_class_)) {
       __ testl(EDX, Immediate(kSmiTagMask));
       __ j(NOT_ZERO, deopt_blob->label());
       PropagateBackLocalClass(node->index_expr(), smi_class_);
     }
     // 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;
   }
 
-  if (AtIdNodeHasClassAt(node, node->id(), growable_object_array_class_, 0)) {
+  if (NodeHasClassAt(node, growable_object_array_class_, 0)) {
     CodeGenInfo array_info(node->array());
     CodeGenInfo index_info(node->index_expr());
     VisitLoadTwo(node->array(), node->index_expr(), EDX, EAX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EDX, EAX, kDeoptLoadIndexedGrowableArray);
     // EAX: index, EDX: array.
     if (!index_info.IsClass(smi_class_)) {
       __ testl(EAX, Immediate(kSmiTagMask));
       __ j(NOT_ZERO, deopt_blob->label());  // Not Smi index.
       PropagateBackLocalClass(node->index_expr(), smi_class_);
@@ skipping 33 matching lines @@
   // array (e.g. in a[x] += 3). Fixes issue 1570.
   {
     CodeGenInfo array_info(node->array());
     node->array()->Visit(this);
     class_of_this_array = array_info.is_class()->raw();
   }
   // 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());
+  const ICData& ic_data = node->ic_data();
   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 (AtIdNodeHasClassAt(node, node->id(), object_array_class, 0)) {
+  if (NodeHasClassAt(node, object_array_class, 0)) {
     // Release CodeGenInfo of index quickly as it may be used in the value,
     // e.g. a[i] += 3. Fixes issue 1570.
     bool index_is_smi = false;
     {
       CodeGenInfo index_info(node->index_expr());
       node->index_expr()->Visit(this);
       index_is_smi = index_info.IsClass(smi_class_);
     }
     VisitLoadOne(node->value(), ECX);
     DeoptimizationBlob* deopt_blob =
@@ skipping 20 matching lines @@
     __ cmpl(EBX, FieldAddress(EAX, Array::length_offset()));
     __ j(ABOVE_EQUAL, deopt_blob->label());  // Range error -> deopt.
     ASSERT(kSmiTagShift == 1);
     __ StoreIntoObject(EAX,
                        FieldAddress(EAX, EBX, TIMES_2, sizeof(RawArray)),
                        ECX);
     HandleResult(node, ECX);
     return;
   }
 
-  if (AtIdNodeHasClassAt(node, node->id(), growable_object_array_class_, 0)) {
+  if (NodeHasClassAt(node, growable_object_array_class_, 0)) {
     bool index_is_smi = false;
     // Release CodeGenInfo of index quickly as it may be used in the value,
     // e.g. a[i] += 3. Fixes issue 1570.
     {
       CodeGenInfo index_info(node->index_expr());
       node->index_expr()->Visit(this);
       index_is_smi = index_info.IsClass(smi_class_);
     }
     VisitLoadOne(node->value(), ECX);
     DeoptimizationBlob* deopt_blob =
@@ skipping 258 matching lines @@
     targets->Add(&null_target);
   }
 }
 
 
 // Use IC data in 'node' to issues checks and calls.
 // IC data can contain one or more argument checks.
 void OptimizingCodeGenerator::GenerateCheckedInstanceCalls(
     AstNode* node,
     AstNode* receiver,
-    intptr_t node_id,
     intptr_t token_index,
     intptr_t num_args,
     const Array& optional_arguments_names) {
   ASSERT(node != NULL);
   ASSERT(receiver != NULL);
   ASSERT(num_args > 0);
-  const ICData& ic_data = node->ICDataAtId(node_id);
+  const ICData& ic_data = node->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     // 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.
     GenerateInlineCacheCall(
-        node_id, token_index, ic_data, num_args, optional_arguments_names);
+        node->id(), token_index, ic_data, num_args, optional_arguments_names);
     return;
   }
 
   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.target_name()),
@@ skipping 11 matching lines @@
   __ movl(EAX, Address(ESP, (num_args - 1) * kWordSize));  // Load receiver.
   if (classes[0]->raw() == smi_class_.raw()) {
     start_ix++;
     // Smi test is needed.
     __ testl(EAX, Immediate(kSmiTagMask));
     if (classes.length() == 1) {
       // Only Smi test.
       DeoptimizationBlob* deopt_blob =
           AddDeoptimizationBlob(node, kDeoptCheckedInstanceCallSmiOnly);
       __ j(NOT_ZERO, deopt_blob->label());
-      GenerateDirectCall(node_id,
+      GenerateDirectCall(node->id(),
                          token_index,
                          *targets[0],
                          num_args,
                          optional_arguments_names);
       return;
     }
     Label not_smi;
     __ j(NOT_ZERO, &not_smi);
-    GenerateDirectCall(node_id,
+    GenerateDirectCall(node->id(),
                        token_index,
                        *targets[0],
                        num_args,
                        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.
   }
   __ movl(EAX, FieldAddress(EAX, Object::class_offset()));  // Receiver's class.
   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 == (classes.length() - 1)) {
       // Last check.
       DeoptimizationBlob* deopt_blob =
           AddDeoptimizationBlob(node, kDeoptCheckedInstanceCallCheckFail);
       __ j(NOT_EQUAL, deopt_blob->label());
-      GenerateDirectCall(node_id,
+      GenerateDirectCall(node->id(),
                          token_index,
                          target,
                          num_args,
                          optional_arguments_names);
     } else {
       Label next;
       __ j(NOT_EQUAL, &next);
-      GenerateDirectCall(node_id,
+      GenerateDirectCall(node->id(),
                          token_index,
                          target,
                          num_args,
                          optional_arguments_names);
       __ jmp(&done);
       __ Bind(&next);
     }
   }
   __ Bind(&done);
 }
 
 
 void OptimizingCodeGenerator::VisitInstanceCallNode(InstanceCallNode* node) {
   const int number_of_arguments = node->arguments()->length() + 1;
   // Compute the receiver object and pass it as first argument to call.
   node->receiver()->Visit(this);
   // Now compute rest of the arguments to the call.
   node->arguments()->Visit(this);
   if (TryInlineInstanceCall(node)) {
     // Instance call is inlined.
   } else {
     GenerateCheckedInstanceCalls(node,
                                  node->receiver(),
-                                 node->id(),
                                  node->token_index(),
                                  number_of_arguments,
                                  node->arguments()->names());
   }
   // Result is in EAX.
   HandleResult(node, EAX);
 }
 
 
 // Returns true if an instance call was replaced with its intrinsic.
 // Returns result in EAX.
 bool OptimizingCodeGenerator::TryInlineInstanceCall(InstanceCallNode* node) {
   const ZoneGrowableArray<const Class*>* classes = CollectedClassesAtNode(node);
   if ((classes != NULL) && (classes->length() == 1)) {
     const int num_arguments = node->arguments()->length() + 1;
     const int num_named_arguments = node->arguments()->names().IsNull() ?
         0 : node->arguments()->names().Length();
     const Function& target = Function::ZoneHandle(
         Resolver::ResolveDynamicForReceiverClass(*(*classes)[0],
                                                  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) &&
-        AtIdNodeHasClassAt(node, node->id(), smi_class_, 0)) {
+        NodeHasClassAt(node, 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, PcDescriptors::kOther);
       // 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) &&
-        AtIdNodeHasClassAt(node, node->id(), double_class_, 0)) {
+        NodeHasClassAt(node, 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 126 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 (AtIdNodeHasClassAt(node, node->id(), smi_class_, 0)) {
-      const ICData& ic_data = node->ICDataAtId(node->id());
+    if (NodeHasClassAt(node, smi_class_, 0)) {
+      const ICData& ic_data = node->ic_data();
       ASSERT(ic_data.num_args_tested() == 1);
       GenerateSmiUnaryOp(node);
       return;
     }
   }
   if (node->kind() == Token::kSUB) {
-    if (AtIdNodeHasClassAt(node, node->id(), double_class_, 0)) {
-      const ICData& ic_data = node->ICDataAtId(node->id());
+    if (NodeHasClassAt(node, double_class_, 0)) {
+      const ICData& ic_data = node->ic_data();
       ASSERT(ic_data.num_args_tested() == 1);
       GenerateDoubleUnaryOp(node);
       return;
     }
   }
   // TODO(srdjan): Implement unary kSUB (negate) Mint.
   CodeGenerator::VisitUnaryOpNode(node);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32