Add passive handle types PassiveObject and PassiveInstance to allow

runtime/vm/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/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 151 matching lines @@
                                intptr_t size,
                                Snapshot::Kind kind,
                                Isolate* isolate)
     : BaseReader(buffer, size),
       kind_(kind),
       isolate_(isolate),
       heap_(isolate->heap()),
       old_space_(isolate->heap()->old_space()),
       cls_(Class::Handle(isolate)),
       obj_(Object::Handle(isolate)),
+      pobj_(PassiveObject::Handle(isolate)),
       array_(Array::Handle(isolate)),
       field_(Field::Handle(isolate)),
       str_(String::Handle(isolate)),
       library_(Library::Handle(isolate)),
       type_(AbstractType::Handle(isolate)),
       type_arguments_(TypeArguments::Handle(isolate)),
       tokens_(Array::Handle(isolate)),
       stream_(TokenStream::Handle(isolate)),
       data_(ExternalTypedData::Handle(isolate)),
       error_(UnhandledException::Handle(isolate)),
@@ skipping 147 matching lines @@
     AddBackRef(object_id, &array, kIsNotDeserialized);
 
     return array.raw();
   }
 
   // For all other internal VM classes we read the object inline.
   intptr_t tags = ReadTags();
   switch (class_id) {
 #define SNAPSHOT_READ(clazz)                                                   \
     case clazz::kClassId: {                                                    \
-      obj_ = clazz::ReadFrom(this, object_id, tags, kind_);                    \
+      pobj_ = clazz::ReadFrom(this, object_id, tags, kind_);                   \
       break;                                                                   \
     }
     CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
 #undef SNAPSHOT_READ
 #define SNAPSHOT_READ(clazz)                                                   \
     case kTypedData##clazz##Cid:                                               \
 
     CLASS_LIST_TYPED_DATA(SNAPSHOT_READ) {
       tags = RawObject::ClassIdTag::update(class_id, tags);
-      obj_ = TypedData::ReadFrom(this, object_id, tags, kind_);
+      pobj_ = TypedData::ReadFrom(this, object_id, tags, kind_);
       break;
     }
 #undef SNAPSHOT_READ
 #define SNAPSHOT_READ(clazz)                                                   \
     case kExternalTypedData##clazz##Cid:                                       \
 
     CLASS_LIST_TYPED_DATA(SNAPSHOT_READ) {
       tags = RawObject::ClassIdTag::update(class_id, tags);
-      obj_ = ExternalTypedData::ReadFrom(this, object_id, tags, kind_);
+      pobj_ = ExternalTypedData::ReadFrom(this, object_id, tags, kind_);
       break;
     }
 #undef SNAPSHOT_READ
     default: UNREACHABLE(); break;
   }
   if (kind_ == Snapshot::kFull) {
-    obj_.SetCreatedFromSnapshot();
+    pobj_.SetCreatedFromSnapshot();
   }
