Refactored the code for comparing the type of an object with a constant....

src/codegen-ia32.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1916 matching lines @@
   ASSERT(kSmiTagSize == 1 && kSmiTag == 0);
   Result switch_value = frame_->Pop();
   switch_value.ToRegister();
   __ test(switch_value.reg(), Immediate(kSmiTagMask));
   is_smi.Branch(equal, &switch_value, taken);
 
   // It's a heap object, not a smi or a failure.  Check if it is a
   // heap number.
   Result temp = allocator()->Allocate();
   ASSERT(temp.is_valid());
-  __ mov(temp.reg(), FieldOperand(switch_value.reg(), HeapObject::kMapOffset));
-  __ movzx_b(temp.reg(), FieldOperand(temp.reg(), Map::kInstanceTypeOffset));
-  __ cmp(temp.reg(), HEAP_NUMBER_TYPE);
+  __ CmpObjectType(switch_value.reg(), HEAP_NUMBER_TYPE, temp.reg());
   temp.Unuse();
   default_target->Branch(not_equal);
 
   // The switch value is a heap number.  Convert it to a smi.
   frame_->Push(&switch_value);
   Result smi_value = frame_->CallRuntime(Runtime::kNumberToSmi, 1);
 
   is_smi.Bind(&smi_value);
   smi_value.ToRegister();
   // Convert the switch value to a 0-based table index.
@@ skipping 2165 matching lines @@
   ASSERT(args->length() == 1);
   Load(args->at(0));
   Result value = frame_->Pop();
   value.ToRegister();
   ASSERT(value.is_valid());
   __ test(value.reg(), Immediate(kSmiTagMask));
   destination()->false_target()->Branch(equal);
   // It is a heap object - get map.
   Result temp = allocator()->Allocate();
   ASSERT(temp.is_valid());
-  __ mov(temp.reg(), FieldOperand(value.reg(), HeapObject::kMapOffset));
-  __ movzx_b(temp.reg(), FieldOperand(temp.reg(), Map::kInstanceTypeOffset));
   // Check if the object is a JS array or not.
-  __ cmp(temp.reg(), JS_ARRAY_TYPE);
+  __ CmpObjectType(value.reg(), JS_ARRAY_TYPE, temp.reg());
   value.Unuse();
   temp.Unuse();
   destination()->Split(equal);
 }
 
 
 void CodeGenerator::GenerateArgumentsLength(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 0);
   Result initial_value = allocator()->Allocate(eax);
   ASSERT(initial_value.is_valid());
@@ skipping 15 matching lines @@
   frame_->Dup();
   Result object = frame_->Pop();
   object.ToRegister();
   ASSERT(object.is_valid());
   // if (object->IsSmi()) return object.
   __ test(object.reg(), Immediate(kSmiTagMask));
   leave.Branch(zero, taken);
   // It is a heap object - get map.
   Result temp = allocator()->Allocate();
   ASSERT(temp.is_valid());
-  __ mov(temp.reg(), FieldOperand(object.reg(), HeapObject::kMapOffset));
-  __ movzx_b(temp.reg(), FieldOperand(temp.reg(), Map::kInstanceTypeOffset));
   // if (!object->IsJSValue()) return object.
-  __ cmp(temp.reg(), JS_VALUE_TYPE);
+  __ CmpObjectType(object.reg(), JS_VALUE_TYPE, temp.reg());
   leave.Branch(not_equal, not_taken);
   __ mov(temp.reg(), FieldOperand(object.reg(), JSValue::kValueOffset));
   object.Unuse();
   frame_->SetElementAt(0, &temp);
   leave.Bind();
 }
 
 
 void CodeGenerator::GenerateSetValueOf(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 2);
   JumpTarget leave(this);
   Load(args->at(0));  // Load the object.
   Load(args->at(1));  // Load the value.
   Result value = frame_->Pop();
   Result object = frame_->Pop();
   value.ToRegister();
   object.ToRegister();
 
   // if (object->IsSmi()) return value.
   __ test(object.reg(), Immediate(kSmiTagMask));
   leave.Branch(zero, &value, taken);
 
   // It is a heap object - get its map.
   Result scratch = allocator_->Allocate();
   ASSERT(scratch.is_valid());
-  __ mov(scratch.reg(), FieldOperand(object.reg(), HeapObject::kMapOffset));
-  __ movzx_b(scratch.reg(),
-             FieldOperand(scratch.reg(), Map::kInstanceTypeOffset));
   // if (!object->IsJSValue()) return value.
-  __ cmp(scratch.reg(), JS_VALUE_TYPE);
+  __ CmpObjectType(object.reg(), JS_VALUE_TYPE, scratch.reg());
   leave.Branch(not_equal, &value, not_taken);
 
   // Store the value.
   __ mov(FieldOperand(object.reg(), JSValue::kValueOffset), value.reg());
   // Update the write barrier.  Save the value as it will be
   // overwritten by the write barrier code and is needed afterward.
   Result duplicate_value = allocator_->Allocate();
   ASSERT(duplicate_value.is_valid());
   __ mov(duplicate_value.reg(), value.reg());
   // The object register is also overwritten by the write barrier and
@@ skipping 693 matching lines @@
       __ movzx_b(answer.reg(),
                  FieldOperand(answer.reg(), Map::kBitFieldOffset));
       __ test(answer.reg(), Immediate(1 << Map::kIsUndetectable));
       answer.Unuse();
       destination()->Split(not_zero);
 
     } else if (check->Equals(Heap::function_symbol())) {
       __ test(answer.reg(), Immediate(kSmiTagMask));
       destination()->false_target()->Branch(zero);
       frame_->Spill(answer.reg());
-      __ mov(answer.reg(), FieldOperand(answer.reg(), HeapObject::kMapOffset));
-      __ movzx_b(answer.reg(),
-                 FieldOperand(answer.reg(), Map::kInstanceTypeOffset));
-      __ cmp(answer.reg(), JS_FUNCTION_TYPE);
+      __ CmpObjectType(answer.reg(), JS_FUNCTION_TYPE, answer.reg());
       answer.Unuse();
       destination()->Split(equal);
 
     } else if (check->Equals(Heap::object_symbol())) {
       __ test(answer.reg(), Immediate(kSmiTagMask));
       destination()->false_target()->Branch(zero);
       __ cmp(answer.reg(), Factory::null_value());
       destination()->true_target()->Branch(equal);
 
       // It can be an undetectable object.
@@ skipping 1476 matching lines @@
 void CallFunctionStub::Generate(MacroAssembler* masm) {
   Label slow;
 
   // Get the function to call from the stack.
   // +2 ~ receiver, return address
   __ mov(edi, Operand(esp, (argc_ + 2) * kPointerSize));
 
   // Check that the function really is a JavaScript function.
   __ test(edi, Immediate(kSmiTagMask));
   __ j(zero, &slow, not_taken);
-  // Get the map.
-  __ mov(ecx, FieldOperand(edi, HeapObject::kMapOffset));
-  __ movzx_b(ecx, FieldOperand(ecx, Map::kInstanceTypeOffset));
-  __ cmp(ecx, JS_FUNCTION_TYPE);
+  // Goto slow case if we do not have a function.
+  __ CmpObjectType(edi, JS_FUNCTION_TYPE, ecx);
   __ j(not_equal, &slow, not_taken);
 
   // Fast-case: Just invoke the function.
   ParameterCount actual(argc_);
   __ InvokeFunction(edi, actual, JUMP_FUNCTION);
 
   // Slow-case: Non-function called.
   __ bind(&slow);
   __ Set(eax, Immediate(argc_));
   __ Set(ebx, Immediate(0));
@@ skipping 401 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal