X64: Serialization fixed to use intptr_t/Address where needed.

src/serialize.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 60 matching lines @@
 const int kPageBits = 32 - (kOffsetBits + kSpaceBits + kHeapObjectTagSize);
 const int kPageShift = kOffsetShift + kOffsetBits;
 const int kPageMask = (1 << kPageBits) - 1;
 
 const int kPageAndOffsetShift = kOffsetShift;
 const int kPageAndOffsetBits = kPageBits + kOffsetBits;
 const int kPageAndOffsetMask = (1 << kPageAndOffsetBits) - 1;
 
 
 static inline AllocationSpace GetSpace(Address addr) {
-  const int encoded = reinterpret_cast<int>(addr);
-  int space_number = ((encoded >> kSpaceShift) & kSpaceMask);
+  const intptr_t encoded = reinterpret_cast<intptr_t>(addr);
+  int space_number = (static_cast<int>(encoded >> kSpaceShift) & kSpaceMask);
   if (space_number == kLOSpaceExecutable) space_number = LO_SPACE;
   else if (space_number == kLOSpacePointer) space_number = LO_SPACE;
   return static_cast<AllocationSpace>(space_number);
 }
 
 
 static inline bool IsLargeExecutableObject(Address addr) {
-  const int encoded = reinterpret_cast<int>(addr);
-  const int space_number = ((encoded >> kSpaceShift) & kSpaceMask);
-  if (space_number == kLOSpaceExecutable) return true;
-  return false;
+  const intptr_t encoded = reinterpret_cast<intptr_t>(addr);
+  const int space_number =
+      (static_cast<int>(encoded >> kSpaceShift) & kSpaceMask);
+  return (space_number == kLOSpaceExecutable);
 }
 
 
 static inline bool IsLargeFixedArray(Address addr) {
-  const int encoded = reinterpret_cast<int>(addr);
-  const int space_number = ((encoded >> kSpaceShift) & kSpaceMask);
-  if (space_number == kLOSpacePointer) return true;
-  return false;
+  const intptr_t encoded = reinterpret_cast<intptr_t>(addr);
+  const int space_number =
+      (static_cast<int>(encoded >> kSpaceShift) & kSpaceMask);
+  return (space_number == kLOSpacePointer);
 }
 
 
 static inline int PageIndex(Address addr) {
-  const int encoded = reinterpret_cast<int>(addr);
-  return (encoded >> kPageShift) & kPageMask;
+  const intptr_t encoded = reinterpret_cast<intptr_t>(addr);
+  return static_cast<int>(encoded >> kPageShift) & kPageMask;
 }
 
 
 static inline int PageOffset(Address addr) {
-  const int encoded = reinterpret_cast<int>(addr);
-  return ((encoded >> kOffsetShift) & kOffsetMask) << kObjectAlignmentBits;
+  const intptr_t encoded = reinterpret_cast<intptr_t>(addr);
+  const int offset = static_cast<int>(encoded >> kOffsetShift) & kOffsetMask;
+  return offset << kObjectAlignmentBits;
 }
 
 
 static inline int NewSpaceOffset(Address addr) {
-  const int encoded = reinterpret_cast<int>(addr);
-  return ((encoded >> kPageAndOffsetShift) & kPageAndOffsetMask) <<
-      kObjectAlignmentBits;
+  const intptr_t encoded = reinterpret_cast<intptr_t>(addr);
+  const int page_offset =
+      static_cast<int>(encoded >> kPageAndOffsetShift) & kPageAndOffsetMask;
+  return page_offset << kObjectAlignmentBits;
 }
 
 
 static inline int LargeObjectIndex(Address addr) {
-  const int encoded = reinterpret_cast<int>(addr);
-  return (encoded >> kPageAndOffsetShift) & kPageAndOffsetMask;
+  const intptr_t encoded = reinterpret_cast<intptr_t>(addr);
+  return static_cast<int>(encoded >> kPageAndOffsetShift) & kPageAndOffsetMask;
 }
 
 
 // A RelativeAddress encodes a heap address that is independent of
 // the actual memory addresses in real heap. The general case (for the
 // OLD, CODE and MAP spaces) is as a (space id, page number, page offset)
 // triple. The NEW space has page number == 0, because there are no
 // pages. The LARGE_OBJECT space has page offset = 0, since there is
 // exactly one object per page.  RelativeAddresses are encodable as
 // Addresses, so that they can replace the map() pointers of
@@ skipping 584 matching lines @@
 const char* ExternalReferenceEncoder::NameOfAddress(Address key) const {
   int index = IndexOf(key);
   return index >=0 ? ExternalReferenceTable::instance()->name(index) : NULL;
 }
 
 
 int ExternalReferenceEncoder::IndexOf(Address key) const {
   if (key == NULL) return -1;
   HashMap::Entry* entry =
       const_cast<HashMap &>(encodings_).Lookup(key, Hash(key), false);
-  return entry == NULL ? -1 : reinterpret_cast<int>(entry->value);
+  return entry == NULL ? -1 :

[Kasper Lund, 2009/05/07 11:48:54]

I would put ? and : on separate lines like this:

  return entry == NULL
      ? -1
      : ....;

+             static_cast<int>(reinterpret_cast<intptr_t>(entry->value));
 }
 
 
 void ExternalReferenceEncoder::Put(Address key, int index) {
   HashMap::Entry* entry = encodings_.Lookup(key, Hash(key), true);
   entry->value = reinterpret_cast<void *>(index);
 }
 
 
 ExternalReferenceDecoder::ExternalReferenceDecoder()
