[regexp] Turn last match info into a simple FixedArray

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/regexp/jsregexp.h"
 #include "src/regexp/regexp-utils.h"
@@ skipping 232 matching lines @@
                    language_mode);
     a->Goto(&out);
   }
 
   a->Bind(&out);
 }
 
 compiler::Node* ConstructNewResultFromMatchInfo(Isolate* isolate,
                                                 CodeStubAssembler* a,
                                                 compiler::Node* context,
-                                                compiler::Node* match_elements,
+                                                compiler::Node* match_info,
                                                 compiler::Node* string) {
   typedef CodeStubAssembler::Variable Variable;
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
   Label out(a);
 
   CodeStubAssembler::ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
   Node* const num_indices = a->SmiUntag(a->LoadFixedArrayElement(
-      match_elements, a->IntPtrConstant(RegExpImpl::kLastCaptureCount), 0,
+      match_info, a->IntPtrConstant(RegExpMatchInfo::kNumberOfCapturesIndex), 0,
       mode));
   Node* const num_results = a->SmiTag(a->WordShr(num_indices, 1));
   Node* const start = a->LoadFixedArrayElement(
-      match_elements, a->IntPtrConstant(RegExpImpl::kFirstCapture), 0, mode);
+      match_info, a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex), 0,
+      mode);
   Node* const end = a->LoadFixedArrayElement(
-      match_elements, a->IntPtrConstant(RegExpImpl::kFirstCapture + 1), 0,
+      match_info, a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex + 1), 0,
       mode);
 
   // Calculate the substring of the first match before creating the result array
   // to avoid an unnecessary write barrier storing the first result.
   Node* const first = a->SubString(context, string, start, end);
 
   Node* const result =
       a->AllocateRegExpResult(context, num_results, start, string);
   Node* const result_elements = a->LoadElements(result);
 
   a->StoreFixedArrayElement(result_elements, a->IntPtrConstant(0), first,
                             SKIP_WRITE_BARRIER);
 
   a->GotoIf(a->SmiEqual(num_results, a->SmiConstant(Smi::FromInt(1))), &out);
 
   // Store all remaining captures.
-  Node* const limit =
-      a->IntPtrAdd(a->IntPtrConstant(RegExpImpl::kFirstCapture), num_indices);
+  Node* const limit = a->IntPtrAdd(
+      a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex), num_indices);
 
   Variable var_from_cursor(a, MachineType::PointerRepresentation());
   Variable var_to_cursor(a, MachineType::PointerRepresentation());
 
-  var_from_cursor.Bind(a->IntPtrConstant(RegExpImpl::kFirstCapture + 2));
+  var_from_cursor.Bind(
+      a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex + 2));
   var_to_cursor.Bind(a->IntPtrConstant(1));
 
   Variable* vars[] = {&var_from_cursor, &var_to_cursor};
   Label loop(a, 2, vars);
 
   a->Goto(&loop);
   a->Bind(&loop);
   {
     Node* const from_cursor = var_from_cursor.value();
     Node* const to_cursor = var_to_cursor.value();
-    Node* const start = a->LoadFixedArrayElement(match_elements, from_cursor);
+    Node* const start = a->LoadFixedArrayElement(match_info, from_cursor);
 
     Label next_iter(a);
     a->GotoIf(a->SmiEqual(start, a->SmiConstant(Smi::FromInt(-1))), &next_iter);
 
     Node* const from_cursor_plus1 =
         a->IntPtrAdd(from_cursor, a->IntPtrConstant(1));
-    Node* const end =
-        a->LoadFixedArrayElement(match_elements, from_cursor_plus1);
+    Node* const end = a->LoadFixedArrayElement(match_info, from_cursor_plus1);
 
     Node* const capture = a->SubString(context, string, start, end);
     a->StoreFixedArrayElement(result_elements, to_cursor, capture);
     a->Goto(&next_iter);
 
     a->Bind(&next_iter);
     var_from_cursor.Bind(a->IntPtrAdd(from_cursor, a->IntPtrConstant(2)));
     var_to_cursor.Bind(a->IntPtrAdd(to_cursor, a->IntPtrConstant(1)));
     a->Branch(a->UintPtrLessThan(var_from_cursor.value(), limit), &loop, &out);
   }
