[regexp] Turn last match info into a simple FixedArray

src/runtime/runtime-regexp.cc

 // Copyright 2014 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/runtime/runtime-utils.h"
 
 #include "src/arguments.h"
 #include "src/conversions-inl.h"
 #include "src/isolate-inl.h"
 #include "src/messages.h"
@@ skipping 383 matching lines @@
   static const size_t kMaxRegexpIndicesListCapacity = 8 * KB;
   if (isolate->regexp_indices()->capacity() > kMaxRegexpIndicesListCapacity) {
     isolate->regexp_indices()->Clear();  //  Throw away backing storage
   }
 }
 }  // namespace
 
 template <typename ResultSeqString>
 MUST_USE_RESULT static Object* StringReplaceGlobalAtomRegExpWithString(
     Isolate* isolate, Handle<String> subject, Handle<JSRegExp> pattern_regexp,
-    Handle<String> replacement, Handle<JSObject> last_match_info) {
+    Handle<String> replacement, Handle<RegExpMatchInfo> last_match_info) {
   DCHECK(subject->IsFlat());
   DCHECK(replacement->IsFlat());
 
   List<int>* indices = GetRewoundRegexpIndicesList(isolate);
 
   DCHECK_EQ(JSRegExp::ATOM, pattern_regexp->TypeTag());
   String* pattern =
       String::cast(pattern_regexp->DataAt(JSRegExp::kAtomPatternIndex));
   int subject_len = subject->length();
   int pattern_len = pattern->length();
@@ skipping 57 matching lines @@
                              indices->at(matches - 1) + pattern_len};
   RegExpImpl::SetLastMatchInfo(last_match_info, subject, 0, match_indices);
 
   TruncateRegexpIndicesList(isolate);
 
   return *result;
 }
 
 MUST_USE_RESULT static Object* StringReplaceGlobalRegExpWithString(
     Isolate* isolate, Handle<String> subject, Handle<JSRegExp> regexp,
-    Handle<String> replacement, Handle<JSObject> last_match_info) {
+    Handle<String> replacement, Handle<RegExpMatchInfo> last_match_info) {
   DCHECK(subject->IsFlat());
   DCHECK(replacement->IsFlat());
 
   int capture_count = regexp->CaptureCount();
   int subject_length = subject->length();
 
   // CompiledReplacement uses zone allocation.
   Zone zone(isolate->allocator());
   CompiledReplacement compiled_replacement(&zone);
   bool simple_replace =
@@ skipping 61 matching lines @@
 
   RegExpImpl::SetLastMatchInfo(last_match_info, subject, capture_count,
                                global_cache.LastSuccessfulMatch());
 
   RETURN_RESULT_OR_FAILURE(isolate, builder.ToString());
 }
 
 template <typename ResultSeqString>
 MUST_USE_RESULT static Object* StringReplaceGlobalRegExpWithEmptyString(
     Isolate* isolate, Handle<String> subject, Handle<JSRegExp> regexp,
-    Handle<JSObject> last_match_info) {
+    Handle<RegExpMatchInfo> last_match_info) {
   DCHECK(subject->IsFlat());
 
   // Shortcut for simple non-regexp global replacements
   if (regexp->TypeTag() == JSRegExp::ATOM) {
     Handle<String> empty_string = isolate->factory()->empty_string();
     if (subject->IsOneByteRepresentation()) {
       return StringReplaceGlobalAtomRegExpWithString<SeqOneByteString>(
           isolate, subject, regexp, empty_string, last_match_info);
     } else {
       return StringReplaceGlobalAtomRegExpWithString<SeqTwoByteString>(
@@ skipping 78 matching lines @@
     heap->CreateFillerObjectAt(end_of_string, delta, ClearRecordedSlots::kNo);
   }
   heap->AdjustLiveBytes(*answer, -delta, Heap::CONCURRENT_TO_SWEEPER);
   return *answer;
 }
 
 namespace {
 
 Object* StringReplaceGlobalRegExpWithStringHelper(
     Isolate* isolate, Handle<JSRegExp> regexp, Handle<String> subject,
-    Handle<String> replacement, Handle<JSObject> last_match_info) {
+    Handle<String> replacement, Handle<RegExpMatchInfo> last_match_info) {
   CHECK(regexp->GetFlags() & JSRegExp::kGlobal);
-  CHECK(last_match_info->HasFastObjectElements());
 
   subject = String::Flatten(subject);
 
   if (replacement->length() == 0) {
     if (subject->HasOnlyOneByteChars()) {
       return StringReplaceGlobalRegExpWithEmptyString<SeqOneByteString>(
           isolate, subject, regexp, last_match_info);
     } else {
       return StringReplaceGlobalRegExpWithEmptyString<SeqTwoByteString>(
           isolate, subject, regexp, last_match_info);
     }
   }
 
   replacement = String::Flatten(replacement);
 
   return StringReplaceGlobalRegExpWithString(isolate, subject, regexp,
                                              replacement, last_match_info);
 }
 
 }  // namespace
 
 RUNTIME_FUNCTION(Runtime_StringReplaceGlobalRegExpWithString) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 4);
 
   CONVERT_ARG_HANDLE_CHECKED(String, subject, 0);
   CONVERT_ARG_HANDLE_CHECKED(String, replacement, 2);
   CONVERT_ARG_HANDLE_CHECKED(JSRegExp, regexp, 1);
-  CONVERT_ARG_HANDLE_CHECKED(JSObject, last_match_info, 3);
+  CONVERT_ARG_HANDLE_CHECKED(RegExpMatchInfo, last_match_info, 3);
 
   return StringReplaceGlobalRegExpWithStringHelper(
       isolate, regexp, subject, replacement, last_match_info);
 }
 
 RUNTIME_FUNCTION(Runtime_StringSplit) {
   HandleScope handle_scope(isolate);
   DCHECK(args.length() == 3);
   CONVERT_ARG_HANDLE_CHECKED(String, subject, 0);
   CONVERT_ARG_HANDLE_CHECKED(String, pattern, 1);
@@ skipping 99 matching lines @@
 
   return *regexp;
 }
 
 RUNTIME_FUNCTION(Runtime_RegExpExec) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 4);
   CONVERT_ARG_HANDLE_CHECKED(JSRegExp, regexp, 0);
   CONVERT_ARG_HANDLE_CHECKED(String, subject, 1);
   CONVERT_INT32_ARG_CHECKED(index, 2);
