Remove PropertyCell space

src/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/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 828 matching lines @@
 
 
 void Deserializer::ReadData(Object** current, Object** limit, int source_space,
                             Address current_object_address) {
   Isolate* const isolate = isolate_;
   // Write barrier support costs around 1% in startup time.  In fact there
   // are no new space objects in current boot snapshots, so it's not needed,
   // but that may change.
   bool write_barrier_needed =
       (current_object_address != NULL && source_space != NEW_SPACE &&
-       source_space != CELL_SPACE && source_space != PROPERTY_CELL_SPACE &&
-       source_space != CODE_SPACE);
+       source_space != CELL_SPACE && source_space != CODE_SPACE);
   while (current < limit) {
     byte data = source_.Get();
     switch (data) {
 #define CASE_STATEMENT(where, how, within, space_number) \
   case where + how + within + space_number:              \
     STATIC_ASSERT((where & ~kPointedToMask) == 0);       \
     STATIC_ASSERT((how & ~kHowToCodeMask) == 0);         \
     STATIC_ASSERT((within & ~kWhereToPointMask) == 0);   \
     STATIC_ASSERT((space_number & ~kSpaceMask) == 0);
 
@@ skipping 80 matching lines @@
           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
-// write barrier handling) and handles the other spaces with 8 fall-through
-// cases and one body.
+// write barrier handling) and handles the other spaces with fall-through cases
+// and one body.
 #define ALL_SPACES(where, how, within)                    \
   CASE_STATEMENT(where, how, within, NEW_SPACE)           \
   CASE_BODY(where, how, within, NEW_SPACE)                \
   CASE_STATEMENT(where, how, within, OLD_SPACE)           \
   CASE_STATEMENT(where, how, within, CODE_SPACE)          \
   CASE_STATEMENT(where, how, within, MAP_SPACE)           \
   CASE_STATEMENT(where, how, within, CELL_SPACE)          \
-  CASE_STATEMENT(where, how, within, PROPERTY_CELL_SPACE) \
   CASE_STATEMENT(where, how, within, LO_SPACE)            \
   CASE_BODY(where, how, within, kAnyOldSpace)
 
 #define FOUR_CASES(byte_code)             \
   case byte_code:                         \
   case byte_code + 1:                     \
   case byte_code + 2:                     \
   case byte_code + 3:
 
 #define SIXTEEN_CASES(byte_code)          \
@@ skipping 1578 matching lines @@
   DisallowHeapAllocation no_gc;
   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 v8::internal