Make InToSpace/InFromSpace use the page header.

src/ia32/code-stubs-ia32.cc

 // Copyright 2011 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 5998 matching lines @@
   __ mov(value_, Operand(address_, 0));
   GenerateIncremental(masm);
 }
 
 
 void RecordWriteStub::GenerateIncremental(MacroAssembler* masm) {
   regs_.Save(masm);
 
   Label value_in_old_space;
 
-  __ CheckPageFlag(value_, regs_.scratch0(),
-                   MemoryChunk::IN_NEW_SPACE, zero,
-                   &value_in_old_space);
+  __ InNewSpace(value_, regs_.scratch0(), not_equal, &value_in_old_space);
   // After this point the value_ register may have been overwritten since it is
   // also one of the scratch registers.
 
   GenerateIncrementalValueIsInNewSpace(masm);
 
   __ bind(&value_in_old_space);
   GenerateIncrementalValueIsInOldSpace(masm);
 
   __ bind(&slow_);
   // Inform the incremental marker, but don't bother with the remembered set.
@@ skipping 18 matching lines @@
   __ ret(0);
 }
 
 
 void RecordWriteStub::GenerateIncrementalValueIsInNewSpace(
     MacroAssembler* masm) {
   Label both_in_new_space;
   Label value_in_new_space_object_is_black_no_remembered_set;
 
   // The value is in new space.  Check the object.
-  __ CheckPageFlag(regs_.object(), regs_.scratch0(),
-                   MemoryChunk::IN_NEW_SPACE, not_zero,
-                   &both_in_new_space);
+  __ InNewSpace(regs_.object(), regs_.scratch0(), equal, &both_in_new_space);
 
   // Value is in new space, object is in old space.  Could we be lucky and find
   // the scan_on_scavenge flag on the object's page?
   if (emit_remembered_set_ == EMIT_REMEMBERED_SET) {
     Label scan_on_scavenge;
     __ CheckPageFlag(regs_.object(),
                      regs_.scratch0(),
                      MemoryChunk::SCAN_ON_SCAVENGE,
                      not_zero,
                      &scan_on_scavenge);
@@ skipping 124 matching lines @@
                     &value_is_white,
                     false);  // In old space.
   __ pop(regs_.object());
   regs_.Restore(masm);
   __ ret(0);
 
   // The value is in old space and white.  We have to find out which space the
   // object is in in order to find its colour.
   __ bind(&value_is_white);
   __ pop(regs_.object());
-  __ CheckPageFlag(regs_.object(), regs_.scratch0(),
-                   MemoryChunk::IN_NEW_SPACE, not_zero,
-                   &value_in_old_space_and_white_object_in_new_space);
+  __ InNewSpace(regs_.object(), regs_.scratch0(), equal,
+                &value_in_old_space_and_white_object_in_new_space);
 
   // Both in old space, value is white and can't be marked.
   __ InOldSpaceIsBlack(regs_.object(),
                        regs_.scratch0(),
                        regs_.scratch1(),
                        &slow_);
   regs_.Restore(masm);
   __ ret(0);
 
   // Object in new space, value in old space and white and can't be marked.
   __ bind(&value_in_old_space_and_white_object_in_new_space);
   __ InNewSpaceIsBlack(regs_.object(),
                        regs_.scratch0(),
                        regs_.scratch1(),
                        &slow_);
   regs_.Restore(masm);
   __ ret(0);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32