-  CONVERT_ARG_HANDLE_CHECKED(JSObject, last_match_info, 3);
+  CONVERT_ARG_HANDLE_CHECKED(RegExpMatchInfo, last_match_info, 3);
   // Due to the way the JS calls are constructed this must be less than the
   // length of a string, i.e. it is always a Smi.  We check anyway for security.
   CHECK(index >= 0);
   CHECK(index <= subject->length());
   isolate->counters()->regexp_entry_runtime()->Increment();
   RETURN_RESULT_OR_FAILURE(
       isolate, RegExpImpl::Exec(regexp, subject, index, last_match_info));
 }
 
 
@@ skipping 45 matching lines @@
   return *regexp;
 }
 
 RUNTIME_FUNCTION(Runtime_RegExpInternalReplace) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 3);
   CONVERT_ARG_HANDLE_CHECKED(JSRegExp, regexp, 0);
   CONVERT_ARG_HANDLE_CHECKED(String, subject, 1);
   CONVERT_ARG_HANDLE_CHECKED(String, replacement, 2);
 
-  static const int kInitialMatchSlots = 2;
-  Handle<JSArray> internal_match_info = isolate->factory()->NewJSArray(
-      FAST_ELEMENTS, 0, RegExpImpl::kLastMatchOverhead + kInitialMatchSlots,
-      INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
+  Handle<RegExpMatchInfo> internal_match_info =
+      isolate->regexp_internal_match_info();
 
   return StringReplaceGlobalRegExpWithStringHelper(
       isolate, regexp, subject, replacement, internal_match_info);
 }
 
 namespace {
 
 class MatchInfoBackedMatch : public String::Match {
  public:
   MatchInfoBackedMatch(Isolate* isolate, Handle<String> subject,
-                       Handle<JSObject> match_info)
+                       Handle<RegExpMatchInfo> match_info)
       : isolate_(isolate), match_info_(match_info) {
     subject_ = String::Flatten(subject);
   }
 
   Handle<String> GetMatch() override {
     return RegExpUtils::GenericCaptureGetter(isolate_, match_info_, 0, nullptr);
   }
 
   MaybeHandle<String> GetCapture(int i, bool* capture_exists) override {
     Handle<Object> capture_obj =
         RegExpUtils::GenericCaptureGetter(isolate_, match_info_, i);
     if (capture_obj->IsUndefined(isolate_)) {
       *capture_exists = false;
       return isolate_->factory()->empty_string();
     }
     *capture_exists = true;
     return Object::ToString(isolate_, capture_obj);
   }
 
   Handle<String> GetPrefix() override {
-    const int match_start =
-        RegExpUtils::GetLastMatchCapture(isolate_, match_info_, 0);
+    const int match_start = match_info_->Capture(0);
     return isolate_->factory()->NewSubString(subject_, 0, match_start);
   }
 
   Handle<String> GetSuffix() override {
-    const int match_end =
-        RegExpUtils::GetLastMatchCapture(isolate_, match_info_, 1);
+    const int match_end = match_info_->Capture(1);
     return isolate_->factory()->NewSubString(subject_, match_end,
                                              subject_->length());
   }
 
   int CaptureCount() override {
-    return RegExpUtils::GetLastMatchNumberOfCaptures(isolate_, match_info_) / 2;
+    return match_info_->NumberOfCaptureRegisters() / 2;
   }
 
   virtual ~MatchInfoBackedMatch() {}
 
  private:
   Isolate* isolate_;
   Handle<String> subject_;
-  Handle<JSObject> match_info_;
+  Handle<RegExpMatchInfo> match_info_;
 };
 
 class VectorBackedMatch : public String::Match {
  public:
   VectorBackedMatch(Isolate* isolate, Handle<String> subject,
                     Handle<String> match, int match_position,
                     ZoneVector<Handle<Object>>* captures)
       : isolate_(isolate),
         match_(match),
         match_position_(match_position),
@@ skipping 31 matching lines @@
   Isolate* isolate_;
   Handle<String> subject_;
   Handle<String> match_;
   const int match_position_;
   ZoneVector<Handle<Object>>* captures_;
 };
 
 // Only called from RegExpExecMultiple so it doesn't need to maintain
 // separate last match info.  See comment on that function.
 template <bool has_capture>
