Finishes removing intptr_t from raw object fields.

runtime/vm/snapshot.h

 // 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.
 
 #ifndef VM_SNAPSHOT_H_
 #define VM_SNAPSHOT_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
@@ skipping 70 matching lines @@
 //    using ths unique ID assigned to them).
 // - Reference to object that has already been written: (object id | 0x3)
 //   This valus is serialized as a positive number.
 // - 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 kObjectIdBits = (kBitsPerWord - (kHeaderTagBits + 1));
-static const intptr_t kMaxObjectId = (kUwordMax >> (kHeaderTagBits + 1));
+static const int8_t kObjectIdBits = (kBitsPerInt32 - (kHeaderTagBits + 1));
+static const intptr_t kMaxObjectId = (kMaxUint32 >> (kHeaderTagBits + 1));
 
 
 class SerializedHeaderTag : public BitField<enum SerializedHeaderType,
                                             0,
                                             kHeaderTagBits> {
 };
 
 
 class SerializedHeaderData : public BitField<intptr_t,
                                              kHeaderTagBits,
@@ skipping 64 matching lines @@
 class BaseReader {
  public:
   BaseReader(const uint8_t* buffer, intptr_t size) : stream_(buffer, size) {}
   // 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 <= kIntptrMax) && (value >= kIntptrMin));
-    return static_cast<intptr_t>(value);
-  }
-
   intptr_t ReadRawPointerValue() {
     int64_t value = Read<int64_t>();
     return static_cast<intptr_t>(value);
   }
 
   void ReadBytes(uint8_t* addr, intptr_t len) {
     stream_.ReadBytes(addr, len);
   }
 
   double ReadDouble() {
@@ skipping 201 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) {
-    ASSERT((value >= kMinInt32) && (value <= kMaxInt32));
-    Write<int64_t>(value);
-  }
-
   void WriteRawPointerValue(intptr_t value) {
     Write<int64_t>(value);
   }
 
   // Write an object that is serialized as an Id (singleton in object store,
   // or an object that was already serialized before).
   void WriteIndexedObject(intptr_t object_id) {
     ASSERT(object_id <= kMaxObjectId);
     intptr_t value = 0;
     value = SerializedHeaderTag::update(kObjectId, value);
     value = SerializedHeaderData::update(object_id, value);
-    WriteIntptrValue(value);
+    Write<int32_t>(value);

[Ivan Posva, 2014/06/26 09:02:04]

Can't we just have a Write32 instead of having to write Write<int32_t>
everywhere?

[zra, 2014/07/01 20:37:01]

I can make this name change in a separate CL.

   }
 
   // Write a VM Isolateobject that is serialized as an Id.
   void WriteVMIsolateObject(intptr_t object_id) {
     ASSERT(object_id <= kMaxObjectId);
     intptr_t value = 0;
     value = SerializedHeaderTag::update(kObjectId, value);
     value = SerializedHeaderData::update(object_id, value);
-    WriteIntptrValue(-value);  // Write as a negative value.
+    Write<int32_t>(-value);  // Write as a negative value.
   }
 
   // Write serialization header information for an object.
   void WriteInlinedObjectHeader(intptr_t id) {
     ASSERT(id <= kMaxObjectId);
     intptr_t value = 0;
     value = SerializedHeaderTag::update(kInlined, value);
     value = SerializedHeaderData::update(id, value);
-    WriteIntptrValue(value);
+    Write<int32_t>(value);
   }
 
   // Write out a buffer of bytes.
   void WriteBytes(const uint8_t* addr, intptr_t len) {
     stream_.WriteBytes(addr, len);
   }
 
   void WriteDouble(double value) {
     stream_.WriteBytes(reinterpret_cast<const uint8_t*>(&value), sizeof(value));
   }
@@ skipping 198 matching lines @@
  private:
   SnapshotWriter* writer_;
   bool as_references_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // VM_SNAPSHOT_H_