Make snapshots 32 or 64 bit compliant by using Write<int64_t> and Read<int64_t> for intptr_t type...

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 35 matching lines @@
   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;
 }
 
 
 RawObject* SnapshotReader::ReadObject() {
-  intptr_t header = Read<intptr_t>();
-  if ((header & kSmiTagMask) == 0) {
-    return reinterpret_cast<RawObject*>(header);
+  int64_t value = Read<int64_t>();
+  if ((value & kSmiTagMask) == 0) {
+    return Integer::New((value >> kSmiTagShift));
   }
-  return ReadObjectImpl(header);
+  ASSERT((value <= LONG_MAX) && (value >= LONG_MIN));

[Ivan Posva, 2011/12/27 22:27:59]

ditto

[siva, 2011/12/27 23:47:20]

Done.

+  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 = Read<intptr_t>();
+  intptr_t class_header = ReadIntptrValue();
   ASSERT((class_header & kSmiTagMask) != 0);
   Class& cls = Class::ZoneHandle();
   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();
     library_url ^= ReadObjectImpl(class_header);
     String& class_name = String::Handle();
     class_name ^= ReadObject();
@@ skipping 26 matching lines @@
     *(object_store->from() + i) = ReadObject();
   }
 
   // Setup native resolver for bootstrap impl.
   Bootstrap::SetupNativeResolver();
 }
 
 
 RawClass* SnapshotReader::LookupInternalClass(intptr_t class_header) {
   SerializedHeaderType header_type = SerializedHeaderTag::decode(class_header);
-  intptr_t header_value = SerializedHeaderData::decode(class_header);
 
   // If the header is an object Id, lookup singleton VM classes or classes
   // stored in the object store.
   if (header_type == kObjectId) {
+    intptr_t header_value = SerializedHeaderData::decode(class_header);
     if (IsSingletonClassId(header_value)) {
       return Object::GetSingletonClass(header_value);  // return the singleton.
     } else if (IsObjectStoreClassId(header_value)) {
       return object_store()->GetClass(header_value);
     }
   }
   return Class::null();
 }
 
 
@@ skipping 33 matching lines @@
 
   ASSERT(object_id >= kMaxPredefinedObjectIds);
   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 = Read<intptr_t>();
-  intptr_t tags = Read<intptr_t>();
+  intptr_t class_header = ReadIntptrValue();
+  intptr_t tags = ReadIntptrValue();
   Class& cls = Class::Handle();
   Object& obj = Object::Handle();
   if (SerializedHeaderData::decode(class_header) == kInstanceId) {
     // Object is regular dart instance.
     Instance& result = Instance::ZoneHandle();
     AddBackwardReference(object_id, &result);
 
     cls ^= ReadObject();
     ASSERT(!cls.IsNull());
     intptr_t instance_size = cls.instance_size();
@@ skipping 65 matching lines @@
   // - Object that is seen for the first time (inlined as follows):
   //    (object size in multiples of kObjectAlignment | 0x1)
   //    serialized fields of the object
   //    ......
 
   NoGCScope no_gc;
   // writing a snap shot.
 
   // First check if it is a Smi (i.e not a heap object).
   if (!rawobj->IsHeapObject()) {
-    Write<RawObject*>(rawobj);
+    Write<int64_t>(reinterpret_cast<int64_t>(rawobj));
     return;
   }
 
   // Check if it is a singleton null object which is shared by all isolates.
   if (rawobj == Object::null()) {
     WriteIndexedObject(Object::kNullObject);
     return;
   }
 
   // Check if it is a singleton sentinel object which is shared by all isolates.
@@ skipping 60 matching lines @@
   object_store->VisitObjectPointers(&visitor);
 
   // Finalize the snapshot buffer.
   FinalizeBuffer();
 }
 
 
 intptr_t SnapshotWriter::MarkObject(RawObject* raw, RawClass* cls) {
   NoGCScope no_gc;
   intptr_t object_id = forward_list_.length() + kMaxPredefinedObjectIds;
+  ASSERT(object_id <= kMaxObjectId);
   uword value = 0;
   value = SerializedHeaderTag::update(kObjectId, value);
   value = SerializedHeaderData::update(object_id, value);
   raw->ptr()->class_ = reinterpret_cast<RawClass*>(value);
   ForwardObjectNode* node = new ForwardObjectNode(raw, cls);
   ASSERT(node != NULL);
   forward_list_.Add(node);
   return object_id;
 }
 
@@ skipping 21 matching lines @@
     // TODO(5411462): figure out what we need to do if an object with native
     // fields is serialized (throw exception or serialize a null object).
     ASSERT(cls->ptr()->num_native_fields_ == 0);
     intptr_t instance_size = cls->ptr()->instance_size_;
     ASSERT(instance_size != 0);
 
     // Write out the serialization header value for this object.
     WriteSerializationMarker(kInlined, object_id);
 
     // Indicate this is an instance object.
-    Write<intptr_t>(SerializedHeaderData::encode(kInstanceId));
+    WriteIntptrValue(SerializedHeaderData::encode(kInstanceId));
 
     // Write out the tags.
-    Write<intptr_t>(raw->ptr()->tags_);
+    WriteIntptrValue(raw->ptr()->tags_);
 
     // Write out the class information for this object.
     WriteObject(cls);
 
     // Write out all the fields for the object.
     intptr_t offset = Object::InstanceSize();
     while (offset < instance_size) {
       WriteObject(*reinterpret_cast<RawObject**>(
           reinterpret_cast<uword>(raw->ptr()) + offset));
       offset += kWordSize;
@@ skipping 48 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