Changeset 229514 in webkit for trunk/Source/JavaScriptCore/runtime/RegExpObject.cpp

Timestamp:

Mar 10, 2018, 11:20:29 PM (7 years ago)

Author:

Yusuke Suzuki

Message:

[FTL] Drop NewRegexp for String.prototype.match with RegExp + global flag
​https://bugs.webkit.org/show_bug.cgi?id=181848

Reviewed by Sam Weinig.

JSTests:

• microbenchmarks/regexp-u-global-es5.js: Added.

(fn):

• microbenchmarks/regexp-u-global-es6.js: Added.

(fn):

• stress/materialized-regexp-has-correct-last-index-set-by-match-at-osr-exit.js: Added.

(shouldBe):
(test):
(i.switch):

• stress/materialized-regexp-has-correct-last-index-set-by-match.js: Added.

(shouldBe):
(test):

Source/JavaScriptCore:

In r181535, we support string.match(/nonglobal/) code. However, string.match(/global/g) is not
optimized since it sets lastIndex value before performing RegExp operation.

This patch optimizes the above "with a global flag" case by emitting SetRegExpObjectLastIndex properly.
RegExpMatchFast is converted to SetRegExpObjectLastIndex and RegExpMatchFastGlobal. The latter node
just holds RegExp (not RegExpObject) cell so that it can offer a chance to make NewRegexp PhantomNewRegexp
in object allocation sinking phase.

Added microbenchmarks shows that this patch makes NewRegexp PhantomNewRegexp even if the given RegExp
has a global flag. And it improves the performance.

baseline patched

regexp-u-global-es5 44.1298+-4.6128 ^{33.7920+-2.0110} definitely 1.3059x faster
regexp-u-global-es6 182.3272+-2.2861 ^{154.3414+-7.6769} definitely 1.1813x faster

• dfg/DFGAbstractInterpreterInlines.h:

(JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):

• dfg/DFGClobberize.h:

(JSC::DFG::clobberize):

• dfg/DFGDoesGC.cpp:

(JSC::DFG::doesGC):

• dfg/DFGFixupPhase.cpp:

(JSC::DFG::FixupPhase::fixupNode):

• dfg/DFGMayExit.cpp:
• dfg/DFGNode.cpp:

(JSC::DFG::Node::convertToRegExpMatchFastGlobal):

• dfg/DFGNode.h:

(JSC::DFG::Node::hasHeapPrediction):
(JSC::DFG::Node::hasCellOperand):

• dfg/DFGNodeType.h:
• dfg/DFGOperations.cpp:
• dfg/DFGOperations.h:
• dfg/DFGPredictionPropagationPhase.cpp:
• dfg/DFGSafeToExecute.h:

(JSC::DFG::safeToExecute):

• dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::compileRegExpMatchFastGlobal):

• dfg/DFGSpeculativeJIT.h:
• dfg/DFGSpeculativeJIT32_64.cpp:

(JSC::DFG::SpeculativeJIT::compile):

• dfg/DFGSpeculativeJIT64.cpp:

(JSC::DFG::SpeculativeJIT::compile):

• dfg/DFGStrengthReductionPhase.cpp:

(JSC::DFG::StrengthReductionPhase::handleNode):

• ftl/FTLCapabilities.cpp:

(JSC::FTL::canCompile):

• ftl/FTLLowerDFGToB3.cpp:

(JSC::FTL::DFG::LowerDFGToB3::compileNode):
(JSC::FTL::DFG::LowerDFGToB3::compileRegExpMatchFastGlobal):

• runtime/RegExpObject.cpp:

(JSC::collectMatches): Deleted.

• runtime/RegExpObject.h:
• runtime/RegExpObjectInlines.h:

(JSC::RegExpObject::execInline):
(JSC::RegExpObject::matchInline):
(JSC::advanceStringUnicode):
(JSC::collectMatches):
(JSC::RegExpObject::advanceStringUnicode): Deleted.

• runtime/RegExpPrototype.cpp:

(JSC::advanceStringIndex):

File:

• trunk/Source/JavaScriptCore/runtime/RegExpObject.cpp (modified) (1 diff)

trunk/Source/JavaScriptCore/runtime/RegExpObject.cpp

@@ -178 +178 @@
 }
 
-template<typename FixEndFunc>
-JSValue collectMatches(VM& vm, ExecState* exec, JSString* string, const String& s, RegExpConstructor* constructor, RegExp* regExp, const FixEndFunc& fixEnd)
-{
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    MatchResult result = constructor->performMatch(vm, regExp, string, s, 0);
-    if (!result)
-        return jsNull();
-    
-    static unsigned maxSizeForDirectPath = 100000;
-    
-    JSArray* array = constructEmptyArray(exec, nullptr);
-    RETURN_IF_EXCEPTION(scope, { });
-
-    bool hasException = false;
-    auto iterate = [&] () {
-        size_t end = result.end;
-        size_t length = end - result.start;
-        array->push(exec, JSRopeString::createSubstringOfResolved(vm, string, result.start, length));
-        if (UNLIKELY(scope.exception())) {
-            hasException = true;
-            return;
-        }
-        if (!length)
-            end = fixEnd(end);
-        result = constructor->performMatch(vm, regExp, string, s, end);
-    };
-    
-    do {
-        if (array->length() >= maxSizeForDirectPath) {
-            // First do a throw-away match to see how many matches we'll get.
-            unsigned matchCount = 0;
-            MatchResult savedResult = result;
-            do {
-                if (array->length() + matchCount > MAX_STORAGE_VECTOR_LENGTH) {
-                    throwOutOfMemoryError(exec, scope);
-                    return jsUndefined();
-                }
-                
-                size_t end = result.end;
-                matchCount++;
-                if (result.empty())
-                    end = fixEnd(end);
-                
-                // Using RegExpConstructor::performMatch() instead of calling RegExp::match()
-                // directly is a surprising but profitable choice: it means that when we do OOM, we
-                // will leave the cached result in the state it ought to have had just before the
-                // OOM! On the other hand, if this loop concludes that the result is small enough,
-                // then the iterate() loop below will overwrite the cached result anyway.
-                result = constructor->performMatch(vm, regExp, string, s, end);
-            } while (result);
-            
-            // OK, we have a sensible number of matches. Now we can create them for reals.
-            result = savedResult;
-            do {
-                iterate();
-                EXCEPTION_ASSERT(!!scope.exception() == hasException);
-                if (UNLIKELY(hasException))
-                    return { };
-            } while (result);
-            
-            return array;
-        }
-        
-        iterate();
-    } while (result);
-    
-    return array;
-}
-
 JSValue RegExpObject::matchGlobal(ExecState* exec, JSGlobalObject* globalObject, JSString* string)
 {