Use Heap::kOld when allocating objects for script snapshots.

runtime/vm/raw_object_snapshot.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 #define NEW_OBJECT(type)                                                       \
   ((kind == Snapshot::kFull) ? reader->New##type() : type::New())
 
 #define NEW_OBJECT_WITH_LEN(type, len)                                         \
   ((kind == Snapshot::kFull) ? reader->New##type(len) : type::New(len))
 
+#define NEW_OBJECT_WITH_LEN_SPACE(type, len, kind)                             \
+  ((kind == Snapshot::kFull) ?                                                 \
+  reader->New##type(len) : type::New(len, space(kind)))
+
 
 static uword BigintAllocator(intptr_t size) {
   Zone* zone = Isolate::Current()->current_zone();
   return zone->AllocUnsafe(size);
 }
 
 
+static Heap::Space space(Snapshot::Kind kind) {
+  return (kind == Snapshot::kMessage) ? Heap::kNew : Heap::kOld;
+}
+
+
 RawClass* Class::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   Class& cls = Class::ZoneHandle(reader->isolate(), Class::null());
   if ((kind == Snapshot::kFull) ||
       (kind == Snapshot::kScript && !RawObject::IsCreatedFromSnapshot(tags))) {
     // Read in the base information.
@@ skipping 273 matching lines @@
 RawTypeArguments* TypeArguments::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
   intptr_t len = reader->ReadSmiValue();
 
   TypeArguments& type_arguments = TypeArguments::ZoneHandle(
-      reader->isolate(), NEW_OBJECT_WITH_LEN(TypeArguments, len));
+      reader->isolate(), NEW_OBJECT_WITH_LEN_SPACE(TypeArguments, len, kind));
   reader->AddBackRef(object_id, &type_arguments, kIsDeserialized);
 
   // Now set all the object fields.
   for (intptr_t i = 0; i < len; i++) {
     *reader->TypeHandle() ^= reader->ReadObjectImpl();
     type_arguments.SetTypeAt(i, *reader->TypeHandle());
   }
 
   // Set the object tags (This is done after setting the object fields
   // because 'SetTypeAt' has an assertion to check if the object is not
@@ skipping 34 matching lines @@
 RawInstantiatedTypeArguments* InstantiatedTypeArguments::ReadFrom(
     SnapshotReader* reader,
     intptr_t object_id,
     intptr_t tags,
     Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Allocate instantiated types object.
   InstantiatedTypeArguments& instantiated_type_arguments =
-      InstantiatedTypeArguments::ZoneHandle(reader->isolate(),
-                                            InstantiatedTypeArguments::New());
+      InstantiatedTypeArguments::ZoneHandle(

[cshapiro, 2012/08/25 03:30:11]

Perhaps I have missed something subtle, but the change on this line looks like
noise.  If I am indeed right, can we remove this delta?

[siva, 2012/08/27 17:15:21]

Done.

+          reader->isolate(), InstantiatedTypeArguments::New());
   reader->AddBackRef(object_id, &instantiated_type_arguments, kIsDeserialized);
 
   // Set the object tags.
   instantiated_type_arguments.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (instantiated_type_arguments.raw()->to() -
                        instantiated_type_arguments.raw()->from());
@@ skipping 618 matching lines @@
                               intptr_t tags,
                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate context object.
   intptr_t num_vars = reader->ReadIntptrValue();
   Context& context = Context::ZoneHandle(reader->isolate(), Context::null());
   if (kind == Snapshot::kFull) {
     context = reader->NewContext(num_vars);
   } else {
-    context = Context::New(num_vars);
+    context = Context::New(num_vars, space(kind));
   }
   reader->AddBackRef(object_id, &context, kIsDeserialized);
 
   // Set the object tags.
   context.set_tags(tags);
 
   // Set the isolate implicitly.
   context.set_isolate(Isolate::Current());
 
   // Set all the object fields.
@@ skipping 276 matching lines @@
   int64_t value = reader->Read<int64_t>();
 
   // Create a Mint object or get canonical one if it is a canonical constant.
   Mint& mint = Mint::ZoneHandle(reader->isolate(), Mint::null());
   if (kind == Snapshot::kFull) {
     mint = reader->NewMint(value);
   } else {
     if (RawObject::IsCanonical(tags)) {
       mint = Mint::NewCanonical(value);
     } else {
-      mint = Mint::New(value, Heap::kNew);
+      mint = Mint::New(value, space(kind));
     }
   }
   reader->AddBackRef(object_id, &mint, kIsDeserialized);
 
   // Set the object tags.
   mint.set_tags(tags);
 
   return mint.raw();
 }
 
@@ skipping 23 matching lines @@
 
   // Read in the HexCString representation of the bigint.
   intptr_t len = reader->ReadIntptrValue();
   char* str = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   str[len] = '\0';
   reader->ReadBytes(reinterpret_cast<uint8_t*>(str), len);
 
   // Create a Bigint object from HexCString.
   Bigint& obj = Bigint::ZoneHandle(
       reader->isolate(),
-      (kind == Snapshot::kFull) ? reader->NewBigint(str) :
-                                  BigintOperations::FromHexCString(str));
+      ((kind == Snapshot::kFull) ? reader->NewBigint(str) :
+       BigintOperations::FromHexCString(str, space(kind))));
 
   // If it is a canonical constant make it one.
   if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags)) {
     obj ^= obj.Canonicalize();
   }
   reader->AddBackRef(object_id, &obj, kIsDeserialized);
 
   // Set the object tags.
   obj.set_tags(tags);
 