-MaybeHandle<Object> SearchRegExpMultiple(Isolate* isolate,
-                                         Handle<String> subject,
-                                         Handle<JSRegExp> regexp,
-                                         Handle<JSObject> last_match_array,
-                                         Handle<FixedArray> result_elements) {
+MaybeHandle<Object> SearchRegExpMultiple(
+    Isolate* isolate, Handle<String> subject, Handle<JSRegExp> regexp,
+    Handle<RegExpMatchInfo> last_match_array,
+    Handle<FixedArray> result_elements) {
   DCHECK(subject->IsFlat());
   DCHECK_NE(has_capture, regexp->CaptureCount() == 0);
 
   int capture_count = regexp->CaptureCount();
   int subject_length = subject->length();
 
   static const int kMinLengthToCache = 0x1000;
 
   if (subject_length > kMinLengthToCache) {
     FixedArray* last_match_cache;
@@ skipping 123 matching lines @@
     return isolate->factory()->null_value();  // No matches at all.
   }
 }
 
 // This is only called for StringReplaceGlobalRegExpWithFunction.  This sets
 // lastMatchInfoOverride to maintain the last match info, so we don't need to
 // set any other last match array info.
 MaybeHandle<Object> RegExpExecMultiple(Isolate* isolate,
                                        Handle<JSRegExp> regexp,
                                        Handle<String> subject,
-                                       Handle<JSObject> last_match_info,
+                                       Handle<RegExpMatchInfo> last_match_info,
                                        Handle<FixedArray> result_array) {
-  CHECK(last_match_info->HasFastObjectElements());
-
   subject = String::Flatten(subject);
   CHECK(regexp->GetFlags() & JSRegExp::kGlobal);
 
   if (regexp->CaptureCount() == 0) {
     return SearchRegExpMultiple<false>(isolate, subject, regexp,
                                        last_match_info, result_array);
   } else {
     return SearchRegExpMultiple<true>(isolate, subject, regexp, last_match_info,
                                       result_array);
   }
 }
 
 // Helper function for replacing regular expressions with the result of a
 // function application in String.prototype.replace.
 MaybeHandle<String> StringReplaceGlobalRegExpWithFunction(
     Isolate* isolate, Handle<String> subject, Handle<JSRegExp> regexp,
     Handle<Object> replace_obj) {
   Factory* factory = isolate->factory();
 
   // TODO(jgruber): Convert result_array into a List<Handle<Object>> (or
   // similar) and adapt / remove FixedArrayBuilder.
-  Handle<JSObject> last_match_info = isolate->regexp_last_match_info();
+  Handle<RegExpMatchInfo> last_match_info = isolate->regexp_last_match_info();
   Handle<FixedArray> result_array = factory->NewFixedArrayWithHoles(16);
 
   Handle<Object> res;
   ASSIGN_RETURN_ON_EXCEPTION(isolate, res,
                              RegExpExecMultiple(isolate, regexp, subject,
                                                 last_match_info, result_array),
                              String);
 
   // Reload the last match info since it might have changed in the meantime.
   last_match_info = isolate->regexp_last_match_info();
 
   if (res->IsNull(isolate)) return subject;  // No matches at all.
 
   result_array = Handle<FixedArray>::cast(res);
   const int result_length = result_array->length();
 
-  const int num_captures =
-      RegExpUtils::GetLastMatchNumberOfCaptures(isolate, last_match_info) / 2;
+  const int num_captures = last_match_info->NumberOfCaptureRegisters() / 2;
   if (num_captures == 1) {
     // If the number of captures is one then there are no explicit captures in
     // the regexp, just the implicit capture that captures the whole match.  In
     // this case we can simplify quite a bit and end up with something faster.
     // The builder will consist of some integers that indicate slices of the
     // input string and some replacements that were returned from the replace
     // function.
     int match_start = 0;
     for (int i = 0; i < result_length; i++) {
       Handle<Object> elem = FixedArray::get(*result_array, i, isolate);
@@ skipping 112 matching lines @@
   }
 
   UNREACHABLE();
   return MaybeHandle<String>();
 }
 
 MaybeHandle<String> StringReplaceNonGlobalRegExpWithFunction(
     Isolate* isolate, Handle<String> subject, Handle<JSRegExp> regexp,
     Handle<Object> replace_obj) {
   Factory* factory = isolate->factory();
-  Handle<JSObject> last_match_info = isolate->regexp_last_match_info();
+  Handle<RegExpMatchInfo> last_match_info = isolate->regexp_last_match_info();
 
   // TODO(jgruber): This is a pattern we could refactor.
   Handle<Object> match_indices_obj;
   ASSIGN_RETURN_ON_EXCEPTION(
       isolate, match_indices_obj,
       RegExpImpl::Exec(regexp, subject, 0, last_match_info), String);
 
   if (match_indices_obj->IsNull(isolate)) {
     RETURN_ON_EXCEPTION(isolate, RegExpUtils::SetLastIndex(isolate, regexp, 0),
                         String);
     return subject;
   }
 
-  Handle<JSObject> match_indices = Handle<JSObject>::cast(match_indices_obj);
+  Handle<RegExpMatchInfo> match_indices =
+      Handle<RegExpMatchInfo>::cast(match_indices_obj);
 
-  const int index = RegExpUtils::GetLastMatchCapture(isolate, match_indices, 0);
-  const int end_of_match =
-      RegExpUtils::GetLastMatchCapture(isolate, match_indices, 1);
+  const int index = match_indices->Capture(0);
+  const int end_of_match = match_indices->Capture(1);
 
   IncrementalStringBuilder builder(isolate);
   builder.AppendString(factory->NewSubString(subject, 0, index));
 
   // Compute the parameter list consisting of the match, captures, index,
   // and subject for the replace function invocation.
   // The number of captures plus one for the match.
-  const int m =
-      RegExpUtils::GetLastMatchNumberOfCaptures(isolate, match_indices) / 2;
+  const int m = match_indices->NumberOfCaptureRegisters() / 2;
 
   const int argc = m + 2;
   ScopedVector<Handle<Object>> argv(argc);
 
   for (int j = 0; j < m; j++) {
     bool ok;
     Handle<String> capture =
         RegExpUtils::GenericCaptureGetter(isolate, match_indices, j, &ok);
     if (ok) {
       argv[j] = capture;
@@ skipping 35 matching lines @@
   const int flags = regexp->GetFlags();
   const bool global = (flags & JSRegExp::kGlobal) != 0;
 
   const bool functional_replace = replace_obj->IsCallable();
   if (!functional_replace) {
     Handle<String> replace;
     ASSIGN_RETURN_ON_EXCEPTION(isolate, replace,
                                Object::ToString(isolate, replace_obj), String);
     replace = String::Flatten(replace);
 
-    Handle<JSObject> last_match_info = isolate->regexp_last_match_info();
+    Handle<RegExpMatchInfo> last_match_info = isolate->regexp_last_match_info();
 
     if (!global) {
       // Non-global regexp search, string replace.
 
       Handle<Object> match_indices_obj;
       ASSIGN_RETURN_ON_EXCEPTION(
           isolate, match_indices_obj,
           RegExpImpl::Exec(regexp, string, 0, last_match_info), String);
 
       if (match_indices_obj->IsNull(isolate)) {
         RETURN_ON_EXCEPTION(
             isolate, RegExpUtils::SetLastIndex(isolate, regexp, 0), String);
         return string;
       }
 
-      auto match_indices = Handle<JSReceiver>::cast(match_indices_obj);
+      auto match_indices = Handle<RegExpMatchInfo>::cast(match_indices_obj);
 
-      Handle<Object> start_index_obj =
-          JSReceiver::GetElement(isolate, match_indices,
-                                 RegExpImpl::kFirstCapture)
-              .ToHandleChecked();
-      const int start_index = Handle<Smi>::cast(start_index_obj)->value();
-
-      Handle<Object> end_index_obj =
-          JSReceiver::GetElement(isolate, match_indices,
-                                 RegExpImpl::kFirstCapture + 1)
-              .ToHandleChecked();
-      const int end_index = Handle<Smi>::cast(end_index_obj)->value();
+      const int start_index = match_indices->Capture(0);
+      const int end_index = match_indices->Capture(1);
 
       IncrementalStringBuilder builder(isolate);
       builder.AppendString(factory->NewSubString(string, 0, start_index));
 
       if (replace->length() > 0) {
-        MatchInfoBackedMatch m(isolate, string, last_match_info);
+        MatchInfoBackedMatch m(isolate, string, match_indices);
         Handle<String> replacement;
         ASSIGN_RETURN_ON_EXCEPTION(
             isolate, replacement, String::GetSubstitution(isolate, &m, replace),
             String);
         builder.AppendString(replacement);
       }
 
       builder.AppendString(
           factory->NewSubString(string, end_index, string->length()));
       return builder.Finish();
@@ skipping 235 matching lines @@
 
 RUNTIME_FUNCTION(Runtime_IsRegExp) {
   SealHandleScope shs(isolate);
   DCHECK(args.length() == 1);
   CONVERT_ARG_CHECKED(Object, obj, 0);
   return isolate->heap()->ToBoolean(obj->IsJSRegExp());
 }
 
 }  // namespace internal
 }  // namespace v8