Changed statement ZoneList to a ZoneChunkList

src/compiler/store-store-elimination.cc

 // Copyright 2016 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 <iterator>
 
 #include "src/compiler/store-store-elimination.h"
 
 #include "src/compiler/all-nodes.h"
 #include "src/compiler/js-graph.h"
@@ skipping 455 matching lines @@
 }
 
 UnobservablesSet UnobservablesSet::Unvisited() { return UnobservablesSet(); }
 
 UnobservablesSet::UnobservablesSet() : set_(nullptr) {}
 
 UnobservablesSet UnobservablesSet::VisitedEmpty(Zone* zone) {
   // Create a new empty UnobservablesSet. This allocates in the zone, and
   // can probably be optimized to use a global singleton.
   ZoneSet<UnobservableStore>* empty_set =
-      new (zone->New(sizeof(ZoneSet<UnobservableStore>)))
-          ZoneSet<UnobservableStore>(zone);
+      new (zone) ZoneSet<UnobservableStore>(zone);
   return UnobservablesSet(empty_set);
 }
 
 // Computes the intersection of two UnobservablesSets. May return
 // UnobservablesSet::Unvisited() instead of an empty UnobservablesSet for
 // speed.
 UnobservablesSet UnobservablesSet::Intersect(UnobservablesSet other,
                                              Zone* zone) const {
   if (IsEmpty() || other.IsEmpty()) {
     return Unvisited();
   } else {
     ZoneSet<UnobservableStore>* intersection =
-        new (zone->New(sizeof(ZoneSet<UnobservableStore>)))
-            ZoneSet<UnobservableStore>(zone);
+        new (zone) ZoneSet<UnobservableStore>(zone);
     // Put the intersection of set() and other.set() in intersection.
     set_intersection(set()->begin(), set()->end(), other.set()->begin(),
                      other.set()->end(),
                      std::inserter(*intersection, intersection->end()));
 
     return UnobservablesSet(intersection);
   }
 }
 
 UnobservablesSet UnobservablesSet::Add(UnobservableStore obs,
                                        Zone* zone) const {
   bool present = (set()->find(obs) != set()->end());
   if (present) {
     return *this;
   } else {
     // Make a new empty set.
     ZoneSet<UnobservableStore>* new_set =
-        new (zone->New(sizeof(ZoneSet<UnobservableStore>)))
-            ZoneSet<UnobservableStore>(zone);
+        new (zone) ZoneSet<UnobservableStore>(zone);
     // Copy the old elements over.
     *new_set = *set();
     // Add the new element.
     bool inserted = new_set->insert(obs).second;
     DCHECK(inserted);
     USE(inserted);  // silence warning about unused variable
 
     return UnobservablesSet(new_set);
   }
 }
 
 UnobservablesSet UnobservablesSet::RemoveSameOffset(StoreOffset offset,
                                                     Zone* zone) const {
   // Make a new empty set.
   ZoneSet<UnobservableStore>* new_set =
-      new (zone->New(sizeof(ZoneSet<UnobservableStore>)))
-          ZoneSet<UnobservableStore>(zone);
+      new (zone) ZoneSet<UnobservableStore>(zone);
   // Copy all elements over that have a different offset.
   for (auto obs : *set()) {
     if (obs.offset_ != offset) {
       new_set->insert(obs);
     }
   }
 
   return UnobservablesSet(new_set);
 }
 
@@ skipping 19 matching lines @@
   return !(*this == other);
 }
 
 bool UnobservableStore::operator<(const UnobservableStore other) const {
   return (id_ < other.id_) || (id_ == other.id_ && offset_ < other.offset_);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8