[regexp] Add support for dotAll flag

src/builtins/builtins-regexp-gen.cc

 // Copyright 2017 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-regexp-gen.h"
 
 #include "src/builtins/builtins-constructor-gen.h"
 #include "src/builtins/builtins-utils-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
@@ skipping 763 matching lines @@
 Node* RegExpBuiltinsAssembler::FlagsGetter(Node* const context,
                                            Node* const regexp,
                                            bool is_fastpath) {
   Isolate* isolate = this->isolate();
 
   Node* const int_zero = IntPtrConstant(0);
   Node* const int_one = IntPtrConstant(1);
   Variable var_length(this, MachineType::PointerRepresentation(), int_zero);
   Variable var_flags(this, MachineType::PointerRepresentation());
 
+  Node* const is_dotall_enabled = IsDotAllEnabled(isolate);
+
   // First, count the number of characters we will need and check which flags
   // are set.
 
   if (is_fastpath) {
     // Refer to JSRegExp's flag property on the fast-path.
     Node* const flags_smi = LoadObjectField(regexp, JSRegExp::kFlagsOffset);
     Node* const flags_intptr = SmiUntag(flags_smi);
     var_flags.Bind(flags_intptr);
 
 #define CASE_FOR_FLAG(FLAG)                                  \
   do {                                                       \
     Label next(this);                                        \
     GotoIfNot(IsSetWord(flags_intptr, FLAG), &next);         \
     var_length.Bind(IntPtrAdd(var_length.value(), int_one)); \
     Goto(&next);                                             \
     Bind(&next);                                             \
   } while (false)
 
     CASE_FOR_FLAG(JSRegExp::kGlobal);
     CASE_FOR_FLAG(JSRegExp::kIgnoreCase);
     CASE_FOR_FLAG(JSRegExp::kMultiline);
+    {
+      Label next(this);
+      GotoIfNot(is_dotall_enabled, &next);
+      CASE_FOR_FLAG(JSRegExp::kDotAll);
+      Goto(&next);
+      Bind(&next);
+    }
     CASE_FOR_FLAG(JSRegExp::kUnicode);
     CASE_FOR_FLAG(JSRegExp::kSticky);
 #undef CASE_FOR_FLAG
   } else {
     DCHECK(!is_fastpath);
 
     // Fall back to GetProperty stub on the slow-path.
     var_flags.Bind(int_zero);
 
 #define CASE_FOR_FLAG(NAME, FLAG)                                          \
   do {                                                                     \
     Label next(this);                                                      \
     Node* const flag = GetProperty(                                        \
         context, regexp, isolate->factory()->InternalizeUtf8String(NAME)); \
     Label if_isflagset(this);                                              \
     BranchIfToBooleanIsTrue(flag, &if_isflagset, &next);                   \
     Bind(&if_isflagset);                                                   \
     var_length.Bind(IntPtrAdd(var_length.value(), int_one));               \
     var_flags.Bind(WordOr(var_flags.value(), IntPtrConstant(FLAG)));       \
     Goto(&next);                                                           \
     Bind(&next);                                                           \
   } while (false)
 
     CASE_FOR_FLAG("global", JSRegExp::kGlobal);
     CASE_FOR_FLAG("ignoreCase", JSRegExp::kIgnoreCase);
     CASE_FOR_FLAG("multiline", JSRegExp::kMultiline);
+    {
+      Label next(this);
+      GotoIfNot(is_dotall_enabled, &next);
+      CASE_FOR_FLAG("dotAll", JSRegExp::kDotAll);
+      Goto(&next);
+      Bind(&next);
+    }
     CASE_FOR_FLAG("unicode", JSRegExp::kUnicode);
     CASE_FOR_FLAG("sticky", JSRegExp::kSticky);
 #undef CASE_FOR_FLAG
   }
 
   // Allocate a string of the required length and fill it with the corresponding
   // char for each set flag.
 
   {
     Node* const result = AllocateSeqOneByteString(context, var_length.value());
@@ skipping 11 matching lines @@
     StoreNoWriteBarrier(MachineRepresentation::kWord8, result, \
                         var_offset.value(), value);            \
     var_offset.Bind(IntPtrAdd(var_offset.value(), int_one));   \
     Goto(&next);                                               \
     Bind(&next);                                               \
   } while (false)
 
     CASE_FOR_FLAG(JSRegExp::kGlobal, 'g');
     CASE_FOR_FLAG(JSRegExp::kIgnoreCase, 'i');
     CASE_FOR_FLAG(JSRegExp::kMultiline, 'm');
+    {
+      Label next(this);
+      GotoIfNot(is_dotall_enabled, &next);
+      CASE_FOR_FLAG(JSRegExp::kDotAll, 's');
+      Goto(&next);
+      Bind(&next);
+    }
     CASE_FOR_FLAG(JSRegExp::kUnicode, 'u');
     CASE_FOR_FLAG(JSRegExp::kSticky, 'y');
 #undef CASE_FOR_FLAG
 
     return result;
   }
 }
 
 // ES#sec-isregexp IsRegExp ( argument )
 Node* RegExpBuiltinsAssembler::IsRegExp(Node* const context,
@@ skipping 332 matching lines @@
   switch (flag) {
     case JSRegExp::kGlobal:
       name = factory->global_string();
       break;
     case JSRegExp::kIgnoreCase:
       name = factory->ignoreCase_string();
       break;
     case JSRegExp::kMultiline:
       name = factory->multiline_string();
       break;
+    case JSRegExp::kDotAll:
+      UNREACHABLE();  // Never called for dotAll.
+      break;
     case JSRegExp::kSticky:
       name = factory->sticky_string();
       break;
     case JSRegExp::kUnicode:
       name = factory->unicode_string();
       break;
     default:
       UNREACHABLE();
   }
 
@@ skipping 20 matching lines @@
 
 Node* RegExpBuiltinsAssembler::FlagGetter(Node* const context,
                                           Node* const regexp,
                                           JSRegExp::Flag flag,
                                           bool is_fastpath) {
   return is_fastpath ? FastFlagGetter(regexp, flag)
                      : SlowFlagGetter(context, regexp, flag);
 }
 
 void RegExpBuiltinsAssembler::FlagGetter(Node* context, Node* receiver,
-                                         JSRegExp::Flag flag,
-                                         v8::Isolate::UseCounterFeature counter,
+                                         JSRegExp::Flag flag, int counter,
                                          const char* method_name) {
   Isolate* isolate = this->isolate();
 
   // Check whether we have an unmodified regexp instance.
   Label if_isunmodifiedjsregexp(this),
       if_isnotunmodifiedjsregexp(this, Label::kDeferred);
 
   GotoIf(TaggedIsSmi(receiver), &if_isnotunmodifiedjsregexp);
 
   Node* const receiver_map = LoadMap(receiver);
@@ skipping 17 matching lines @@
     Node* const initial_map =
         LoadObjectField(regexp_fun, JSFunction::kPrototypeOrInitialMapOffset);
     Node* const initial_prototype = LoadMapPrototype(initial_map);
 
     Label if_isprototype(this), if_isnotprototype(this);
     Branch(WordEqual(receiver, initial_prototype), &if_isprototype,
            &if_isnotprototype);
 
     Bind(&if_isprototype);
     {
-      Node* const counter_smi = SmiConstant(Smi::FromInt(counter));
-      CallRuntime(Runtime::kIncrementUseCounter, context, counter_smi);
+      if (counter != -1) {
+        Node* const counter_smi = SmiConstant(Smi::FromInt(counter));
+        CallRuntime(Runtime::kIncrementUseCounter, context, counter_smi);
+      }
       Return(UndefinedConstant());
     }
 
     Bind(&if_isnotprototype);
     {
       Node* const message_id =
           SmiConstant(Smi::FromInt(MessageTemplate::kRegExpNonRegExp));
       Node* const method_name_str = HeapConstant(
           isolate->factory()->NewStringFromAsciiChecked(method_name));
       CallRuntime(Runtime::kThrowTypeError, context, message_id,
@@ skipping 26 matching lines @@
 // ES6 21.2.5.7.
 // ES #sec-get-regexp.prototype.multiline
 TF_BUILTIN(RegExpPrototypeMultilineGetter, RegExpBuiltinsAssembler) {
   Node* context = Parameter(Descriptor::kContext);
   Node* receiver = Parameter(Descriptor::kReceiver);
   FlagGetter(context, receiver, JSRegExp::kMultiline,
              v8::Isolate::kRegExpPrototypeOldFlagGetter,
              "RegExp.prototype.multiline");
 }
 
+Node* RegExpBuiltinsAssembler::IsDotAllEnabled(Isolate* isolate) {
+  Node* flag_ptr = ExternalConstant(
+      ExternalReference::address_of_regexp_dotall_flag(isolate));
+  Node* flag_value = Load(MachineType::IntPtr(), flag_ptr);
+  return WordNotEqual(flag_value, IntPtrConstant(0));
+}
+
+// ES #sec-get-regexp.prototype.dotAll
+TF_BUILTIN(RegExpPrototypeDotAllGetter, RegExpBuiltinsAssembler) {
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  static const int kNoCounter = -1;
+  CSA_ASSERT(this, IsDotAllEnabled(isolate()));
+  FlagGetter(context, receiver, JSRegExp::kDotAll, kNoCounter,
+             "RegExp.prototype.dotAll");
+}
+
 // ES6 21.2.5.12.
 // ES #sec-get-regexp.prototype.sticky
 TF_BUILTIN(RegExpPrototypeStickyGetter, RegExpBuiltinsAssembler) {
   Node* context = Parameter(Descriptor::kContext);
   Node* receiver = Parameter(Descriptor::kReceiver);
   FlagGetter(context, receiver, JSRegExp::kSticky,
              v8::Isolate::kRegExpPrototypeStickyGetter,
              "RegExp.prototype.sticky");
 }
 
@@ skipping 1330 matching lines @@
   Bind(&if_matched);
   {
     Node* result =
         ConstructNewResultFromMatchInfo(context, regexp, match_indices, string);
     Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8