@@ skipping 52 matching lines @@
   double value = reader->Read<double>();
 
   // Create a Double object or get canonical one if it is a canonical constant.
   Double& dbl = Double::ZoneHandle(reader->isolate(), Double::null());
   if (kind == Snapshot::kFull) {
     dbl = reader->NewDouble(value);
   } else {
     if (RawObject::IsCanonical(tags)) {
       dbl = Double::NewCanonical(value);
     } else {
-      dbl = Double::New(value, Heap::kNew);
+      dbl = Double::New(value, space(kind));
     }
   }
   reader->AddBackRef(object_id, &dbl, kIsDeserialized);
 
   // Set the object tags.
   dbl.set_tags(tags);
 
   return dbl.raw();
 }
 
@@ skipping 28 matching lines @@
                         intptr_t object_id,
                         Snapshot::Kind kind) {
   UNREACHABLE();  // String is an abstract class.
 }
 
 
 template<typename HandleType, typename CharacterType>
 void String::ReadFromImpl(SnapshotReader* reader,
                           HandleType* str_obj,
                           intptr_t len,
-                          intptr_t tags) {
+                          intptr_t tags,
+                          Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   if (RawObject::IsCanonical(tags)) {
     // Set up canonical string object.
     ASSERT(reader != NULL);
     CharacterType* ptr =
         Isolate::Current()->current_zone()->Alloc<CharacterType>(len);
     for (intptr_t i = 0; i < len; i++) {
       ptr[i] = reader->Read<CharacterType>();
     }
     *str_obj ^= Symbols::New(ptr, len);
   } else {
     // Set up the string object.
-    *str_obj = HandleType::New(len, Heap::kNew);
+    *str_obj = HandleType::New(len, space(kind));
     str_obj->set_tags(tags);
     str_obj->SetHash(0);  // Will get computed when needed.
     for (intptr_t i = 0; i < len; i++) {
       *str_obj->CharAddr(i) = reader->Read<CharacterType>();
     }
   }
 }
 
 
 RawOneByteString* OneByteString::ReadFrom(SnapshotReader* reader,
@@ skipping 12 matching lines @@
     RawOneByteString* obj = reader->NewOneByteString(len);
     str_obj = obj;
     str_obj.set_tags(tags);
     obj->ptr()->hash_ = Smi::New(hash);
     if (len > 0) {
       uint8_t* raw_ptr = str_obj.CharAddr(0);
       reader->ReadBytes(raw_ptr, len);
     }
     ASSERT((hash == 0) || (String::Hash(str_obj, 0, str_obj.Length()) == hash));
   } else {
-    ReadFromImpl<OneByteString, uint8_t>(reader, &str_obj, len, tags);
+    ReadFromImpl<OneByteString, uint8_t>(reader, &str_obj, len, tags, kind);
   }
   reader->AddBackRef(object_id, &str_obj, kIsDeserialized);
   return str_obj.raw();
 }
 
 
 RawTwoByteString* TwoByteString::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