-  return obj_.raw();
+  return pobj_.raw();
 }
 
 
 void SnapshotReader::AddBackRef(intptr_t id,
                                 Object* obj,
                                 DeserializeState state) {
   intptr_t index = (id - kMaxPredefinedObjectIds);
   ASSERT(index == backward_references_.length());
   BackRefNode node(obj, state);
   backward_references_.Add(node);
@@ skipping 503 matching lines @@
       instance_size = cls_.instance_size();
     }
     intptr_t next_field_offset = cls_.next_field_offset();
     intptr_t type_argument_field_offset = cls_.type_arguments_field_offset();
     ASSERT(next_field_offset > 0);
     // Instance::NextFieldOffset() returns the offset of the first field in
     // a Dart object.
     intptr_t offset = Instance::NextFieldOffset();
     intptr_t result_cid = result->GetClassId();
     while (offset < next_field_offset) {
-      obj_ = ReadObjectRef();
-      result->SetFieldAtOffset(offset, obj_);
+      pobj_ = ReadObjectRef();
+      result->SetFieldAtOffset(offset, pobj_);
       if ((offset != type_argument_field_offset) &&
           (kind_ == Snapshot::kMessage)) {
         // TODO(fschneider): Consider hoisting these lookups out of the loop.
         // This would involve creating a handle, since cls_ can't be reused
         // across the call to ReadObjectRef.
         cls_ = isolate()->class_table()->At(result_cid);
         array_ = cls_.OffsetToFieldMap();
         field_ ^= array_.At(offset >> kWordSizeLog2);
         ASSERT(!field_.IsNull());
         ASSERT(field_.Offset() == offset);
+        obj_ = pobj_.raw();
         field_.RecordStore(obj_);
       }
       // TODO(fschneider): Verify the guarded cid and length for other kinds of
       // snapshot (kFull, kScript) with asserts.
       offset += kWordSize;
     }
     if (kind_ == Snapshot::kFull) {
       // We create an uninitialized object in the case of full snapshots, so
       // we need to initialize any remaining padding area with the Null object.
       while (offset < instance_size) {
         result->SetFieldAtOffset(offset, Object::null_object());
         offset += kWordSize;
       }
       result->SetCreatedFromSnapshot();
     } else if (result->IsCanonical()) {
       *result = result->CheckAndCanonicalize(NULL);
       ASSERT(!result->IsNull());
     }
     return result->raw();
   }
   ASSERT((class_header & kSmiTagMask) != kSmiTag);
   cls_ = LookupInternalClass(class_header);
   ASSERT(!cls_.IsNull());
   switch (cls_.id()) {
 #define SNAPSHOT_READ(clazz)                                                   \
     case clazz::kClassId: {                                                    \
-      obj_ = clazz::ReadFrom(this, object_id, tags, kind_);                    \
+      pobj_ = clazz::ReadFrom(this, object_id, tags, kind_);                   \
       break;                                                                   \
     }
     CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
 #undef SNAPSHOT_READ
 #define SNAPSHOT_READ(clazz)                                                   \
     case kTypedData##clazz##Cid:                                               \
 
     CLASS_LIST_TYPED_DATA(SNAPSHOT_READ) {
       tags = RawObject::ClassIdTag::update(cls_.id(), tags);
-      obj_ = TypedData::ReadFrom(this, object_id, tags, kind_);
+      pobj_ = TypedData::ReadFrom(this, object_id, tags, kind_);
       break;
     }
 #undef SNAPSHOT_READ
 #define SNAPSHOT_READ(clazz)                                                   \
     case kExternalTypedData##clazz##Cid:                                       \
 
     CLASS_LIST_TYPED_DATA(SNAPSHOT_READ) {
       tags = RawObject::ClassIdTag::update(cls_.id(), tags);
-      obj_ = ExternalTypedData::ReadFrom(this, object_id, tags, kind_);
+      pobj_ = ExternalTypedData::ReadFrom(this, object_id, tags, kind_);
       break;
     }
 #undef SNAPSHOT_READ
     default: UNREACHABLE(); break;
   }
   if (kind_ == Snapshot::kFull) {
-    obj_.SetCreatedFromSnapshot();
+    pobj_.SetCreatedFromSnapshot();
   }
-  return obj_.raw();
+  return pobj_.raw();
 }
 
 
 void SnapshotReader::ArrayReadFrom(const Array& result,
                                    intptr_t len,
                                    intptr_t tags) {
   // Set the object tags.
   result.set_tags(tags);
 
   // Setup the object fields.
   *TypeArgumentsHandle() ^= ReadObjectImpl();
   result.SetTypeArguments(*TypeArgumentsHandle());
 
   for (intptr_t i = 0; i < len; i++) {
-    *ObjectHandle() = ReadObjectRef();
-    result.SetAt(i, *ObjectHandle());
+    *PassiveObjectHandle() = ReadObjectRef();
+    result.SetAt(i, *PassiveObjectHandle());
   }
 }
 
 
 SnapshotWriter::SnapshotWriter(Snapshot::Kind kind,
                                uint8_t** buffer,
                                ReAlloc alloc,
                                intptr_t initial_size)
     : BaseWriter(buffer, alloc, initial_size),
       kind_(kind),
@@ skipping 666 matching lines @@
     NoGCScope no_gc;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart