Changeset 221160 in webkit for trunk/Source/JavaScriptCore/yarr/YarrJIT.cpp

Timestamp:

Aug 24, 2017, 2:14:43 PM (8 years ago)

Author:

[email protected]

Message:

Add support for RegExp "dotAll" flag
​https://bugs.webkit.org/show_bug.cgi?id=175924

Reviewed by Keith Miller.

JSTests:

Updated tests for new dotAll ('s' flag) changes.

• es6/Proxy_internal_get_calls_RegExp.prototype.flags.js:
• stress/static-getter-in-names.js:

Source/JavaScriptCore:

The dotAll RegExp flag, 's', changes . to match any character including line terminators.
Added a the "dotAll" identifier as well as RegExp.prototype.dotAll getter.
Added a new any character CharacterClass that is used to match . terms in a dotAll flags
RegExp. In the YARR pattern and parsing code, changed the NewlineClassID, which was only
used for '.' processing, to DotClassID. The selection of which builtin character class
that DotClassID resolves to when generating the pattern is conditional on the dotAll flag.
This NewlineClassID to DotClassID refactoring includes the atomBuiltInCharacterClass() in
the WebCore content extensions code in the PatternParser class.

As an optimization, the Yarr JIT actually doesn't perform match checks against the builtin
any character CharacterClass, it merely reads the character. There is another optimization
in our DotStart enclosure processing where a non-capturing regular expression in the form
of .*<expression.*, with options beginning ^{and/or trailing $, match the contained
expression and then look for the extents of the surrounding .*'s. When used with the
dotAll flag, that processing alwys results with the beinning of the string and the end
of the string. Therefore we short circuit the finding the beginning and end of the line
or string with dotAll patterns.}

• bytecode/BytecodeDumper.cpp:

(JSC::regexpToSourceString):

• runtime/CommonIdentifiers.h:
• runtime/RegExp.cpp:

(JSC::regExpFlags):
(JSC::RegExpFunctionalTestCollector::outputOneTest):

• runtime/RegExp.h:
• runtime/RegExpKey.h:
• runtime/RegExpPrototype.cpp:

(JSC::RegExpPrototype::finishCreation):
(JSC::flagsString):
(JSC::regExpProtoGetterDotAll):

• yarr/YarrInterpreter.cpp:

(JSC::Yarr::Interpreter::matchDotStarEnclosure):

• yarr/YarrInterpreter.h:

(JSC::Yarr::BytecodePattern::dotAll const):

• yarr/YarrJIT.cpp:

(JSC::Yarr::YarrGenerator::optimizeAlternative):
(JSC::Yarr::YarrGenerator::generateCharacterClassOnce):
(JSC::Yarr::YarrGenerator::generateCharacterClassFixed):
(JSC::Yarr::YarrGenerator::generateCharacterClassGreedy):
(JSC::Yarr::YarrGenerator::backtrackCharacterClassNonGreedy):
(JSC::Yarr::YarrGenerator::generateDotStarEnclosure):

• yarr/YarrParser.h:

(JSC::Yarr::Parser::parseTokens):

• yarr/YarrPattern.cpp:

(JSC::Yarr::YarrPatternConstructor::atomBuiltInCharacterClass):
(JSC::Yarr::YarrPatternConstructor::atomCharacterClassBuiltIn):
(JSC::Yarr::YarrPatternConstructor::optimizeDotStarWrappedExpressions):
(JSC::Yarr::YarrPattern::YarrPattern):
(JSC::Yarr::PatternTerm::dump):
(JSC::Yarr::anycharCreate):

• yarr/YarrPattern.h:

(JSC::Yarr::YarrPattern::reset):
(JSC::Yarr::YarrPattern::anyCharacterClass):
(JSC::Yarr::YarrPattern::dotAll const):

Source/WebCore:

Changed due to refactoring NewlineClassID to DotClassID.

No new tests. No change in behavior.

• contentextensions/URLFilterParser.cpp:

(WebCore::ContentExtensions::PatternParser::atomBuiltInCharacterClass):

LayoutTests:

