Keep track of the addition order of variables explicitly.

src/base/hashmap.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The reason we write our own hash map instead of using unordered_map in STL,
 // is that STL containers use a mutex pool on debug build, which will lead to
 // deadlock when we are using async signal handler.
 
 #ifndef V8_BASE_HASHMAP_H_
 #define V8_BASE_HASHMAP_H_
@@ skipping 30 matching lines @@
 
   ~TemplateHashMapImpl();
 
   // HashMap entries are (key, value, hash) triplets.
   // Some clients may not need to use the value slot
   // (e.g. implementers of sets, where the key is the value).
   struct Entry {
     void* key;
     void* value;
     uint32_t hash;  // The full hash value for key
-    int order;      // If you never remove entries this is the insertion order.
   };
 
   // If an entry with matching key is found, returns that entry.
   // Otherwise, NULL is returned.
   Entry* Lookup(void* key, uint32_t hash) const;
 
   // If an entry with matching key is found, returns that entry.
   // If no matching entry is found, a new entry is inserted with
   // corresponding key, key hash, and NULL value.
   Entry* LookupOrInsert(void* key, uint32_t hash,
@@ skipping 83 matching lines @@
 TemplateHashMapImpl<AllocationPolicy>::InsertNew(void* key, uint32_t hash,
                                                  AllocationPolicy allocator) {
   // Find a matching entry.
   Entry* p = Probe(key, hash);
   DCHECK(p->key == NULL);
 
   // No entry found; insert one.
   p->key = key;
   p->value = NULL;
   p->hash = hash;
-  p->order = occupancy_;
   occupancy_++;
 
   // Grow the map if we reached >= 80% occupancy.
   if (occupancy_ + occupancy_ / 4 >= capacity_) {
     Resize(allocator);
     p = Probe(key, hash);
   }
 
   return p;
 }
@@ skipping 127 matching lines @@
   uint32_t n = occupancy_;
 
   // Allocate larger map.
   Initialize(capacity_ * 2, allocator);
 
   // Rehash all current entries.
   for (Entry* p = map; n > 0; p++) {
     if (p->key != NULL) {
       Entry* entry = LookupOrInsert(p->key, p->hash, allocator);
       entry->value = p->value;
-      entry->order = p->order;
       n--;
     }
   }
 
   // Delete old map.
   AllocationPolicy::Delete(map);
 }
 
 // A hash map for pointer keys and values with an STL-like interface.
 template <class Key, class Value, class AllocationPolicy>
@@ skipping 43 matching lines @@
       return Iterator(this, this->LookupOrInsert(key, key->Hash(), allocator));
     }
     return Iterator(this, this->Lookup(key, key->Hash()));
   }
 };
 
 }  // namespace base
 }  // namespace v8
 
 #endif  // V8_BASE_HASHMAP_H_