@@ skipping 90 matching lines @@
   {
     // Get last match info from the context.
     Node* const last_match_info = a->LoadContextElement(
         native_context, Context::REGEXP_LAST_MATCH_INFO_INDEX);
 
     // Call the exec stub.
     Callable exec_callable = CodeFactory::RegExpExec(isolate);
     match_indices = a->CallStub(exec_callable, context, regexp, string,
                                 var_lastindex.value(), last_match_info);
 
-    // {match_indices} is either null or the RegExpLastMatchInfo array.
+    // {match_indices} is either null or the RegExpMatchInfo array.
     // Return early if exec failed, possibly updating last index.
     a->GotoUnless(a->WordEqual(match_indices, null), &successful_match);
 
     Label return_null(a);
     a->GotoUnless(should_update_last_index, &return_null);
 
     StoreLastIndex(a, context, has_initialmap, regexp, smi_zero);
     a->Goto(&return_null);
 
     a->Bind(&return_null);
     a->Return(null);
   }
 
   Label construct_result(a);
   a->Bind(&successful_match);
   {
-    Node* const match_elements = a->LoadElements(match_indices);
-
     a->GotoUnless(should_update_last_index, &construct_result);
 
     // Update the new last index from {match_indices}.
     Node* const new_lastindex = a->LoadFixedArrayElement(
-        match_elements, a->IntPtrConstant(RegExpImpl::kFirstCapture + 1));
+        match_indices,
+        a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex + 1));
 
     StoreLastIndex(a, context, has_initialmap, regexp, new_lastindex);
     a->Goto(&construct_result);
 
     a->Bind(&construct_result);
     {
       Node* result = ConstructNewResultFromMatchInfo(isolate, a, context,
-                                                     match_elements, string);
+                                                     match_indices, string);
       a->Return(result);
     }
   }
 }
 
 namespace {
 
 compiler::Node* ThrowIfNotJSReceiver(CodeStubAssembler* a, Isolate* isolate,
                                      compiler::Node* context,
                                      compiler::Node* value,
@@ skipping 413 matching lines @@
 DEFINE_CAPTURE_GETTER(8)
 DEFINE_CAPTURE_GETTER(9)
 #undef DEFINE_CAPTURE_GETTER
 
 // The properties `input` and `$_` are aliases for each other.  When this
 // value is set, the value it is set to is coerced to a string.
 // Getter and setter for the input.
 
 BUILTIN(RegExpInputGetter) {
   HandleScope scope(isolate);
-  Handle<Object> obj = RegExpUtils::GetLastMatchInput(
-      isolate, isolate->regexp_last_match_info());
+  Handle<Object> obj(isolate->regexp_last_match_info()->LastInput(), isolate);
   return obj->IsUndefined(isolate) ? isolate->heap()->empty_string()
                                    : String::cast(*obj);
 }
 
 BUILTIN(RegExpInputSetter) {
   HandleScope scope(isolate);
   Handle<Object> value = args.atOrUndefined(isolate, 1);
   Handle<String> str;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, str,
                                      Object::ToString(isolate, value));
-  RegExpUtils::SetLastMatchField(isolate, isolate->regexp_last_match_info(),
-                                 RegExpImpl::kLastInput, str);
+  isolate->regexp_last_match_info()->SetLastInput(*str);
   return isolate->heap()->undefined_value();
 }
 
 // Getters for the static properties lastMatch, lastParen, leftContext, and
 // rightContext of the RegExp constructor.  The properties are computed based
 // on the captures array of the last successful match and the subject string
 // of the last successful match.
 BUILTIN(RegExpLastMatchGetter) {
   HandleScope scope(isolate);
   return *RegExpUtils::GenericCaptureGetter(
       isolate, isolate->regexp_last_match_info(), 0);
 }
 
 BUILTIN(RegExpLastParenGetter) {
   HandleScope scope(isolate);
-  Handle<JSObject> match_info = isolate->regexp_last_match_info();
-  const int length =
-      RegExpUtils::GetLastMatchNumberOfCaptures(isolate, match_info);
+  Handle<RegExpMatchInfo> match_info = isolate->regexp_last_match_info();
+  const int length = match_info->NumberOfCaptureRegisters();
   if (length <= 2) return isolate->heap()->empty_string();  // No captures.
 
   DCHECK_EQ(0, length % 2);
   const int last_capture = (length / 2) - 1;
 
   // We match the SpiderMonkey behavior: return the substring defined by the
   // last pair (after the first pair) of elements of the capture array even if
   // it is empty.
   return *RegExpUtils::GenericCaptureGetter(isolate, match_info, last_capture);
 }
 
 BUILTIN(RegExpLeftContextGetter) {
   HandleScope scope(isolate);
-  Handle<JSObject> match_info = isolate->regexp_last_match_info();
-  const int start_index =
-      RegExpUtils::GetLastMatchCapture(isolate, match_info, 0);
-  Handle<String> last_subject =
-      RegExpUtils::GetLastMatchSubject(isolate, match_info);
+  Handle<RegExpMatchInfo> match_info = isolate->regexp_last_match_info();
+  const int start_index = match_info->Capture(0);
+  Handle<String> last_subject(match_info->LastSubject());
   return *isolate->factory()->NewSubString(last_subject, 0, start_index);
 }
 
 BUILTIN(RegExpRightContextGetter) {
   HandleScope scope(isolate);
-  Handle<JSObject> match_info = isolate->regexp_last_match_info();
-  const int start_index =
-      RegExpUtils::GetLastMatchCapture(isolate, match_info, 1);
-  Handle<String> last_subject =
-      RegExpUtils::GetLastMatchSubject(isolate, match_info);
+  Handle<RegExpMatchInfo> match_info = isolate->regexp_last_match_info();
+  const int start_index = match_info->Capture(1);
+  Handle<String> last_subject(match_info->LastSubject());
   const int len = last_subject->length();
   return *isolate->factory()->NewSubString(last_subject, start_index, len);
 }
 
 // ES#sec-regexp.prototype.test
 // RegExp.prototype.test ( S )
 BUILTIN(RegExpPrototypeTest) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSReceiver, recv, "RegExp.prototype.test");
 
