[regexp] Shrink results array in @@match and @@split

src/builtins/builtins-regexp.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 "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/regexp/jsregexp.h"
 #include "src/regexp/regexp-utils.h"
@@ skipping 1368 matching lines @@
 
     Node* const length = var_length_.value();
     Node* const capacity = var_capacity_.value();
 
     Label grow(a), store(a);
     a->Branch(a->IntPtrEqual(capacity, length), &grow, &store);
 
     a->Bind(&grow);
     {
       Node* const new_capacity = NewCapacity(a, capacity);
-      Node* const new_array = GrowFixedArray(capacity, new_capacity, mode);
+      Node* const new_array = ResizeFixedArray(length, new_capacity, mode);
 
       var_capacity_.Bind(new_capacity);
       var_array_.Bind(new_array);
       a->Goto(&store);
     }
 
     a->Bind(&store);
     {
       Node* const array = var_array_.value();
       a->StoreFixedArrayElement(array, length, value, barrier_mode, 0, mode);
 
       Node* const new_length = a->IntPtrAdd(length, a->IntPtrConstant(1));
       var_length_.Bind(new_length);
     }
   }
 
   Node* ToJSArray(Node* const context) {
     CodeStubAssembler* a = assembler_;
 
     const ElementsKind kind = FAST_ELEMENTS;
+    const ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
 
     Node* const native_context = a->LoadNativeContext(context);
     Node* const array_map = a->LoadJSArrayElementsMap(kind, native_context);
 
+    // Shrink to fit if necessary.
+    {
+      Label next(a);
+
+      Node* const length = var_length_.value();
+      Node* const capacity = var_capacity_.value();
+
+      a->GotoIf(a->WordEqual(length, capacity), &next);
+
+      Node* const array = ResizeFixedArray(length, length, mode);
+      var_array_.Bind(array);
+      var_capacity_.Bind(length);
+      a->Goto(&next);
+
+      a->Bind(&next);
+    }
+
     Node* const result_length = a->SmiTag(length());
     Node* const result = a->AllocateUninitializedJSArrayWithoutElements(
         kind, array_map, result_length, nullptr);
 
     // Note: We do not currently shrink the fixed array.
 
     a->StoreObjectField(result, JSObject::kElementsOffset, var_array_.value());
 
     return result;
   }
@@ skipping 23 matching lines @@
     // Growth rate is analog to JSObject::NewElementsCapacity:
     // new_capacity = (current_capacity + (current_capacity >> 1)) + 16.
 
     Node* const new_capacity = a->IntPtrAdd(
         a->IntPtrAdd(current_capacity, a->WordShr(current_capacity, 1)),
         a->IntPtrConstant(16));
 
     return new_capacity;
   }
 
-  Node* GrowFixedArray(Node* const current_capacity, Node* const new_capacity,
-                       ParameterMode mode) {
+  // Creates a new array with {new_capacity} and copies the first
+  // {element_count} elements from the current array.
+  Node* ResizeFixedArray(Node* const element_count, Node* const new_capacity,
+                         ParameterMode mode) {
     DCHECK(mode == CodeStubAssembler::INTPTR_PARAMETERS);
 
     CodeStubAssembler* a = assembler_;
 
-    CSA_ASSERT(a, a->IntPtrGreaterThan(current_capacity, a->IntPtrConstant(0)));
-    CSA_ASSERT(a, a->IntPtrGreaterThan(new_capacity, current_capacity));
+    CSA_ASSERT(a, a->IntPtrGreaterThan(element_count, a->IntPtrConstant(0)));
+    CSA_ASSERT(a, a->IntPtrGreaterThan(new_capacity, a->IntPtrConstant(0)));
+    CSA_ASSERT(a, a->IntPtrGreaterThanOrEqual(new_capacity, element_count));
 
     const ElementsKind kind = FAST_ELEMENTS;
     const WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER;
     const CodeStubAssembler::AllocationFlags flags =
         CodeStubAssembler::kAllowLargeObjectAllocation;
 
     Node* const from_array = var_array_.value();
     Node* const to_array =
         a->AllocateFixedArray(kind, new_capacity, mode, flags);
-    a->CopyFixedArrayElements(kind, from_array, kind, to_array,
-                              current_capacity, new_capacity, barrier_mode,
-                              mode);
+    a->CopyFixedArrayElements(kind, from_array, kind, to_array, element_count,
+                              new_capacity, barrier_mode, mode);
 
     return to_array;
   }
 
  private:
   CodeStubAssembler* const assembler_;
   Variable var_array_;
   Variable var_length_;
   Variable var_capacity_;
 };
@@ skipping 1037 matching lines @@
   Bind(&if_matched);
   {
     Node* result =
         ConstructNewResultFromMatchInfo(context, match_indices, string);
     Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8