Use VM type cast and save handles.

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/exceptions.h"
@@ skipping 88 matching lines @@
   return obj.raw();
 }
 
 
 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);
+  cls = LookupInternalClass(class_header);
   AddBackRef(object_id, &cls, kIsDeserialized);
   if (cls.IsNull()) {
     // Read the library/class information and lookup the class.
     str_ ^= ReadObjectImpl(class_header);
     library_ = Library::LookupLibrary(str_);
     ASSERT(!library_.IsNull());
     str_ ^= ReadObjectImpl();
-    cls ^= library_.LookupClass(str_);
+    cls = library_.LookupClass(str_);
   }
   ASSERT(!cls.IsNull());
   return cls.raw();
 }
 
 
 RawObject* SnapshotReader::ReadObjectImpl() {
   int64_t value = Read<int64_t>();
   if ((value & kSmiTagMask) == 0) {
     return Integer::New((value >> kSmiTagShift));
@@ skipping 46 matching lines @@
     intptr_t instance_size = cls_.instance_size();
     ASSERT(instance_size > 0);
     if (kind_ == Snapshot::kFull) {
       result ^= AllocateUninitialized(cls_, instance_size);
     } else {
       result ^= Object::Allocate(cls_, instance_size, Heap::kNew);
     }
     return result.raw();
   } else {
     ASSERT((class_header & kSmiTagMask) != 0);
-    cls_ ^= LookupInternalClass(class_header);
+    cls_ = LookupInternalClass(class_header);
     ASSERT(!cls_.IsNull());
   }
 
   // Similarly Array and ImmutableArray objects are also similarly only
   // allocated here, the individual array elements are read later.
   ObjectKind obj_kind = cls_.instance_kind();
   if (obj_kind == Array::kInstanceKind) {
     // Read the length and allocate an object based on the len.
     intptr_t len = ReadSmiValue();
     Array& array = Array::ZoneHandle(
@@ skipping 374 matching lines @@
       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);
+    cls_ = LookupInternalClass(class_header);
     ASSERT(!cls_.IsNull());
   }
   switch (cls_.instance_kind()) {
 #define SNAPSHOT_READ(clazz)                                                   \
     case clazz::kInstanceKind: {                                               \
       obj_ = clazz::ReadFrom(this, object_id, tags, kind_);                    \
       break;                                                                   \
     }
     CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
 #undef SNAPSHOT_READ
@@ skipping 418 matching lines @@
     RawObject* raw_obj = *current;
     if (as_references_) {
       writer_->WriteObjectRef(raw_obj);
     } else {
       writer_->WriteObjectImpl(raw_obj);
     }
   }
 }
 
 }  // namespace dart