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

src/ic-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 52 matching lines @@
   // Load the map into r0.
   __ mov(r0, FieldOperand(r1, JSObject::kMapOffset));
   // Test the has_named_interceptor bit in the map.
   __ test(FieldOperand(r0, Map::kInstanceAttributesOffset),
           Immediate(1 << (Map::kHasNamedInterceptor + (3 * 8))));
 
   // Jump to miss if the interceptor bit is set.
   __ j(not_zero, miss_label, not_taken);
 
   // Bail out if we have a JS global object.
-  __ movzx_b(r0, FieldOperand(r0, Map::kInstanceTypeOffset));
-  __ cmp(r0, JS_GLOBAL_OBJECT_TYPE);
+  __ CmpInstanceType(r0, JS_GLOBAL_OBJECT_TYPE);
   __ j(equal, miss_label, not_taken);
 
   // Check that the properties array is a dictionary.
   __ mov(r0, FieldOperand(r1, JSObject::kPropertiesOffset));
   __ cmp(FieldOperand(r0, HeapObject::kMapOffset),
          Immediate(Factory::hash_table_map()));
   __ j(not_equal, miss_label);
 
   // Compute the capacity mask.
   const int kCapacityOffset =
@@ skipping 44 matching lines @@
 
 // Helper function used to check that a value is either not a function
 // or is loaded if it is a function.
 static void GenerateCheckNonFunctionOrLoaded(MacroAssembler* masm, Label* miss,
                                              Register value, Register scratch) {
   Label done;
   // Check if the value is a Smi.
   __ test(value, Immediate(kSmiTagMask));
   __ j(zero, &done, not_taken);
   // Check if the value is a function.
-  __ mov(scratch, FieldOperand(value, HeapObject::kMapOffset));
-  __ movzx_b(scratch, FieldOperand(scratch, Map::kInstanceTypeOffset));
-  __ cmp(scratch, JS_FUNCTION_TYPE);
+  __ CmpObjectType(value, JS_FUNCTION_TYPE, scratch);
   __ j(not_equal, &done, taken);
   // Check if the function has been loaded.
   __ mov(scratch, FieldOperand(value, JSFunction::kSharedFunctionInfoOffset));
   __ mov(scratch,
          FieldOperand(scratch, SharedFunctionInfo::kLazyLoadDataOffset));
   __ cmp(scratch, Factory::undefined_value());
   __ j(not_equal, miss, not_taken);
   __ bind(&done);
 }
 
@@ skipping 288 matching lines @@
   StubCache::GenerateProbe(masm, flags, edx, ecx, ebx);
 
   // If the stub cache probing failed, the receiver might be a value.
   // For value objects, we use the map of the prototype objects for
   // the corresponding JSValue for the cache and that is what we need
   // to probe.
   //
   // Check for number.
   __ test(edx, Immediate(kSmiTagMask));
   __ j(zero, &number, not_taken);
-  __ mov(ebx, FieldOperand(edx, HeapObject::kMapOffset));
-  __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
-  __ cmp(ebx, HEAP_NUMBER_TYPE);
+  __ CmpObjectType(edx, HEAP_NUMBER_TYPE, ebx);
   __ j(not_equal, &non_number, taken);
   __ bind(&number);
   StubCompiler::GenerateLoadGlobalFunctionPrototype(
       masm, Context::NUMBER_FUNCTION_INDEX, edx);
   __ jmp(&probe);
 
   // Check for string.
   __ bind(&non_number);
   __ cmp(ebx, FIRST_NONSTRING_TYPE);
   __ j(above_equal, &non_string, taken);
@@ skipping 27 matching lines @@
                                  Label* miss) {
   // Search dictionary - put result in register edx.
   GenerateDictionaryLoad(masm, miss, eax, edx, ebx, ecx);
 
   // Move the result to register edi and check that it isn't a smi.
   __ mov(edi, Operand(edx));
   __ test(edx, Immediate(kSmiTagMask));
   __ j(zero, miss, not_taken);
 
   // Check that the value is a JavaScript function.
-  __ mov(edx, FieldOperand(edx, HeapObject::kMapOffset));
-  __ movzx_b(edx, FieldOperand(edx, Map::kInstanceTypeOffset));
-  __ cmp(edx, JS_FUNCTION_TYPE);
+  __ CmpObjectType(edx, JS_FUNCTION_TYPE, edx);
   __ j(not_equal, miss, not_taken);
 
   // Check that the function has been loaded.
   __ mov(edx, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
   __ mov(edx, FieldOperand(edx, SharedFunctionInfo::kLazyLoadDataOffset));
   __ cmp(edx, Factory::undefined_value());
   __ j(not_equal, miss, not_taken);
 
   // Patch the receiver with the global proxy if necessary.
   if (is_global_object) {
@@ skipping 382 matching lines @@
 
   // Do tail-call to runtime routine.
   __ TailCallRuntime(
       ExternalReference(IC_Utility(kSharedStoreIC_ExtendStorage)), 3);
 }
 
 #undef __
 
 
 } }  // namespace v8::internal