Create temporary handles in the snapshot object during initialization and use them instead of cre...

vm/snapshot.cc

 // Copyright (c) 2011, 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/snapshot.h"
 
 #include "vm/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/heap.h"
 #include "vm/object.h"
@@ skipping 34 matching lines @@
   ASSERT(kLengthIndex == length_offset());
   ASSERT((kSnapshotFlagIndex * sizeof(int32_t)) == kind_offset());
   ASSERT((kHeapObjectTag & kInlined));
   ASSERT((kHeapObjectTag & kObjectId));
   ASSERT((kObjectAlignmentMask & kObjectId) == kObjectId);
   const Snapshot* snapshot = reinterpret_cast<const Snapshot*>(raw_memory);
   return snapshot;
 }
 
 
+SnapshotReader::SnapshotReader(const Snapshot* snapshot, Isolate* isolate)
+    : stream_(snapshot->content(), snapshot->length()),
+      kind_(snapshot->kind()),
+      isolate_(isolate),
+      cls_(Class::Handle()),
+      obj_(Object::Handle()),
+      str_(String::Handle()),
+      library_(Library::Handle()),
+      type_(AbstractType::Handle()),
+      type_arguments_(AbstractTypeArguments::Handle()),
+      backward_references_() {
+}
+
+
 RawObject* SnapshotReader::ReadObject() {
   int64_t value = Read<int64_t>();
   if ((value & kSmiTagMask) == 0) {
     return Integer::New((value >> kSmiTagShift));
   }
   ASSERT((value <= kIntptrMax) && (value >= kIntptrMin));
   return ReadObjectImpl(value);
 }
 
 
 RawClass* SnapshotReader::ReadClassId(intptr_t object_id) {
   ASSERT(kind_ != Snapshot::kFull);
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
   ASSERT((class_header & kSmiTagMask) != 0);
   Class& cls = Class::ZoneHandle(isolate(), Class::null());
   cls ^= LookupInternalClass(class_header);
   AddBackwardReference(object_id, &cls);
   if (cls.IsNull()) {
     // Read the library/class information and lookup the class.
-    String& library_url = String::Handle(isolate(), String::null());
-    library_url ^= ReadObjectImpl(class_header);
-    String& class_name = String::Handle(isolate(), String::null());
-    class_name ^= ReadObject();
-    const Library& library =
-        Library::Handle(isolate(), Library::LookupLibrary(library_url));
-    ASSERT(!library.IsNull());
-    cls ^= library.LookupClass(class_name);
+    str_ ^= ReadObjectImpl(class_header);
+    library_ = Library::LookupLibrary(str_);
+    ASSERT(!library_.IsNull());
+    str_ ^= ReadObject();
+    cls ^= library_.LookupClass(str_);
   }
   ASSERT(!cls.IsNull());
   return cls.raw();
 }
 
 
 void SnapshotReader::AddBackwardReference(intptr_t id, Object* obj) {
   ASSERT((id - kMaxPredefinedObjectIds) == backward_references_.length());
   backward_references_.Add(obj);
 }
@@ skipping 72 matching lines @@
   intptr_t index = object_id - kMaxPredefinedObjectIds;
   ASSERT(index < backward_references_.length());
   return backward_references_[index]->raw();
 }
 
 
 RawObject* SnapshotReader::ReadInlinedObject(intptr_t object_id) {
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
   intptr_t tags = ReadIntptrValue();
-  Class& cls = Class::Handle(isolate(), Class::null());
-  Object& obj = Object::Handle(isolate(), Object::null());
   if (SerializedHeaderData::decode(class_header) == kInstanceId) {
     // Object is regular dart instance.
     Instance& result = Instance::ZoneHandle(isolate(), Instance::null());
     AddBackwardReference(object_id, &result);
 
-    cls ^= ReadObject();
-    ASSERT(!cls.IsNull());
-    intptr_t instance_size = cls.instance_size();
+    cls_ ^= ReadObject();
+    ASSERT(!cls_.IsNull());
+    intptr_t instance_size = cls_.instance_size();
     ASSERT(instance_size > 0);
     // Allocate the instance and read in all the fields for the object.
-    RawObject* raw = Object::Allocate(cls, instance_size, Heap::kNew);
+    RawObject* raw = Object::Allocate(cls_, instance_size, Heap::kNew);
     result ^= raw;
     intptr_t offset = Object::InstanceSize();
     while (offset < instance_size) {
-      obj = ReadObject();
-      result.SetFieldAtOffset(offset, obj);
+      obj_ = ReadObject();
+      result.SetFieldAtOffset(offset, obj_);
       offset += kWordSize;
     }
     if (kind_ == Snapshot::kFull) {
       result.SetCreatedFromSnapshot();
     } else if (result.IsCanonical()) {
       result = result.Canonicalize();
     }
     return result.raw();
   } else {
     ASSERT((class_header & kSmiTagMask) != 0);
-    cls ^= LookupInternalClass(class_header);
-    ASSERT(!cls.IsNull());
+    cls_ ^= LookupInternalClass(class_header);
+    ASSERT(!cls_.IsNull());
   }
-  switch (cls.instance_kind()) {
+  switch (cls_.instance_kind()) {
 #define SNAPSHOT_READ(clazz)                                                   \
     case clazz::kInstanceKind: {                                               \
-      obj = clazz::ReadFrom(this, object_id, tags, kind_);                     \
+      obj_ = clazz::ReadFrom(this, object_id, tags, kind_);                    \
       break;                                                                   \
     }
     CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
 #undef SNAPSHOT_READ
     default: UNREACHABLE(); break;
   }
   if (kind_ == Snapshot::kFull) {
-    obj.SetCreatedFromSnapshot();
+    obj_.SetCreatedFromSnapshot();
   }
-  return obj.raw();
+  return obj_.raw();
 }
 
 
 void MessageWriter::WriteMessage(intptr_t field_count, intptr_t *data) {
   // Write out the serialization header value for this object.
   WriteSerializationMarker(kInlined, kMaxPredefinedObjectIds);
 
   // Write out the class and tags information.
   WriteObjectHeader(ObjectStore::kArrayClass, 0);
 
@@ skipping 215 matching lines @@
 
 
 void SnapshotWriterVisitor::VisitPointers(RawObject** first, RawObject** last) {
   for (RawObject** current = first; current <= last; current++) {
     RawObject* raw_obj = *current;
     writer_->WriteObject(raw_obj);
   }
 }
 
 }  // namespace dart