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

vm/snapshot.h

 // 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.
 
 #ifndef VM_SNAPSHOT_H_
 #define VM_SNAPSHOT_H_
 
 #include "vm/allocation.h"
 #include "vm/assert.h"
 #include "vm/bitfield.h"
@@ skipping 22 matching lines @@
 // Serialized object header encoding is as follows:
 // - Smi: the Smi value is written as is (last bit is not tagged).
 // - VM internal type (from VM isolate): (index of type in vm isolate | 0x3)
 // - Object that has already been written: (negative id in stream | 0x3)
 // - Object that is seen for the first time (inlined in the stream):
 //   (a unique id for this object | 0x1)
 enum SerializedHeaderType {
   kInlined = 0x1,
   kObjectId = 0x3,
 };
-
+static const int8_t kHeaderTagBits = 2;
+static const int8_t kObjectIdTagBits = (kBitsPerWord - kHeaderTagBits);
+static const intptr_t kMaxObjectId = (LONG_MAX >> kHeaderTagBits);
 
 typedef uint8_t* (*ReAlloc)(uint8_t* ptr, intptr_t old_size, intptr_t new_size);
 
-
-class SerializedHeaderTag : public BitField<enum SerializedHeaderType, 0, 2> {
+class SerializedHeaderTag : public BitField<enum SerializedHeaderType,
+                                            0,
+                                            kHeaderTagBits> {
 };
 
 
-class SerializedHeaderData : public BitField<intptr_t, 2, 30> {
+class SerializedHeaderData : public BitField<intptr_t,
+                                             kHeaderTagBits,
+                                             kObjectIdTagBits> {
 };
 
 
 // Structure capturing the raw snapshot.
 class Snapshot {
  public:
   enum Kind {
     kFull = 0,  // Full snapshot of the current dart heap.
     kScript,    // A partial snapshot of only the application script.
     kMessage,   // A partial snapshot used only for isolate messaging.
@@ skipping 221 matching lines @@
         backward_references_() { }
   ~SnapshotReader() { }
 
   // Reads raw data (for basic types).
   // sizeof(T) must be in {1,2,4,8}.
   template <typename T>
   T Read() {
     return ReadStream::Raw<sizeof(T), T>::Read(&stream_);
   }
 
+  // Reads an intptr_t type value.
+  intptr_t ReadIntptrValue() {
+    int64_t value = Read<int64_t>();
+    ASSERT((value <= LONG_MAX) && (value >= LONG_MIN));

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

As discussed we should use the correct constant for intptr_t.

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

Done.

+    return value;
+  }
+
   Heap* heap() const { return heap_; }
   ObjectStore* object_store() const { return object_store_; }
 
   // Reads an object.
   RawObject* ReadObject();
 
   RawClass* ReadClassId(intptr_t object_id);
 
   // Add object to backward references.
   void AddBackwardReference(intptr_t id, Object* obj);
@@ skipping 30 matching lines @@
   // Size of the snapshot.
   intptr_t BytesWritten() const { return stream_.bytes_written(); }
 
   // Writes raw data to the stream (basic type).
   // sizeof(T) must be in {1,2,4,8}.
   template <typename T>
   void Write(T value) {
     WriteStream::Raw<sizeof(T), T>::Write(&stream_, value);
   }
 
+  // Writes an intptr_t type value out.
+  void WriteIntptrValue(intptr_t value) {
+    Write<int64_t>(value);
+  }
+
   // Write an object that is serialized as an Id (singleton, object store,
   // or an object that was already serialized before).
   void WriteIndexedObject(intptr_t object_id) {
     WriteSerializationMarker(kObjectId, object_id);
   }
 
   // Write out object header value.
   void WriteObjectHeader(intptr_t class_id, intptr_t tags) {
     // Write out the class information.
     WriteIndexedObject(class_id);
     // Write out the tags information.
-    Write<intptr_t>(tags);
+    WriteIntptrValue(tags);
   }
 
   // Write serialization header information for an object.
   void WriteSerializationMarker(SerializedHeaderType type, intptr_t id) {
-    uword value = 0;
+    ASSERT(id <= kMaxObjectId);
+    intptr_t value = 0;
     value = SerializedHeaderTag::update(type, value);
     value = SerializedHeaderData::update(id, value);
-    Write<uword>(value);
+    WriteIntptrValue(value);
   }
 
   // Finalize the serialized buffer by filling in the header information
   // which comprises of a flag(snaphot kind) and the length of
   // serialzed bytes.
   void FinalizeBuffer(Snapshot::Kind kind) {
     int32_t* data = reinterpret_cast<int32_t*>(stream_.buffer());
     data[Snapshot::kLengthIndex] = stream_.bytes_written();
     data[Snapshot::kSnapshotFlagIndex] = kind;
   }
@@ skipping 117 matching lines @@
 
  private:
   SnapshotWriter* writer_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // VM_SNAPSHOT_H_