Used ZoneChunkList in deoptimizer

src/zone/zone-chunk-list.h

 // 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 <stdlib.h>
 
 #include "src/globals.h"
 #include "src/zone/zone.h"
 
 #ifndef V8_SRC_ZONE_ZONE_CHUNK_LIST_H_
@@ skipping 64 matching lines @@
   // free the actual memory, since it is zone allocated.
   void Rewind(const size_t limit = 0);
 
   // Quickly scans the list to retrieve the element at the given index. Will
   // *not* check bounds.
   ForwardZoneChunkListIterator<T> Find(const size_t index);
   ForwardZoneChunkListIterator<const T> Find(const size_t index) const;
   // TODO(heimbuef): Add 'rFind', seeking from the end and returning a
   // reverse iterator.
 
+  void CopyTo(T* ptr);
+
   ForwardZoneChunkListIterator<T> begin();
   ForwardZoneChunkListIterator<T> end();
   ReverseZoneChunkListIterator<T> rbegin();
   ReverseZoneChunkListIterator<T> rend();
   ForwardZoneChunkListIterator<const T> begin() const;
   ForwardZoneChunkListIterator<const T> end() const;
   ReverseZoneChunkListIterator<const T> rbegin() const;
   ReverseZoneChunkListIterator<const T> rend() const;
 
  private:
@@ skipping 290 matching lines @@
 
 template <typename T>
 ForwardZoneChunkListIterator<const T> ZoneChunkList<T>::Find(
     const size_t index) const {
   SeekResult seek_result = SeekIndex(index);
   return ForwardZoneChunkListIterator<const T>(seek_result.chunk_,
                                                seek_result.chunk_index_);
 }
 
 template <typename T>
+void ZoneChunkList<T>::CopyTo(T* ptr) {
+  for (Chunk* current = front_; current != nullptr; current = current->next_) {
+    void* start = current->items();
+    void* end = current->items() + current->position_;
+    size_t bytes = static_cast<size_t>(reinterpret_cast<uintptr_t>(end) -
+                                       reinterpret_cast<uintptr_t>(start));
+
+    MemCopy(ptr, current->items(), bytes);
+    ptr += current->position_;
+  }
+}
+
+template <typename T>
 ForwardZoneChunkListIterator<T> ZoneChunkList<T>::begin() {
   return ForwardZoneChunkListIterator<T>::Begin(this);
 }
 
 template <typename T>
 ForwardZoneChunkListIterator<T> ZoneChunkList<T>::end() {
   return ForwardZoneChunkListIterator<T>::End(this);
 }
 
 template <typename T>
@@ skipping 23 matching lines @@
 
 template <typename T>
 ReverseZoneChunkListIterator<const T> ZoneChunkList<T>::rend() const {
   return ReverseZoneChunkListIterator<const T>::End(this);
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_SRC_ZONE_ZONE_CHUNK_LIST_H_