Replace uint64_t type with ObjectId and use uint32_t as the base for ObjectId type.

src/profile-generator.cc

 // Copyright 2012 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 947 matching lines @@
 
 
 HeapEntry* HeapGraphEdge::From() {
   return reinterpret_cast<HeapEntry*>(this - child_index_) - 1;
 }
 
 
 void HeapEntry::Init(HeapSnapshot* snapshot,
                      Type type,
                      const char* name,
-                     uint64_t id,
+                     ObjectId id,
                      int self_size,
                      int children_count,
                      int retainers_count) {
   snapshot_ = snapshot;
   type_ = type;
   painted_ = false;
   name_ = name;
   self_size_ = self_size;
   retained_size_ = 0;
   children_count_ = children_count;
   retainers_count_ = retainers_count;
   dominator_ = NULL;
 
   union {
-    uint64_t set_id;
+    ObjectId set_id;
     Id stored_id;
   } id_adaptor = {id};
   id_ = id_adaptor.stored_id;
 }
 
 
 void HeapEntry::SetNamedReference(HeapGraphEdge::Type type,
                                   int child_index,
                                   const char* name,
                                   HeapEntry* entry,
@@ skipping 220 matching lines @@
       VisitorSynchronization::kTagNames[tag],
       HeapObjectsMap::GetNthGcSubrootId(tag),
       0,
       children_count,
       retainers_count));
 }
 
 
 HeapEntry* HeapSnapshot::AddEntry(HeapEntry::Type type,
                                   const char* name,
-                                  uint64_t id,
+                                  ObjectId id,
                                   int size,
                                   int children_count,
                                   int retainers_count) {
   HeapEntry* entry = GetNextEntryToInit();
   entry->Init(this, type, name, id, size, children_count, retainers_count);
   return entry;
 }
 
 
 void HeapSnapshot::SetDominatorsToSelf() {
@@ skipping 11 matching lines @@
         reinterpret_cast<char*>(last_entry) + last_entry->EntrySize()));
   } else {
     entries_.Add(reinterpret_cast<HeapEntry*>(raw_entries_));
   }
   ASSERT(reinterpret_cast<char*>(entries_.last()) <
          (raw_entries_ + raw_entries_size_));
   return entries_.last();
 }
 
 
-HeapEntry* HeapSnapshot::GetEntryById(uint64_t id) {
+HeapEntry* HeapSnapshot::GetEntryById(ObjectId id) {
   List<HeapEntry*>* entries_by_id = GetSortedEntriesList();
 
   // Perform a binary search by id.
   int low = 0;
   int high = entries_by_id->length() - 1;
   while (low <= high) {
     int mid =
         (static_cast<unsigned int>(low) + static_cast<unsigned int>(high)) >> 1;
-    uint64_t mid_id = entries_by_id->at(mid)->id();
+    ObjectId mid_id = entries_by_id->at(mid)->id();
     if (mid_id > id)
       high = mid - 1;
     else if (mid_id < id)
       low = mid + 1;
     else
       return entries_by_id->at(mid);
   }
   return NULL;
 }
 
@@ skipping 15 matching lines @@
 }
 
 
 void HeapSnapshot::Print(int max_depth) {
   root()->Print("", "", max_depth, 0);
 }
 
 
 // We split IDs on evens for embedder objects (see
 // HeapObjectsMap::GenerateId) and odds for native objects.
-const uint64_t HeapObjectsMap::kInternalRootObjectId = 1;
-const uint64_t HeapObjectsMap::kGcRootsObjectId =
+const ObjectId HeapObjectsMap::kInternalRootObjectId = 1;
+const ObjectId HeapObjectsMap::kGcRootsObjectId =
     HeapObjectsMap::kInternalRootObjectId + HeapObjectsMap::kObjectIdStep;
-const uint64_t HeapObjectsMap::kGcRootsFirstSubrootId =
+const ObjectId HeapObjectsMap::kGcRootsFirstSubrootId =
     HeapObjectsMap::kGcRootsObjectId + HeapObjectsMap::kObjectIdStep;
