Grow allocation in Zone::Realloc when possible.

runtime/vm/zone.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_ZONE_H_
 #define VM_ZONE_H_
 
 #include "platform/utils.h"
 #include "vm/allocation.h"
 #include "vm/handles.h"
@@ skipping 99 matching lines @@
   }
 
   // Delete all objects and free all memory allocated in the zone.
   void DeleteAll();
 
 #if defined(DEBUG)
   // Dump the current allocated sizes in the zone object.
   void DumpZoneSizes();
 #endif
 
+  // Overflow check (FATAL) for array length.
+  template <class ElementType>
+  static inline void CheckLength(intptr_t len);
+
   // This buffer is used for allocation before any segments.
   // This would act as the initial stack allocated chunk so that we don't
   // end up calling malloc/free on zone scopes that allocate less than
   // kChunkSize
   uint8_t buffer_[kInitialChunkSize];
   MemoryRegion initial_buffer_;
 
   // The free region in the current (head) segment or the initial buffer is
   // represented as the half-open interval [position, limit). The 'position'
   // variable is guaranteed to be aligned as dictated by kAlignment.
@@ skipping 88 matching lines @@
     position_ += size;
   } else {
     result = AllocateExpand(size);
   }
 
   // Check that the result has the proper alignment and return it.
   ASSERT(Utils::IsAligned(result, kAlignment));
   return result;
 }
 
+
+template <class ElementType>
+inline void Zone::CheckLength(intptr_t len) {
+  const intptr_t kElementSize = sizeof(ElementType);
+  if (len > (kIntptrMax / kElementSize)) {
+    FATAL2("Zone::Alloc: 'len' is too large: len=%" Pd ", kElementSize=%" Pd,
+           len, kElementSize);
+  }
+}
+
+
 template <class ElementType>
 inline ElementType* Zone::Alloc(intptr_t len) {
-  const intptr_t element_size = sizeof(ElementType);
-  if (len > (kIntptrMax / element_size)) {
-    FATAL2("Zone::Alloc: 'len' is too large: len=%" Pd ", element_size=%" Pd,
-           len, element_size);
-  }
-  return reinterpret_cast<ElementType*>(AllocUnsafe(len * element_size));
+  CheckLength<ElementType>(len);
+  return reinterpret_cast<ElementType*>(AllocUnsafe(len * sizeof(ElementType)));
 }
 
 template <class ElementType>
 inline ElementType* Zone::Realloc(ElementType* old_data,
-                                      intptr_t old_len,
-                                      intptr_t new_len) {
+                                  intptr_t old_len,
+                                  intptr_t new_len) {
+  CheckLength<ElementType>(new_len);
+  const intptr_t kElementSize = sizeof(ElementType);
+  uword old_end = reinterpret_cast<uword>(old_data) + (old_len * kElementSize);
+  // Resize existing allocation if nothing was allocated in between...
+  if (Utils::RoundUp(old_end, kAlignment) == position_) {
+    uword new_end =
+        reinterpret_cast<uword>(old_data) + (new_len * kElementSize);
+    // ...and there is sufficient space.
+    if (new_end <= limit_) {
+      position_ = Utils::RoundUp(new_end, kAlignment);
+      return old_data;
+    }
+  }
+  if (new_len <= old_len) {
+    return old_data;
+  }
   ElementType* new_data = Alloc<ElementType>(new_len);
   if (old_data != 0) {
     memmove(reinterpret_cast<void*>(new_data),
             reinterpret_cast<void*>(old_data),
-            Utils::Minimum(old_len * sizeof(ElementType),
-                           new_len * sizeof(ElementType)));
+            old_len * kElementSize);
   }
   return new_data;
 }
 
 }  // namespace dart
 
 #endif  // VM_ZONE_H_