Move hashmap into base/.

src/heap/heap-inl.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.
 
 #ifndef V8_HEAP_HEAP_INL_H_
 #define V8_HEAP_HEAP_INL_H_
 
 #include <cmath>
 
 #include "src/base/platform/platform.h"
@@ skipping 508 matching lines @@
       return nullptr;
     default:
       UNREACHABLE();
   }
   UNREACHABLE();
   return nullptr;
 }
 
 template <Heap::UpdateAllocationSiteMode mode>
 void Heap::UpdateAllocationSite(HeapObject* object,
-                                HashMap* pretenuring_feedback) {
+                                base::HashMap* pretenuring_feedback) {
   DCHECK(InFromSpace(object));
   if (!FLAG_allocation_site_pretenuring ||
       !AllocationSite::CanTrack(object->map()->instance_type()))
     return;
   AllocationMemento* memento_candidate = FindAllocationMemento<kForGC>(object);
   if (memento_candidate == nullptr) return;
 
   if (mode == kGlobal) {
     DCHECK_EQ(pretenuring_feedback, global_pretenuring_feedback_);
     // Entering global pretenuring feedback is only used in the scavenger, where
     // we are allowed to actually touch the allocation site.
     if (!memento_candidate->IsValid()) return;
     AllocationSite* site = memento_candidate->GetAllocationSite();
     DCHECK(!site->IsZombie());
     // For inserting in the global pretenuring storage we need to first
     // increment the memento found count on the allocation site.
     if (site->IncrementMementoFoundCount()) {
       global_pretenuring_feedback_->LookupOrInsert(site,
                                                    ObjectHash(site->address()));
     }
   } else {
     DCHECK_EQ(mode, kCached);
     DCHECK_NE(pretenuring_feedback, global_pretenuring_feedback_);
     // Entering cached feedback is used in the parallel case. We are not allowed
     // to dereference the allocation site and rather have to postpone all checks
     // till actually merging the data.
     Address key = memento_candidate->GetAllocationSiteUnchecked();
-    HashMap::Entry* e =
+    base::HashMap::Entry* e =
         pretenuring_feedback->LookupOrInsert(key, ObjectHash(key));
     DCHECK(e != nullptr);
     (*bit_cast<intptr_t*>(&e->value))++;
   }
 }
 
 
 void Heap::RemoveAllocationSitePretenuringFeedback(AllocationSite* site) {
   global_pretenuring_feedback_->Remove(
       site, static_cast<uint32_t>(bit_cast<uintptr_t>(site)));
@@ skipping 182 matching lines @@
 
 void VerifySmisVisitor::VisitPointers(Object** start, Object** end) {
   for (Object** current = start; current < end; current++) {
     CHECK((*current)->IsSmi());
   }
 }
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_HEAP_INL_H_