@@ skipping 10 matching lines @@
     str_obj.set_tags(tags);
     obj->ptr()->hash_ = Smi::New(hash);
     uint16_t* raw_ptr = (len > 0)? str_obj.CharAddr(0) : NULL;
     for (intptr_t i = 0; i < len; i++) {
       ASSERT(str_obj.CharAddr(i) == raw_ptr);  // Will trigger assertions.
       *raw_ptr = reader->Read<uint16_t>();
       raw_ptr += 1;
     }
     ASSERT(String::Hash(str_obj, 0, str_obj.Length()) == hash);
   } else {
-    ReadFromImpl<TwoByteString, uint16_t>(reader, &str_obj, len, tags);
+    ReadFromImpl<TwoByteString, uint16_t>(reader, &str_obj, len, tags, kind);
   }
   reader->AddBackRef(object_id, &str_obj, kIsDeserialized);
   return str_obj.raw();
 }
 
 
 RawFourByteString* FourByteString::ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind) {
@@ skipping 10 matching lines @@
     str_obj.set_tags(tags);
     obj->ptr()->hash_ = Smi::New(hash);
     uint32_t* raw_ptr = (len > 0)? str_obj.CharAddr(0) : NULL;
     for (intptr_t i = 0; i < len; i++) {
       ASSERT(str_obj.CharAddr(i) == raw_ptr);  // Will trigger assertions.
       *raw_ptr = reader->Read<uint32_t>();
       raw_ptr += 1;
     }
     ASSERT(String::Hash(str_obj, 0, str_obj.Length()) == hash);
   } else {
-    ReadFromImpl<FourByteString, uint32_t>(reader, &str_obj, len, tags);
+    ReadFromImpl<FourByteString, uint32_t>(reader, &str_obj, len, tags, kind);
   }
   reader->AddBackRef(object_id, &str_obj, kIsDeserialized);
   return str_obj.raw();
 }
 
 
 template<typename T>
 static void StringWriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind,
