[regexp] Create property on result for each named capture

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-constructor.h"
 #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"
@@ skipping 15 matching lines @@
  protected:
   Node* FastLoadLastIndex(Node* regexp);
   Node* SlowLoadLastIndex(Node* context, Node* regexp);
   Node* LoadLastIndex(Node* context, Node* regexp, bool is_fastpath);
 
   void FastStoreLastIndex(Node* regexp, Node* value);
   void SlowStoreLastIndex(Node* context, Node* regexp, Node* value);
   void StoreLastIndex(Node* context, Node* regexp, Node* value,
                       bool is_fastpath);
 
-  Node* ConstructNewResultFromMatchInfo(Node* context, Node* match_info,
-                                        Node* string);
+  Node* ConstructNewResultFromMatchInfo(Node* const context, Node* const regexp,
+                                        Node* const match_info,
+                                        Node* const string);
 
   Node* RegExpPrototypeExecBodyWithoutResult(Node* const context,
                                              Node* const regexp,
                                              Node* const string,
                                              Label* if_didnotmatch,
                                              const bool is_fastpath);
   Node* RegExpPrototypeExecBody(Node* const context, Node* const regexp,
                                 Node* const string, const bool is_fastpath);
 
   Node* ThrowIfNotJSReceiver(Node* context, Node* maybe_receiver,
@@ skipping 86 matching lines @@
 
 void RegExpBuiltinsAssembler::StoreLastIndex(Node* context, Node* regexp,
                                              Node* value, bool is_fastpath) {
   if (is_fastpath) {
     FastStoreLastIndex(regexp, value);
   } else {
     SlowStoreLastIndex(context, regexp, value);
   }
 }
 
-Node* RegExpBuiltinsAssembler::ConstructNewResultFromMatchInfo(Node* context,
-                                                               Node* match_info,
-                                                               Node* string) {
-  Label out(this);
+Node* RegExpBuiltinsAssembler::ConstructNewResultFromMatchInfo(
+    Node* const context, Node* const regexp, Node* const match_info,
+    Node* const string) {
+  Label named_captures(this), out(this);
 
   Node* const num_indices = SmiUntag(LoadFixedArrayElement(
       match_info, RegExpMatchInfo::kNumberOfCapturesIndex));
   Node* const num_results = SmiTag(WordShr(num_indices, 1));
   Node* const start =
       LoadFixedArrayElement(match_info, RegExpMatchInfo::kFirstCaptureIndex);
   Node* const end = LoadFixedArrayElement(
       match_info, RegExpMatchInfo::kFirstCaptureIndex + 1);
 
   // 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 = SubString(context, string, start, end);
 
   Node* const result =
       AllocateRegExpResult(context, num_results, start, string);
   Node* const result_elements = LoadElements(result);
 
   StoreFixedArrayElement(result_elements, 0, first, SKIP_WRITE_BARRIER);
 
-  GotoIf(SmiEqual(num_results, SmiConstant(Smi::FromInt(1))), &out);
+  GotoIf(SmiEqual(num_results, SmiConstant(1)), &named_captures);
 
   // Store all remaining captures.
   Node* const limit = IntPtrAdd(
       IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex), num_indices);
 
   Variable var_from_cursor(this, MachineType::PointerRepresentation());
   Variable var_to_cursor(this, MachineType::PointerRepresentation());
 
   var_from_cursor.Bind(IntPtrConstant(RegExpMatchInfo::kFirstCaptureIndex + 2));
   var_to_cursor.Bind(IntPtrConstant(1));
 
   Variable* vars[] = {&var_from_cursor, &var_to_cursor};
   Label loop(this, 2, vars);
 
   Goto(&loop);
   Bind(&loop);
   {
     Node* const from_cursor = var_from_cursor.value();
     Node* const to_cursor = var_to_cursor.value();
     Node* const start = LoadFixedArrayElement(match_info, from_cursor);
 
     Label next_iter(this);
-    GotoIf(SmiEqual(start, SmiConstant(Smi::FromInt(-1))), &next_iter);
+    GotoIf(SmiEqual(start, SmiConstant(-1)), &next_iter);
 
     Node* const from_cursor_plus1 = IntPtrAdd(from_cursor, IntPtrConstant(1));
     Node* const end = LoadFixedArrayElement(match_info, from_cursor_plus1);
 
     Node* const capture = SubString(context, string, start, end);
     StoreFixedArrayElement(result_elements, to_cursor, capture);
     Goto(&next_iter);
 
     Bind(&next_iter);
     var_from_cursor.Bind(IntPtrAdd(from_cursor, IntPtrConstant(2)));
     var_to_cursor.Bind(IntPtrAdd(to_cursor, IntPtrConstant(1)));
-    Branch(UintPtrLessThan(var_from_cursor.value(), limit), &loop, &out);
+    Branch(UintPtrLessThan(var_from_cursor.value(), limit), &loop,
+           &named_captures);
+  }
+
+  Bind(&named_captures);
+  {
+    // Preparations for named capture properties. Exit early if the result is
+    // either not an IRREGEXP or does not have any named captures to minimize
+    // performance impact.
+
+    CSA_ASSERT(this, HasInstanceType(regexp, JS_REGEXP_TYPE));
+    Node* const data = LoadObjectField(regexp, JSRegExp::kDataOffset);

[jgruber, 2017/01/17 09:26:51]

This unconditionally adds two loads and two branches to each exec path. 

I'd like to see the impact before optimizing; packing a new internal flag into
JSRegExp::Flags isn't completely trivial since e.g. flags are sometimes
reconstructed from the flags string.

[Yang, 2017/01/18 13:25:36]

I think we can already make this a bit simpler: we only need to care about named
captures if we have any captures at all. If we have captures, then it cannot be
an atom regexp, so the tag check is redundant too.

[jgruber, 2017/01/19 15:59:12]

Very good point, done. 

+    Node* const tag = LoadFixedArrayElement(data, JSRegExp::kTagIndex);
+    GotoUnless(SmiEqual(tag, SmiConstant(JSRegExp::IRREGEXP)), &out);
+
+    // The names fixed array associates names at even indices with a capture
+    // index at odd indices.
+    Node* const names =
+        LoadFixedArrayElement(data, JSRegExp::kIrregexpCaptureNameMapIndex);
+    GotoIf(SmiEqual(names, SmiConstant(0)), &out);
+
+    // One or more named captures exist, add a property for each one.
+
+    CSA_ASSERT(this, HasInstanceType(names, FIXED_ARRAY_TYPE));
+    Node* const names_length = LoadAndUntagFixedArrayBaseLength(names);
+    CSA_ASSERT(this, IntPtrGreaterThan(names_length, IntPtrConstant(0)));
+
+    Variable var_i(this, MachineType::PointerRepresentation());
+    var_i.Bind(IntPtrConstant(0));
+
+    Variable* vars[] = {&var_i};
+    const int vars_count = sizeof(vars) / sizeof(vars[0]);
+    Label loop(this, vars_count, vars);
+
+    Goto(&loop);
+    Bind(&loop);
+    {
+      Node* const i = var_i.value();
+      Node* const i_plus_1 = IntPtrAdd(i, IntPtrConstant(1));
+      Node* const i_plus_2 = IntPtrAdd(i_plus_1, IntPtrConstant(1));
+
+      Node* const name = LoadFixedArrayElement(names, i);
+      Node* const index = LoadFixedArrayElement(names, i_plus_1);
+      Node* const capture =
+          LoadFixedArrayElement(result_elements, SmiUntag(index));
+
+      Node* const language_mode = SmiConstant(Smi::FromInt(STRICT));
+      CallRuntime(Runtime::kSetProperty, context, result, name, capture,
+                  language_mode);
+
+      var_i.Bind(i_plus_2);
+      Branch(IntPtrGreaterThanOrEqual(var_i.value(), names_length), &out,
+             &loop);
+    }
   }
 
   Bind(&out);
   return result;
 }
 
 // ES#sec-regexp.prototype.exec
 // RegExp.prototype.exec ( string )
 // Implements the core of RegExp.prototype.exec but without actually
 // constructing the JSRegExpResult. Returns either null (if the RegExp did not
@@ skipping 132 matching lines @@
   Variable var_result(this, MachineRepresentation::kTagged);
 
   Label if_didnotmatch(this), out(this);
   Node* const indices_or_null = RegExpPrototypeExecBodyWithoutResult(
       context, regexp, string, &if_didnotmatch, is_fastpath);
 
   // Successful match.
   {
     Node* const match_indices = indices_or_null;
     Node* const result =
-        ConstructNewResultFromMatchInfo(context, match_indices, string);
+        ConstructNewResultFromMatchInfo(context, regexp, match_indices, string);
     var_result.Bind(result);
     Goto(&out);
   }
 
   Bind(&if_didnotmatch);
   {
     var_result.Bind(null);
     Goto(&out);
   }
 
@@ skipping 2149 matching lines @@
 
   Label if_matched(this), if_didnotmatch(this);
   Branch(WordEqual(match_indices, null), &if_didnotmatch, &if_matched);
 
   Bind(&if_didnotmatch);
   Return(null);
 
   Bind(&if_matched);
   {
     Node* result =
-        ConstructNewResultFromMatchInfo(context, match_indices, string);
+        ConstructNewResultFromMatchInfo(context, regexp, match_indices, string);
     Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8