[base] Revert "Move hashmap allocator to a field"

src/asmjs/asm-wasm-builder.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/v8.h"
 
 // Required to get M_E etc. in MSVC.
 #if defined(_WIN32)
 #define _USE_MATH_DEFINES
 #endif
@@ skipping 646 matching lines @@
   struct FunctionTableIndices : public ZoneObject {
     uint32_t start_index;
     uint32_t signature_index;
   };
 
   void InsertFunctionTable(Variable* v, uint32_t start_index,
                            uint32_t signature_index) {
     FunctionTableIndices* container = new (zone()) FunctionTableIndices();
     container->start_index = start_index;
     container->signature_index = signature_index;
-    ZoneHashMap::Entry* entry =
-        function_tables_.LookupOrInsert(v, ComputePointerHash(v));
+    ZoneHashMap::Entry* entry = function_tables_.LookupOrInsert(
+        v, ComputePointerHash(v), ZoneAllocationPolicy(zone()));
     entry->value = container;
   }
 
   FunctionTableIndices* LookupFunctionTable(Variable* v) {
     ZoneHashMap::Entry* entry =
         function_tables_.Lookup(v, ComputePointerHash(v));
     DCHECK_NOT_NULL(entry);
     return reinterpret_cast<FunctionTableIndices*>(entry->value);
   }
 
@@ skipping 14 matching lines @@
    public:
     explicit ImportedFunctionTable(AsmWasmBuilderImpl* builder)
         : table_(base::HashMap::PointersMatch,
                  ZoneHashMap::kDefaultHashMapCapacity,
                  ZoneAllocationPolicy(builder->zone())),
           builder_(builder) {}
 
     void AddImport(Variable* v, const char* name, int name_length) {
       ImportedFunctionIndices* indices = new (builder_->zone())
           ImportedFunctionIndices(name, name_length, builder_->zone());
-      ZoneHashMap::Entry* entry =
-          table_.LookupOrInsert(v, ComputePointerHash(v));
+      ZoneHashMap::Entry* entry = table_.LookupOrInsert(
+          v, ComputePointerHash(v), ZoneAllocationPolicy(builder_->zone()));
       entry->value = indices;
     }
 
     uint32_t GetFunctionIndex(Variable* v, FunctionSig* sig) {
       ZoneHashMap::Entry* entry = table_.Lookup(v, ComputePointerHash(v));
       DCHECK_NOT_NULL(entry);
       ImportedFunctionIndices* indices =
           reinterpret_cast<ImportedFunctionIndices*>(entry->value);
       WasmModuleBuilder::SignatureMap::iterator pos =
           indices->signature_to_index_.find(sig);
@@ skipping 972 matching lines @@
   uint32_t LookupOrInsertLocal(Variable* v, LocalType type) {
     DCHECK_NOT_NULL(current_function_builder_);
     ZoneHashMap::Entry* entry =
         local_variables_.Lookup(v, ComputePointerHash(v));
     if (entry == nullptr) {
       uint32_t index;
       DCHECK(!v->IsParameter());
       index = current_function_builder_->AddLocal(type);
       IndexContainer* container = new (zone()) IndexContainer();
       container->index = index;
-      entry = local_variables_.LookupOrInsert(v, ComputePointerHash(v));
+      entry = local_variables_.LookupOrInsert(v, ComputePointerHash(v),
+                                              ZoneAllocationPolicy(zone()));
       entry->value = container;
     }
     return (reinterpret_cast<IndexContainer*>(entry->value))->index;
   }
 
   void InsertParameter(Variable* v, LocalType type, uint32_t index) {
     DCHECK(v->IsParameter());
     DCHECK_NOT_NULL(current_function_builder_);
     ZoneHashMap::Entry* entry =
         local_variables_.Lookup(v, ComputePointerHash(v));
     DCHECK_NULL(entry);
     IndexContainer* container = new (zone()) IndexContainer();
     container->index = index;
-    entry = local_variables_.LookupOrInsert(v, ComputePointerHash(v));
+    entry = local_variables_.LookupOrInsert(v, ComputePointerHash(v),
+                                            ZoneAllocationPolicy(zone()));
     entry->value = container;
   }
 
   uint32_t LookupOrInsertGlobal(Variable* v, LocalType type) {
     ZoneHashMap::Entry* entry =
         global_variables_.Lookup(v, ComputePointerHash(v));
     if (entry == nullptr) {
       uint32_t index = builder_->AddGlobal(type, 0);
       IndexContainer* container = new (zone()) IndexContainer();
       container->index = index;
-      entry = global_variables_.LookupOrInsert(v, ComputePointerHash(v));
+      entry = global_variables_.LookupOrInsert(v, ComputePointerHash(v),
+                                               ZoneAllocationPolicy(zone()));
       entry->value = container;
     }
     return (reinterpret_cast<IndexContainer*>(entry->value))->index;
   }
 
   uint32_t LookupOrInsertFunction(Variable* v) {
     DCHECK_NOT_NULL(builder_);
     ZoneHashMap::Entry* entry = functions_.Lookup(v, ComputePointerHash(v));
     if (entry == nullptr) {
       uint32_t index = builder_->AddFunction();
       IndexContainer* container = new (zone()) IndexContainer();
       container->index = index;
-      entry = functions_.LookupOrInsert(v, ComputePointerHash(v));
+      entry = functions_.LookupOrInsert(v, ComputePointerHash(v),
+                                        ZoneAllocationPolicy(zone()));
       entry->value = container;
     }
     return (reinterpret_cast<IndexContainer*>(entry->value))->index;
   }
 
   LocalType TypeOf(Expression* expr) { return TypeFrom(typer_->TypeOf(expr)); }
 
   LocalType TypeFrom(AsmType* type) {
     if (type->IsA(AsmType::Intish())) {
       return kAstI32;
@@ skipping 50 matching lines @@
   impl.builder_->WriteTo(*buffer);
   return buffer;
 }
 
 const char* AsmWasmBuilder::foreign_init_name = "__foreign_init__";
 const char* AsmWasmBuilder::single_function_name = "__single_function__";
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8