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

runtime/vm/raw_object_snapshot.cc

Index: runtime/vm/raw_object_snapshot.cc
===================================================================
--- runtime/vm/raw_object_snapshot.cc	(revision 11276)
+++ runtime/vm/raw_object_snapshot.cc	(working copy)
@@ -17,13 +17,22 @@
 #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,
@@ -317,7 +326,7 @@
   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.
@@ -372,8 +381,8 @@
 
   // 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.
@@ -1012,7 +1021,7 @@
   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);
 
@@ -1309,7 +1318,7 @@
     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);
@@ -1353,8 +1362,8 @@
   // 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)) {
@@ -1427,7 +1436,7 @@
     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);
@@ -1476,7 +1485,8 @@
 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.
@@ -1489,7 +1499,7 @@
     *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++) {
@@ -1522,7 +1532,7 @@
     }
     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();
@@ -1553,7 +1563,7 @@
     }
     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();
@@ -1584,7 +1594,7 @@
     }
     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();
@@ -1774,7 +1784,7 @@
       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);
@@ -1794,7 +1804,8 @@
       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);
@@ -1838,7 +1849,7 @@
   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();
@@ -1890,9 +1901,8 @@
   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.
@@ -1950,7 +1960,7 @@
   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));                         \
 }                                                                              \
 
 
@@ -2089,8 +2099,7 @@
 
   // 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.
@@ -2143,8 +2152,7 @@
 
   // 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.