• js/regexp-dotall-expected.txt: Added.
• js/regexp-dotall.html: Added.
• js/script-tests/Object-getOwnPropertyNames.js:
• js/script-tests/regexp-dotall.js: Added.

New tests.

• js/Object-getOwnPropertyNames-expected.txt:

Updated tests for new dotAll ('s' flag) changes.

File:

• trunk/Source/JavaScriptCore/yarr/YarrJIT.cpp (modified) (5 diffs)

trunk/Source/JavaScriptCore/yarr/YarrJIT.cpp

@@ -1170 +1170 @@
         JumpList matchDest;
         readCharacter(m_checkedOffset - term->inputPosition, character);
-        matchCharacterClass(character, matchDest, term->characterClass);
-
-        if (term->invert())
-            op.m_jumps.append(matchDest);
-        else {
-            op.m_jumps.append(jump());
-            matchDest.link(this);
-        }
-
+        // If we are matching the "any character" builtin class we only need to read the
+        // character and don't need to match as it will always succeed.
+        if (term->invert() || term->characterClass != m_pattern.anyCharacterClass()) {
+            matchCharacterClass(character, matchDest, term->characterClass);
+
+            if (term->invert())
+                op.m_jumps.append(matchDest);
+            else {
+                op.m_jumps.append(jump());
+                matchDest.link(this);
+            }
+        }
 #ifdef JIT_UNICODE_EXPRESSIONS
         if (m_decodeSurrogatePairs) {
@@ -1216 +1219 @@
         JumpList matchDest;
         readCharacter(m_checkedOffset - term->inputPosition - term->quantityMaxCount, character, countRegister);
-        matchCharacterClass(character, matchDest, term->characterClass);
-
-        if (term->invert())
-            op.m_jumps.append(matchDest);
-        else {
-            op.m_jumps.append(jump());
-            matchDest.link(this);
+        // If we are matching the "any character" builtin class we only need to read the
+        // character and don't need to match as it will always succeed.
+        if (term->invert() || term->characterClass != m_pattern.anyCharacterClass()) {
+            matchCharacterClass(character, matchDest, term->characterClass);
+
+            if (term->invert())
+                op.m_jumps.append(matchDest);
+            else {
+                op.m_jumps.append(jump());
+                matchDest.link(this);
+            }
         }
 
@@ -1264 +1271 @@
             JumpList matchDest;
             readCharacter(m_checkedOffset - term->inputPosition, character);
-            matchCharacterClass(character, matchDest, term->characterClass);
-            failures.append(jump());
+            // If we are matching the "any character" builtin class we only need to read the
+            // character and don't need to match as it will always succeed.
+            if (term->characterClass != m_pattern.anyCharacterClass()) {
+                matchCharacterClass(character, matchDest, term->characterClass);
+                failures.append(jump());
+            }
             matchDest.link(this);
         }
@@ -1366 +1377 @@
         JumpList matchDest;
         readCharacter(m_checkedOffset - term->inputPosition, character);
-        matchCharacterClass(character, matchDest, term->characterClass);
-
-        if (term->invert())
-            nonGreedyFailures.append(matchDest);
-        else {
-            nonGreedyFailures.append(jump());
-            matchDest.link(this);
+        // If we are matching the "any character" builtin class we only need to read the
+        // character and don't need to match as it will always succeed.
+        if (term->invert() || term->characterClass != m_pattern.anyCharacterClass()) {
+            matchCharacterClass(character, matchDest, term->characterClass);
+
+            if (term->invert())
+                nonGreedyFailures.append(matchDest);
+            else {
+                nonGreedyFailures.append(jump());
+                matchDest.link(this);
+            }
         }
 
@@ -1407 +1422 @@
         JumpList saveStartIndex;
         JumpList foundEndingNewLine;
+
+        if (m_pattern.dotAll()) {
+            move(TrustedImm32(0), matchPos);
+            setMatchStart(matchPos);
+            move(length, index);
+            return;
+        }
 
         ASSERT(!m_pattern.m_body->m_hasFixedSize);