@@ skipping 45 matching lines @@
   void Reserve(int bytes, int pos);
 
   void PutC(char c) {
     InsertC(c, len_);
   }
 
   void PutInt(int i) {
     InsertInt(i, len_);
   }
 
+  void PutAddress(Address p) {
+    PutBytes(reinterpret_cast<byte*>(&p), sizeof(p));
+  }
+
   void PutBytes(const byte* a, int size) {
     InsertBytes(a, len_, size);
   }
 
   void PutString(const char* s) {
     InsertString(s, len_);
   }
 
   int InsertC(char c, int pos) {
     Reserve(1, pos);
@@ skipping 100 matching lines @@
   Address obj_address_;
   Serializer* serializer_;
   ExternalReferenceEncoder* reference_encoder_;
   List<int> offsets_;
   List<Address> addresses_;
 };
 
 
 // Helper functions for a map of encoded heap object addresses.
 static uint32_t HeapObjectHash(HeapObject* key) {
-  return reinterpret_cast<uint32_t>(key) >> 2;
+  uint32_t low32bits = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(key));
+  return low32bits >> 2;
 }
 
 
 static bool MatchHeapObject(void* key1, void* key2) {
   return key1 == key2;
 }
 
 
 Serializer::Serializer()
   : global_handles_(4),
@@ skipping 218 matching lines @@
   }
   for (int i = contexts.length() - 1; i >= 0; i--) {
     HandleScopeImplementer::instance()->SaveContext(contexts[i]);
   }
   PutGlobalHandleStack(contexts);
 }
 
 
 void Serializer::PutEncodedAddress(Address addr) {
   writer_->PutC('P');
-  writer_->PutInt(reinterpret_cast<int>(addr));
+  writer_->PutAddress(addr);
 }
 
 
 Address Serializer::Encode(Object* o, bool* serialized) {
   *serialized = false;
   if (o->IsSmi()) {
     return reinterpret_cast<Address>(o);
   } else {
     HeapObject* obj = HeapObject::cast(o);
     if (IsVisited(obj)) {
@@ skipping 162 matching lines @@
   for (Object** p = start; p < end; ++p) {
     if (root) {
       roots_++;
       // Read the next object or pointer from the stream
       // pointer in the stream.
       int c = reader_.GetC();
       if (c == '[') {
         *p = GetObject();  // embedded object
       } else {
         ASSERT(c == 'P');  // pointer to previously serialized object
-        *p = Resolve(reinterpret_cast<Address>(reader_.GetInt()));
+        *p = Resolve(reader_.GetAddress());
       }
     } else {
       // A pointer internal to a HeapObject that we've already
       // read: resolve it to a true address (or Smi)
       *p = Resolve(reinterpret_cast<Address>(*p));
     }
   }
   root_ = root;
 }
 
 
 void Deserializer::VisitExternalReferences(Address* start, Address* end) {
   for (Address* p = start; p < end; ++p) {
-    uint32_t code = reinterpret_cast<uint32_t>(*p);
+    uint32_t code = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(*p));
     *p = reference_decoder_->Decode(code);
   }
 }
 
 
 void Deserializer::VisitRuntimeEntry(RelocInfo* rinfo) {
   uint32_t* pc = reinterpret_cast<uint32_t*>(rinfo->target_address_address());
   uint32_t encoding = *pc;
   Address target = reference_decoder_->Decode(encoding);
   rinfo->set_target_address(target);
@@ skipping 105 matching lines @@
   List<Handle<Object> > entered_contexts(2);
   GetGlobalHandleStack(&entered_contexts);
   for (int i = 0; i < entered_contexts.length(); i++) {
     HandleScopeImplementer::instance()->SaveContext(entered_contexts[i]);
   }
 }
 
 
 Address Deserializer::GetEncodedAddress() {
   reader_.ExpectC('P');
-  return reinterpret_cast<Address>(reader_.GetInt());
+  return reader_.GetAddress();
 }
 
 
 Object* Deserializer::GetObject() {
   // Read the prologue: type, size and encoded address.
   InstanceType type = static_cast<InstanceType>(reader_.GetInt());
   int size = reader_.GetInt() << kObjectAlignmentBits;
   Address a = GetEncodedAddress();
 
   // Get a raw object of the right size in the right space.
@@ skipping 113 matching lines @@
         ASSERT(index < large_objects_.length());
       }
       return large_objects_[index];  // s.page_offset() is ignored.
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 } }  // namespace v8::internal