Reduced the code sequence for testing for object type....

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 112 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