[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 938 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);            \
-      isolate->heap()->RecordWrite(                                            \
+      isolate->heap()->RecordWriteSlow(                                        \

[Michael Lippautz, 2016/02/05 12:44:40]

I tried switching this to the fast check, which assumes that we have a valid
Object* already, but unfortunately some tests crashed.

So I assume that current_object_address could also be some off-heap address at
this point (which requires the slow version to be filtered out).  Is this the
case?

[Yang, 2016/02/05 12:54:05]

Yes I think this is the case. The deserializer is an object visitor that
iterates the heap. There we also iterate addresses that are not on the heap, for
example builtins code list.

[Michael Lippautz, 2016/02/08 18:00:38]

Actually, we are in a path where we can cast to Object*, as we've ruled out
builtins already above. I was lacking the pointer tag though, leading to misses
entries.

           current_object_address,                                              \
           static_cast<int>(current_address - current_object_address));         \
     }                                                                          \
     if (!current_was_incremented) {                                            \
       current++;                                                               \
     }                                                                          \
     break;                                                                     \
   }
 
 // This generates a case and a body for the new space (which has to do extra
@@ skipping 215 matching lines @@
         // 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)) {
           Address current_address = reinterpret_cast<Address>(current);
-          isolate->heap()->RecordWrite(
+          isolate->heap()->RecordWriteSlow(
               current_object_address,
               static_cast<int>(current_address - current_object_address));
         }
         current++;
         break;
       }
 
       // Deserialize raw data of fixed length from 1 to 32 words.
       STATIC_ASSERT(kNumberOfFixedRawData == 32);
       SIXTEEN_CASES(kFixedRawData)
@@ skipping 1583 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