[heap] Move to page lookups for SemiSpace, NewSpace, and Heap containment methods

src/snapshot/serialize.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/snapshot/serialize.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 36 matching lines @@
 ExternalReferenceTable::ExternalReferenceTable(Isolate* isolate) {
   // Miscellaneous
   Add(ExternalReference::roots_array_start(isolate).address(),
       "Heap::roots_array_start()");
   Add(ExternalReference::address_of_stack_limit(isolate).address(),
       "StackGuard::address_of_jslimit()");
   Add(ExternalReference::address_of_real_stack_limit(isolate).address(),
       "StackGuard::address_of_real_jslimit()");
   Add(ExternalReference::new_space_start(isolate).address(),
       "Heap::NewSpaceStart()");
-  Add(ExternalReference::new_space_mask(isolate).address(),
-      "Heap::NewSpaceMask()");
   Add(ExternalReference::new_space_allocation_limit_address(isolate).address(),
       "Heap::NewSpaceAllocationLimitAddress()");
   Add(ExternalReference::new_space_allocation_top_address(isolate).address(),
       "Heap::NewSpaceAllocationTopAddress()");
   Add(ExternalReference::mod_two_doubles_operation(isolate).address(),
       "mod_two_doubles");
   // Keyed lookup cache.
   Add(ExternalReference::keyed_lookup_cache_keys(isolate).address(),
       "KeyedLookupCache::keys()");
   Add(ExternalReference::keyed_lookup_cache_field_offsets(isolate).address(),
@@ skipping 865 matching lines @@
     STATIC_ASSERT((within & ~kWhereToPointMask) == 0);   \
     STATIC_ASSERT((space_number & ~kSpaceMask) == 0);
 
 #define CASE_BODY(where, how, within, space_number_if_any)                     \
   {                                                                            \
     bool emit_write_barrier = false;                                           \
     bool current_was_incremented = false;                                      \
     int space_number = space_number_if_any == kAnyOldSpace                     \
                            ? (data & kSpaceMask)                               \
                            : space_number_if_any;                              \
+    Object* new_object = NULL; /* May not be a real Object pointer. */         \
     if (where == kNewObject && how == kPlain && within == kStartOfObject) {    \
       ReadObject(space_number, current);                                       \
       emit_write_barrier = (space_number == NEW_SPACE);                        \
     } else {                                                                   \
-      Object* new_object = NULL; /* May not be a real Object pointer. */       \
       if (where == kNewObject) {                                               \
         ReadObject(space_number, &new_object);                                 \
       } else if (where == kBackref) {                                          \
         emit_write_barrier = (space_number == NEW_SPACE);                      \
         new_object = GetBackReferencedObject(data & kSpaceMask);               \
       } else if (where == kBackrefWithSkip) {                                  \
         int skip = source_.GetInt();                                           \
         current = reinterpret_cast<Object**>(                                  \
             reinterpret_cast<Address>(current) + skip);                        \
         emit_write_barrier = (space_number == NEW_SPACE);                      \
@@ skipping 48 matching lines @@
             reinterpret_cast<Address>(new_object));                            \
         location_of_branch_data += Assembler::kSpecialTargetSize;              \
         current = reinterpret_cast<Object**>(location_of_branch_data);         \
         current_was_incremented = true;                                        \
       } else {                                                                 \
         UnalignedCopy(current, &new_object);                                   \
       }                                                                        \
     }                                                                          \
     if (emit_write_barrier && write_barrier_needed) {                          \
       Address current_address = reinterpret_cast<Address>(current);            \
+      /* Builtins have been filtered above, so we are on-heap. */              \
       isolate->heap()->RecordWrite(                                            \
-          current_object_address,                                              \
-          static_cast<int>(current_address - current_object_address));         \
+          reinterpret_cast<Object*>(current_object_address + 1),               \
+          static_cast<int>(current_address - current_object_address),          \
+          new_object);                                                         \
     }                                                                          \
     if (!current_was_incremented) {                                            \
       current++;                                                               \
     }                                                                          \
     break;                                                                     \
   }
 
 // This generates a case and a body for the new space (which has to do extra
 // write barrier handling) and handles the other spaces with fall-through cases
 // and one body.
@@ skipping 211 matching lines @@
         current = reinterpret_cast<Object**>(
             reinterpret_cast<Address>(current) + skip);
         // Fall through.
       }
 
       FOUR_CASES(kHotObject)
       FOUR_CASES(kHotObject + 4) {
         int index = data & kHotObjectMask;
         Object* hot_object = hot_objects_.Get(index);
         UnalignedCopy(current, &hot_object);
-        if (write_barrier_needed && isolate->heap()->InNewSpace(hot_object)) {
+        if (write_barrier_needed) {
           Address current_address = reinterpret_cast<Address>(current);
           isolate->heap()->RecordWrite(
-              current_object_address,
-              static_cast<int>(current_address - current_object_address));
+              reinterpret_cast<Object*>(current_object_address + 1),
+              static_cast<int>(current_address - current_object_address),
+              hot_object);
         }
         current++;
         break;
       }
 
       // Deserialize raw data of fixed length from 1 to 32 words.
       STATIC_ASSERT(kNumberOfFixedRawData == 32);
       SIXTEEN_CASES(kFixedRawData)
       SIXTEEN_CASES(kFixedRawData + 16) {
         byte* raw_data_out = reinterpret_cast<byte*>(current);
@@ skipping 1581 matching lines @@
   SerializedCodeData* scd = new SerializedCodeData(cached_data);
   SanityCheckResult r = scd->SanityCheck(isolate, source);
   if (r == CHECK_SUCCESS) return scd;
   cached_data->Reject();
   source->GetIsolate()->counters()->code_cache_reject_reason()->AddSample(r);
   delete scd;
   return NULL;
 }
 }  // namespace internal
 }  // namespace v8