Request for comments on overall approach.

runtime/vm/opt_code_generator_ia32.cc

Index: runtime/vm/opt_code_generator_ia32.cc
diff --git a/runtime/vm/opt_code_generator_ia32.cc b/runtime/vm/opt_code_generator_ia32.cc
index 640ffd5920553940a8de3e891a8e02e18f33d2bd..51802a83ce68b92dc63a4e521fdadf4bf0cb9b91 100644
--- a/runtime/vm/opt_code_generator_ia32.cc
+++ b/runtime/vm/opt_code_generator_ia32.cc
@@ -983,8 +983,7 @@ void OptimizingCodeGenerator::GenerateMintBinaryOp(BinaryOpNode* node,
     __ testl(EAX, Immediate(kSmiTagMask));
     __ j(ZERO, &is_smi);
 
-    __ movl(EBX, FieldAddress(EAX, Object::class_offset()));
-    __ CompareObject(EBX, Class::ZoneHandle(object_store->mint_class()));
+    __ CompareClassOf(EAX, Class::Handle(object_store->mint_class()), EBX);
     __ j(NOT_EQUAL, deopt_blob->label());
 
     // Load lower Mint word, convert to Smi. It is OK to loose bits.
@@ -1049,8 +1048,7 @@ void OptimizingCodeGenerator::CheckIfDoubleOrSmi(Register reg,
                                                  Label* not_double_or_smi) {
   __ testl(reg, Immediate(kSmiTagMask));
   __ j(ZERO, is_smi);
-  __ movl(temp, FieldAddress(reg, Object::class_offset()));
-  __ CompareObject(temp, double_class_);
+  __ CompareClassOf(reg, double_class_, temp);
   __ j(NOT_EQUAL, not_double_or_smi);
 }
 
@@ -1417,14 +1415,14 @@ void OptimizingCodeGenerator::InlineInstanceGettersWithSameTarget(
     __ j(ZERO, deopt_blob->label());
   }
 
-  __ movl(EAX, FieldAddress(EBX, Object::class_offset()));
+  __ LoadObjectClassId(EAX, EBX);
   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();
+    Class& cls = Class::Handle();
     ic_data.GetOneClassCheckAt(i, &cls, &target);
-    __ CompareObject(EAX, cls);
+    __ CompareClassId(EAX, cls);

[Ivan Posva, 2012/05/26 04:34:46]

Not sure about others, but I find this more readable:
__ cmpl(EAX, Immediate(cls.index()));

[Vyacheslav Egorov (Google), 2012/05/26 16:48:22]

ok. I will inline them. I agree that macros does not buy as anything in this
case. I introduced it only because I wanted to be able to quickly find places
where I compare loaded class ids.

     if (i == (ic_data.NumberOfChecks() - 1)) {
       __ j(NOT_EQUAL, deopt_blob->label());
     } else {
@@ -1627,7 +1625,7 @@ void OptimizingCodeGenerator::InlineInstanceSetter(AstNode* node,
     __ testl(recv_reg, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());
   }
-  __ movl(EBX, FieldAddress(recv_reg, Object::class_offset()));
+  __ LoadObjectClassId(EBX, recv_reg);
   // Initialize setter arguments, but leave the class and target fields NULL.
   InstanceSetterArgs setter_args =
       {NULL, NULL, &field_name, recv_reg, value_reg,
@@ -1636,7 +1634,7 @@ void OptimizingCodeGenerator::InlineInstanceSetter(AstNode* node,
   if (unique_target) {
     Label store_field;
     for (intptr_t i = 0; i < classes.length(); i++) {
-      __ CompareObject(EBX, *classes[i]);
+      __ CompareClassId(EBX, *classes[i]);
       if (i == (classes.length() - 1)) {
         __ j(NOT_EQUAL, deopt_blob->label());
       } else {
@@ -1990,10 +1988,10 @@ bool OptimizingCodeGenerator::GenerateEqualityComparison(ComparisonNode* node) {
     // Smi causes deoptimization.
     __ testl(EAX, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());
-    __ movl(EBX, FieldAddress(EAX, Object::class_offset()));
+    __ LoadObjectClassId(EBX, EAX);
     for (intptr_t i = 0; i < num_classes; i++) {
       const Class& cls = *(*classes)[i];
-      __ CompareObject(EBX, cls);
+      __ CompareClassId(EBX, cls);
       if (i == (num_classes - 1)) {
         __ j(NOT_EQUAL, deopt_blob->label());
       } else {
@@ -2171,8 +2169,7 @@ void OptimizingCodeGenerator::VisitLoadIndexedNode(LoadIndexedNode* node) {
     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);
+      __ CompareClassOf(EBX, test_class, EAX);
       __ j(NOT_EQUAL, deopt_blob->label());
       PropagateBackLocalClass(node->array(), test_class);
     }
@@ -2209,8 +2206,7 @@ void OptimizingCodeGenerator::VisitLoadIndexedNode(LoadIndexedNode* node) {
     if (!array_info.IsClass(growable_object_array_class_)) {
       __ testl(EDX, Immediate(kSmiTagMask));
       __ j(ZERO, deopt_blob->label());  // Array is Smi.
-      __ movl(EBX, FieldAddress(EDX, Object::class_offset()));
-      __ CompareObject(EBX, growable_object_array_class_);
+      __ CompareClassOf(EDX, growable_object_array_class_, EBX);
       __ j(NOT_EQUAL, deopt_blob->label());  // Not GrowableObjectArray.
       PropagateBackLocalClass(node->array(), growable_object_array_class_);
     }
@@ -2277,8 +2273,7 @@ void OptimizingCodeGenerator::VisitStoreIndexedNode(StoreIndexedNode* node) {
     if (class_of_this_array.raw() != object_array_class.raw()) {
       __ 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);
+      __ CompareClassOf(EAX, object_array_class, EDX);
       __ j(NOT_EQUAL, deopt_blob->label());  // Not ObjectArray -> deopt.
       PropagateBackLocalClass(node->array(), object_array_class);
     }
@@ -2318,8 +2313,7 @@ void OptimizingCodeGenerator::VisitStoreIndexedNode(StoreIndexedNode* node) {
     if (class_of_this_array.raw() != growable_object_array_class_.raw()) {
       __ testl(EAX, Immediate(kSmiTagMask));
       __ j(ZERO, deopt_blob->label());  // Array is smi -> deopt.
-      __ movl(EDX, FieldAddress(EAX, Object::class_offset()));
-      __ CompareObject(EDX, growable_object_array_class_);
+      __ CompareClassOf(EAX, growable_object_array_class_, EDX);
       __ j(NOT_EQUAL, deopt_blob->label());  // Not GrowableObjectArray.
       PropagateBackLocalClass(node->array(), growable_object_array_class_);
     }
@@ -2647,11 +2641,11 @@ void OptimizingCodeGenerator::GenerateCheckedInstanceCalls(
   } else {
     // Receiver cannot be Smi, no need to test it.
   }
-  __ movl(EAX, FieldAddress(EAX, Object::class_offset()));  // Receiver's class.
+  __ LoadObjectClassId(EAX, EAX);  // 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);
+    __ CompareClassId(EAX, cls);
     if (i == (classes.length() - 1)) {
       // Last check.
       DeoptimizationBlob* deopt_blob =