@@ skipping 174 matching lines @@
                                  Handle<Object> limit_obj) {
   Factory* factory = isolate->factory();
 
   uint32_t limit;
   RETURN_ON_EXCEPTION(isolate, ToUint32(isolate, limit_obj, &limit), JSArray);
 
   const int length = string->length();
 
   if (limit == 0) return factory->NewJSArray(0);
 
-  Handle<JSObject> last_match_info = isolate->regexp_last_match_info();
+  Handle<RegExpMatchInfo> last_match_info = isolate->regexp_last_match_info();
 
   if (length == 0) {
     Handle<Object> match_indices;
     ASSIGN_RETURN_ON_EXCEPTION(
         isolate, match_indices,
         RegExpImpl::Exec(regexp, string, 0, last_match_info), JSArray);
 
     if (!match_indices->IsNull(isolate)) return factory->NewJSArray(0);
 
     Handle<FixedArray> elems = factory->NewUninitializedFixedArray(1);
@@ skipping 13 matching lines @@
     if (start_index == length) {
       Handle<String> substr =
           factory->NewSubString(string, current_index, length);
       elems = FixedArray::SetAndGrow(elems, num_elems++, substr);
       break;
     }
 
     Handle<Object> match_indices_obj;
     ASSIGN_RETURN_ON_EXCEPTION(
         isolate, match_indices_obj,
-        RegExpImpl::Exec(regexp, string, start_index, last_match_info),
+        RegExpImpl::Exec(regexp, string, start_index,
+                         isolate->regexp_last_match_info()),
         JSArray);
 
     if (match_indices_obj->IsNull(isolate)) {
       Handle<String> substr =
           factory->NewSubString(string, current_index, length);
       elems = FixedArray::SetAndGrow(elems, num_elems++, substr);
       break;
     }
 
-    auto match_indices = Handle<JSReceiver>::cast(match_indices_obj);
+    auto match_indices = Handle<RegExpMatchInfo>::cast(match_indices_obj);
 
-    Handle<Object> start_match_obj =
-        JSReceiver::GetElement(isolate, match_indices,
-                               RegExpImpl::kFirstCapture)
-            .ToHandleChecked();
-    start_match = Handle<Smi>::cast(start_match_obj)->value();
+    start_match = match_indices->Capture(0);
 
     if (start_match == length) {
       Handle<String> substr =
           factory->NewSubString(string, current_index, length);
       elems = FixedArray::SetAndGrow(elems, num_elems++, substr);
       break;
     }
 
-    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 end_index = match_indices->Capture(1);
 
     if (start_index == end_index && end_index == current_index) {
       const bool unicode = (regexp->GetFlags() & JSRegExp::kUnicode) != 0;
       if (unicode && AtSurrogatePair(isolate, string, start_index)) {
         start_index += 2;
       } else {
         start_index += 1;
       }
       continue;
     }
 
     {
       Handle<String> substr =
           factory->NewSubString(string, current_index, start_match);
       elems = FixedArray::SetAndGrow(elems, num_elems++, substr);
     }
 
     if (num_elems == limit) break;
 
-    Handle<Object> num_captures_obj =
-        JSReceiver::GetElement(isolate, match_indices,
-                               RegExpImpl::kLastCaptureCount)
-            .ToHandleChecked();
-    const int match_indices_len = Handle<Smi>::cast(num_captures_obj)->value() +
-                                  RegExpImpl::kFirstCapture;
-
-    for (int i = RegExpImpl::kFirstCapture + 2; i < match_indices_len;) {
-      Handle<Object> start_obj =
-          JSReceiver::GetElement(isolate, match_indices, i++).ToHandleChecked();
-      const int start = Handle<Smi>::cast(start_obj)->value();
-
-      Handle<Object> end_obj =
-          JSReceiver::GetElement(isolate, match_indices, i++).ToHandleChecked();
-      const int end = Handle<Smi>::cast(end_obj)->value();
+    for (int i = 2; i < match_indices->NumberOfCaptureRegisters(); i += 2) {
+      const int start = match_indices->Capture(i);
+      const int end = match_indices->Capture(i + 1);
 
       if (end != -1) {
         Handle<String> substr = factory->NewSubString(string, start, end);
         elems = FixedArray::SetAndGrow(elems, num_elems++, substr);
       } else {
         elems = FixedArray::SetAndGrow(elems, num_elems++,
                                        factory->undefined_value());
       }
 
       if (num_elems == limit) {
@@ skipping 275 matching lines @@
 
     a->Bind(&if_didnotmatch);
     {
       FastStoreLastIndex(a, context, regexp, smi_zero);
       var_result.Bind(subject_string);
       a->Goto(&out);
     }
 
     a->Bind(&if_matched);
     {
-      Node* const match_elements = a->LoadElements(match_indices);
       CodeStubAssembler::ParameterMode mode =
           CodeStubAssembler::INTPTR_PARAMETERS;
 
       Node* const subject_start = smi_zero;
       Node* const match_start = a->LoadFixedArrayElement(
-          match_elements, a->IntPtrConstant(RegExpImpl::kFirstCapture), 0,
-          mode);
+          match_indices, a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex),
+          0, mode);
       Node* const match_end = a->LoadFixedArrayElement(
-          match_elements, a->IntPtrConstant(RegExpImpl::kFirstCapture + 1), 0,
-          mode);
+          match_indices,
+          a->IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex + 1), 0, mode);
       Node* const subject_end = a->LoadStringLength(subject_string);
 
       Label if_replaceisempty(a), if_replaceisnotempty(a);
       Node* const replace_length = a->LoadStringLength(replace_string);
       a->Branch(a->SmiEqual(replace_length, smi_zero), &if_replaceisempty,
                 &if_replaceisnotempty);
 
       a->Bind(&if_replaceisempty);
       {
         // TODO(jgruber): We could skip many of the checks that using SubString
@@ skipping 93 matching lines @@
   }
 
   a->Bind(&runtime);
   {
     Node* const result = a->CallRuntime(Runtime::kRegExpReplace, context,
                                         receiver, string, replace_value);
     a->Return(result);
   }
 }
 
-namespace {
-
-// TODO(jgruber): Replace this with a FixedArray.
-compiler::Node* GetInternalMatchInfo(CodeStubAssembler* a,
-                                     compiler::Node* context) {
-  typedef compiler::Node Node;
-
-  const ElementsKind elements_kind = FAST_ELEMENTS;
-  Node* const native_context = a->LoadNativeContext(context);
-  Node* const array_map =
-      a->LoadJSArrayElementsMap(elements_kind, native_context);
-  Node* const capacity = a->IntPtrConstant(RegExpImpl::kLastMatchOverhead + 2);
-  Node* const allocation_site = nullptr;
-
-  Node* const smi_zero = a->SmiConstant(Smi::kZero);
-
-  return a->AllocateJSArray(elements_kind, array_map, capacity, smi_zero,
-                            allocation_site,
-                            CodeStubAssembler::INTPTR_PARAMETERS);
-}
-
-}  // namespace
-
 // Simple string matching functionality for internal use which does not modify
 // the last match info.
 void Builtins::Generate_RegExpInternalMatch(CodeStubAssembler* a) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
   Isolate* const isolate = a->isolate();
 
   Node* const regexp = a->Parameter(1);
   Node* const string = a->Parameter(2);
   Node* const context = a->Parameter(5);
 
   Node* const null = a->NullConstant();
   Node* const smi_zero = a->SmiConstant(Smi::FromInt(0));
-  Node* const internal_match_info = GetInternalMatchInfo(a, context);
+
+  Node* const native_context = a->LoadNativeContext(context);
+  Node* const internal_match_info = a->LoadContextElement(
+      native_context, Context::REGEXP_INTERNAL_MATCH_INFO_INDEX);
 
   Callable exec_callable = CodeFactory::RegExpExec(isolate);
   Node* const match_indices = a->CallStub(
       exec_callable, context, regexp, string, smi_zero, internal_match_info);
 
   Label if_matched(a), if_didnotmatch(a);
   a->Branch(a->WordEqual(match_indices, null), &if_didnotmatch, &if_matched);
 
   a->Bind(&if_didnotmatch);
   a->Return(null);
 
   a->Bind(&if_matched);
   {
-    Node* const match_elements = a->LoadElements(match_indices);
     Node* result = ConstructNewResultFromMatchInfo(isolate, a, context,
-                                                   match_elements, string);
+                                                   match_indices, string);
     a->Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8