Simplify IdentityMap.

src/identity-map.cc

 // Copyright 2015 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.
 
 #include "src/identity-map.h"
 
 #include "src/heap/heap.h"
 #include "src/heap/heap-inl.h"
 #include "src/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 
 static const int kInitialIdentityMapSize = 4;
 static const int kResizeFactor = 4;
 
 IdentityMapBase::~IdentityMapBase() {
-  if (keys_) {
-    Heap::OptionalRelocationLock lock(heap_, concurrent_);
-    heap_->UnregisterStrongRoots(keys_);
-  }
+  if (keys_) heap_->UnregisterStrongRoots(keys_);
 }
 
 
-IdentityMapBase::RawEntry IdentityMapBase::Lookup(Handle<Object> key) {
-  AllowHandleDereference for_lookup;
-  int index = LookupIndex(*key);
+IdentityMapBase::RawEntry IdentityMapBase::Lookup(Object* key) {
+  int index = LookupIndex(key);
   return index >= 0 ? &values_[index] : nullptr;
 }
 
 
-IdentityMapBase::RawEntry IdentityMapBase::Insert(Handle<Object> key) {
-  AllowHandleDereference for_lookup;
-  int index = InsertIndex(*key);
+IdentityMapBase::RawEntry IdentityMapBase::Insert(Object* key) {
+  int index = InsertIndex(key);
   DCHECK_GE(index, 0);
   return &values_[index];
 }
 
 
 int IdentityMapBase::Hash(Object* address) {
   CHECK_NE(address, heap_->not_mapped_symbol());
   uintptr_t raw_address = reinterpret_cast<uintptr_t>(address);
   // Xor some of the upper bits, since the lower 2 or 3 are usually aligned.
   return static_cast<int>((raw_address >> 11) ^ raw_address);
@@ skipping 32 matching lines @@
   }
   UNREACHABLE();
   return -1;
 }
 
 
 // Searches this map for the given key using the object's address
 // as the identity, returning:
 //    found => a pointer to the storage location for the value
 //    not found => a pointer to a new storage location for the value
-IdentityMapBase::RawEntry IdentityMapBase::GetEntry(Handle<Object> key) {
-  Heap::OptionalRelocationLock lock(heap_, concurrent_);
+IdentityMapBase::RawEntry IdentityMapBase::GetEntry(Object* key) {
   RawEntry result;
   if (size_ == 0) {
     // Allocate the initial storage for keys and values.
     size_ = kInitialIdentityMapSize;
     mask_ = kInitialIdentityMapSize - 1;
     gc_counter_ = heap_->gc_count();
 
     keys_ = zone_->NewArray<Object*>(size_);
     Object* not_mapped = heap_->not_mapped_symbol();
     for (int i = 0; i < size_; i++) keys_[i] = not_mapped;
@@ skipping 12 matching lines @@
     }
   }
   return result;
 }
 
 
 // Searches this map for the given key using the object's address
 // as the identity, returning:
 //    found => a pointer to the storage location for the value
 //    not found => {nullptr}
-IdentityMapBase::RawEntry IdentityMapBase::FindEntry(Handle<Object> key) {
+IdentityMapBase::RawEntry IdentityMapBase::FindEntry(Object* key) {
   if (size_ == 0) return nullptr;
 
-  Heap::OptionalRelocationLock lock(heap_, concurrent_);
   RawEntry result = Lookup(key);
   if (result == nullptr && gc_counter_ != heap_->gc_count()) {
     Rehash();  // Rehash is expensive, so only do it in case of a miss.
     result = Lookup(key);
   }
   return result;
 }
 
 
 void IdentityMapBase::Rehash() {
@@ skipping 53 matching lines @@
     DCHECK_GE(index, 0);
     values_[index] = old_values[i];
   }
 
   // Unregister old keys and register new keys.
   heap_->UnregisterStrongRoots(old_keys);
   heap_->RegisterStrongRoots(keys_, keys_ + size_);
 }
 }  // namespace internal
 }  // namespace v8