-const uint64_t HeapObjectsMap::kFirstAvailableObjectId =
+const ObjectId HeapObjectsMap::kFirstAvailableObjectId =
     HeapObjectsMap::kGcRootsFirstSubrootId +
     VisitorSynchronization::kNumberOfSyncTags * HeapObjectsMap::kObjectIdStep;
 
 HeapObjectsMap::HeapObjectsMap()
     : initial_fill_mode_(true),
       next_id_(kFirstAvailableObjectId),
       entries_map_(AddressesMatch),
       entries_(new List<EntryInfo>()) { }
 
 
 HeapObjectsMap::~HeapObjectsMap() {
   delete entries_;
 }
 
 
 void HeapObjectsMap::SnapshotGenerationFinished() {
   initial_fill_mode_ = false;
   RemoveDeadEntries();
 }
 
 
-uint64_t HeapObjectsMap::FindObject(Address addr) {
+ObjectId HeapObjectsMap::FindObject(Address addr) {
   if (!initial_fill_mode_) {
-    uint64_t existing = FindEntry(addr);
+    ObjectId existing = FindEntry(addr);
     if (existing != 0) return existing;
   }
-  uint64_t id = next_id_;
+  ObjectId id = next_id_;
   next_id_ += kObjectIdStep;
   AddEntry(addr, id);
   return id;
 }
 
 
 void HeapObjectsMap::MoveObject(Address from, Address to) {
   if (from == to) return;
   HashMap::Entry* entry = entries_map_.Lookup(from, AddressHash(from), false);
   if (entry != NULL) {
     void* value = entry->value;
     entries_map_.Remove(from, AddressHash(from));
     if (to != NULL) {
       entry = entries_map_.Lookup(to, AddressHash(to), true);
       // We can have an entry at the new location, it is OK, as GC can overwrite
       // dead objects with alive objects being moved.
       entry->value = value;
     }
   }
 }
 
 
-void HeapObjectsMap::AddEntry(Address addr, uint64_t id) {
+void HeapObjectsMap::AddEntry(Address addr, ObjectId id) {
   HashMap::Entry* entry = entries_map_.Lookup(addr, AddressHash(addr), true);
   ASSERT(entry->value == NULL);
   entry->value = reinterpret_cast<void*>(entries_->length());
   entries_->Add(EntryInfo(id));
 }
 
 
-uint64_t HeapObjectsMap::FindEntry(Address addr) {
+ObjectId HeapObjectsMap::FindEntry(Address addr) {
   HashMap::Entry* entry = entries_map_.Lookup(addr, AddressHash(addr), false);
   if (entry != NULL) {
     int entry_index =
         static_cast<int>(reinterpret_cast<intptr_t>(entry->value));
     EntryInfo& entry_info = entries_->at(entry_index);
     entry_info.accessed = true;
     return entry_info.id;
   } else {
     return 0;
   }
@@ skipping 19 matching lines @@
   for (int i = 0; i < dead_entries.length(); ++i) {
     void* raw_entry = dead_entries[i];
     entries_map_.Remove(
         raw_entry, AddressHash(reinterpret_cast<Address>(raw_entry)));
   }
   delete entries_;
   entries_ = new_entries;
 }
 
 
-uint64_t HeapObjectsMap::GenerateId(v8::RetainedObjectInfo* info) {
-  uint64_t id = static_cast<uint64_t>(info->GetHash());
+ObjectId HeapObjectsMap::GenerateId(v8::RetainedObjectInfo* info) {
+  ObjectId id = static_cast<ObjectId>(info->GetHash());
   const char* label = info->GetLabel();
   id ^= HashSequentialString(label,
                              static_cast<int>(strlen(label)),
                              HEAP->HashSeed());
   intptr_t element_count = info->GetElementCount();
   if (element_count != -1)
     id ^= ComputeIntegerHash(static_cast<uint32_t>(element_count),
                              v8::internal::kZeroHashSeed);
   return id << 1;
 }
@@ skipping 49 matching lines @@
 
 
 void HeapSnapshotsCollection::RemoveSnapshot(HeapSnapshot* snapshot) {
   snapshots_.RemoveElement(snapshot);
   unsigned uid = snapshot->uid();
   snapshots_uids_.Remove(reinterpret_cast<void*>(uid),
                          static_cast<uint32_t>(uid));
 }
 
 
-Handle<HeapObject> HeapSnapshotsCollection::FindHeapObjectById(uint64_t id) {
+Handle<HeapObject> HeapSnapshotsCollection::FindHeapObjectById(ObjectId id) {
   // First perform a full GC in order to avoid dead objects.
   HEAP->CollectAllGarbage(Heap::kMakeHeapIterableMask,
                           "HeapSnapshotsCollection::FindHeapObjectById");
   AssertNoAllocation no_allocation;
   HeapObject* object = NULL;
   HeapIterator iterator(HeapIterator::kFilterUnreachable);
   // Make sure that object with the given id is still reachable.
   for (HeapObject* obj = iterator.next();
        obj != NULL;
        obj = iterator.next()) {
@@ skipping 2033 matching lines @@
   STATIC_CHECK(sizeof(int) == sizeof(GetNodeId(edge->to())));  // NOLINT
   int result = OS::SNPrintF(buffer, ",%d,%d,%d",
       edge->type(), edge_name_or_index, GetNodeId(edge->to()));
   USE(result);
   ASSERT(result != -1);
   writer_->AddString(buffer.start());
 }
 
 
 void HeapSnapshotJSONSerializer::SerializeNode(HeapEntry* entry) {
-  // The buffer needs space for 6 ints, 1 uint64_t, 7 commas, \n and \0
+  // The buffer needs space for 6 ints, 1 uint32_t, 7 commas, \n and \0
   static const int kBufferSize =
       6 * MaxDecimalDigitsIn<sizeof(int)>::kSigned  // NOLINT
-      + MaxDecimalDigitsIn<sizeof(uint64_t)>::kUnsigned  // NOLINT
+      + MaxDecimalDigitsIn<sizeof(uint32_t)>::kUnsigned  // NOLINT
       + 7 + 1 + 1;
   EmbeddedVector<char, kBufferSize> buffer;
   Vector<HeapGraphEdge> children = entry->children();
   STATIC_CHECK(sizeof(int) == sizeof(entry->type()));  // NOLINT
   STATIC_CHECK(sizeof(int) == sizeof(GetStringId(entry->name())));  // NOLINT
-  STATIC_CHECK(sizeof(uint64_t) == sizeof(entry->id()));  // NOLINT
+  STATIC_CHECK(sizeof(uint32_t) == sizeof(entry->id()));  // NOLINT

[alexeif, 2012/03/06 16:07:52]

It should be 'unsigned'. The idea here is to check the types against the printf
format codes used below. The 'id' is printed with %u.

Otherwise once we hit an arch having 64-bit int type the check won't trigger and
we silently pass 32-bit value into printf which would expect 64-bit value.

   STATIC_CHECK(sizeof(int) == sizeof(entry->self_size()));  // NOLINT
   STATIC_CHECK(sizeof(int) == sizeof(entry->retained_size()));  // NOLINT
   STATIC_CHECK(sizeof(int) == sizeof(GetNodeId(entry->dominator())));  // NOLINT
   STATIC_CHECK(sizeof(int) == sizeof(children.length()));  // NOLINT
-  int result = OS::SNPrintF(buffer, "\n,%d,%d,%llu,%d,%d,%d,%d",
+  int result = OS::SNPrintF(buffer, "\n,%d,%d,%u,%d,%d,%d,%d",
       entry->type(),
       GetStringId(entry->name()),
       entry->id(),
       entry->self_size(),
       entry->retained_size(),
       GetNodeId(entry->dominator()),
       children.length());
   USE(result);
   ASSERT(result != -1);
   writer_->AddString(buffer.start());
@@ skipping 180 matching lines @@
 
 
 void HeapSnapshotJSONSerializer::SortHashMap(
     HashMap* map, List<HashMap::Entry*>* sorted_entries) {
   for (HashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p))
     sorted_entries->Add(p);
   sorted_entries->Sort(SortUsingEntryValue);
 }
 
 } }  // namespace v8::internal