@@ skipping 169 matching lines @@
                           intptr_t tags,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
   intptr_t len = reader->ReadSmiValue();
   Array* array = reinterpret_cast<Array*>(
       reader->GetBackRef(object_id));
   if (array == NULL) {
     array = &(Array::ZoneHandle(reader->isolate(),
-                                NEW_OBJECT_WITH_LEN(Array, len)));
+                                NEW_OBJECT_WITH_LEN_SPACE(Array, len, kind)));
     reader->AddBackRef(object_id, array, kIsDeserialized);
   }
   reader->ArrayReadFrom(*array, len, tags);
   return array->raw();
 }
 
 
 RawImmutableArray* ImmutableArray::ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
   intptr_t len = reader->ReadSmiValue();
   ImmutableArray* array = reinterpret_cast<ImmutableArray*>(
       reader->GetBackRef(object_id));
   if (array == NULL) {
     array = &(ImmutableArray::ZoneHandle(
-        reader->isolate(), NEW_OBJECT_WITH_LEN(ImmutableArray, len)));
+        reader->isolate(),
+        NEW_OBJECT_WITH_LEN_SPACE(ImmutableArray, len, kind)));
     reader->AddBackRef(object_id, array, kIsDeserialized);
   }
   reader->ArrayReadFrom(*array, len, tags);
   return array->raw();
 }
 
 
 void RawArray::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind) {
@@ skipping 23 matching lines @@
                                                       intptr_t tags,
                                                       Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
   GrowableObjectArray& array = GrowableObjectArray::ZoneHandle(
       reader->isolate(), GrowableObjectArray::null());
   if (kind == Snapshot::kFull) {
     array = reader->NewGrowableObjectArray();
   } else {
-    array = GrowableObjectArray::New(0);
+    array = GrowableObjectArray::New(0, space(kind));
   }
   reader->AddBackRef(object_id, &array, kIsDeserialized);
   intptr_t length = reader->ReadSmiValue();
   array.SetLength(length);
   Array& contents = Array::Handle();
   contents ^= reader->ReadObjectImpl();
   array.SetData(contents);
   const AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(contents.GetTypeArguments());
   array.SetTypeArguments(type_arguments);
@@ skipping 31 matching lines @@
 
 
 template<typename HandleT, typename RawT, typename ElementT>
 RawT* ByteArray::ReadFromImpl(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   intptr_t len = reader->ReadSmiValue();
-  Heap::Space space = (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew;
-  HandleT& result =
-      HandleT::ZoneHandle(reader->isolate(), HandleT::New(len, space));
+  HandleT& result = HandleT::ZoneHandle(
+      reader->isolate(), HandleT::New(len, space(kind)));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   // Set the object tags.
   result.set_tags(tags);
 
   // Setup the array elements.
   for (intptr_t i = 0; i < len; ++i) {
     result.SetAt(i, reader->Read<ElementT>());
   }
   return result.raw();
@@ skipping 37 matching lines @@
     Snapshot::Kind kind) {                                                     \
   ASSERT(kind != Snapshot::kFull);                                             \
   intptr_t length = reader->ReadSmiValue();                                    \
   type* data = reinterpret_cast<type*>(reader->ReadIntptrValue());             \
   void* peer = reinterpret_cast<void*>(reader->ReadIntptrValue());             \
   Dart_PeerFinalizer callback =                                                \
       reinterpret_cast<Dart_PeerFinalizer>(reader->ReadIntptrValue());         \
   const Class& cls = Class::Handle(                                            \
       reader->isolate()->object_store()->external_##lname##_array_class());    \
   return NewExternalImpl<External##name##Array, RawExternal##name##Array>(     \
-      cls, data, length, peer, callback, Heap::kNew);                          \
+      cls, data, length, peer, callback, space(kind));                         \
 }                                                                              \
 
 
 BYTEARRAY_TYPE_LIST(EXTERNALARRAY_READ_FROM)
 #undef EXTERNALARRAY_READ_FROM
 
 
 static void ByteArrayWriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind,
@@ skipping 118 matching lines @@
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Read the length so that we can determine instance size to allocate.
   intptr_t len = reader->ReadSmiValue();
 
   // Allocate JSRegExp object.
   JSRegExp& regex = JSRegExp::ZoneHandle(
-      reader->isolate(),
-      JSRegExp::New(len, (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew));
+      reader->isolate(), JSRegExp::New(len, space(kind)));
   reader->AddBackRef(object_id, &regex, kIsDeserialized);
 
   // Set the object tags.
   regex.set_tags(tags);
 
   // Read and Set all the other fields.
   regex.raw_ptr()->num_bracket_expressions_ = reader->ReadAsSmi();
   *reader->StringHandle() ^= reader->ReadObjectImpl();
   regex.raw_ptr()->pattern_ = (*reader->StringHandle()).raw();
   regex.raw_ptr()->type_ = reader->ReadIntptrValue();
@@ skipping 32 matching lines @@
 
 
 RawWeakProperty* WeakProperty::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate the weak property object.
   WeakProperty& weak_property = WeakProperty::ZoneHandle(
-      reader->isolate(),
-      WeakProperty::New((kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew));
+      reader->isolate(), WeakProperty::New(space(kind)));
   reader->AddBackRef(object_id, &weak_property, kIsDeserialized);
 
   // Set the object tags.
   weak_property.set_tags(tags);
 
   // Set all the object fields.
   weak_property.raw_ptr()->key_ = reader->ReadObjectRef();
   weak_property.raw_ptr()->value_ = reader->ReadObjectRef();
 
   return weak_property.raw();
@@ skipping 11 matching lines @@
   // Write out the class and tags information.
   writer->WriteIndexedObject(kWeakPropertyCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->key_);
   writer->Write<RawObject*>(ptr()->value_);
 }
 
 }  // namespace dart