Changeset 227725 in webkit for trunk/Source/JavaScriptCore/runtime/RegExp.cpp

Timestamp:

Jan 29, 2018, 2:43:13 AM (7 years ago)

Author:

Yusuke Suzuki

Message:

JSC Sampling Profiler: Detect tester and testee when sampling in RegExp JIT
​https://bugs.webkit.org/show_bug.cgi?id=152729

Reviewed by Saam Barati.

JSTests:

• stress/sampling-profiler-regexp.js: Added.

(platformSupportsSamplingProfiler.test):
(platformSupportsSamplingProfiler.baz):
(platformSupportsSamplingProfiler):

Source/JavaScriptCore:

This patch extends SamplingProfiler to recognize JIT RegExp execution. We record
executing RegExp in VM so that SamplingProfiler can detect it. This is better
than the previous VM::isExecutingInRegExpJIT flag approach since

1. isExecutingInRegExpJIT is set after starting executing JIT RegExp code. Thus,

if we suspend the thread just before executing this flag, or just after clearing
this flag, SamplingProfiler gets invalid frame, and frame validation fails. We
should set such a flag before and after executing JIT RegExp code.

2. This removes VM dependency from YarrJIT which is not essential one.

We add ExecutionContext enum to RegExp::matchInline not to mark execution if it
is done in non JS thread.

• bytecode/BytecodeDumper.cpp:

(JSC::regexpName):
(JSC::BytecodeDumper<Block>::dumpRegExps):
(JSC::regexpToSourceString): Deleted.

• heap/Heap.cpp:

(JSC::Heap::addCoreConstraints):

• runtime/RegExp.cpp:

(JSC::RegExp::compile):
(JSC::RegExp::match):
(JSC::RegExp::matchConcurrently):
(JSC::RegExp::compileMatchOnly):
(JSC::RegExp::toSourceString const):

• runtime/RegExp.h:
• runtime/RegExpInlines.h:

(JSC::RegExp::matchInline):

• runtime/RegExpMatchesArray.h:

(JSC::createRegExpMatchesArray):

• runtime/SamplingProfiler.cpp:

(JSC::SamplingProfiler::SamplingProfiler):
(JSC::SamplingProfiler::timerLoop):
(JSC::SamplingProfiler::takeSample):
(JSC::SamplingProfiler::processUnverifiedStackTraces):
(JSC::SamplingProfiler::StackFrame::nameFromCallee):
(JSC::SamplingProfiler::StackFrame::displayName):
(JSC::SamplingProfiler::StackFrame::displayNameForJSONTests):
(JSC::SamplingProfiler::StackFrame::functionStartLine):
(JSC::SamplingProfiler::StackFrame::functionStartColumn):
(JSC::SamplingProfiler::StackFrame::sourceID):
(JSC::SamplingProfiler::StackFrame::url):
(WTF::printInternal):
(JSC::SamplingProfiler::~SamplingProfiler): Deleted.

• runtime/SamplingProfiler.h:
• runtime/VM.h:
• yarr/YarrJIT.cpp:

(JSC::Yarr::YarrGenerator::generateEnter):
(JSC::Yarr::YarrGenerator::generateReturn):
(JSC::Yarr::YarrGenerator::YarrGenerator):
(JSC::Yarr::jitCompile):

• yarr/YarrJIT.h:

File:

• trunk/Source/JavaScriptCore/runtime/RegExp.cpp (modified) (7 diffs)

trunk/Source/JavaScriptCore/runtime/RegExp.cpp

@@ -308 +308 @@
 #if ENABLE(YARR_JIT)
     if (!pattern.m_containsBackreferences && !pattern.containsUnsignedLengthPattern() && VM::canUseRegExpJIT()) {
-        Yarr::jitCompile(pattern, charSize, vm, m_regExpJITCode);
+        Yarr::jitCompile(pattern, charSize, m_regExpJITCode);
         if (!m_regExpJITCode.failureReason()) {
             m_state = JITCode;
@@ -327 +327 @@
 int RegExp::match(VM& vm, const String& s, unsigned startOffset, Vector<int>& ovector)
 {
-    return matchInline(vm, s, startOffset, ovector);
+    return matchInline(vm, Concurrency::MainThread, s, startOffset, ovector);
 }
 
@@ -338 +338 @@
         return false;
 
-    position = match(vm, s, startOffset, ovector);
+    position = matchInline(vm, Concurrency::Concurrent, s, startOffset, ovector);
     return true;
 }
@@ -364 +364 @@
 #if ENABLE(YARR_JIT)
     if (!pattern.m_containsBackreferences && !pattern.containsUnsignedLengthPattern() && VM::canUseRegExpJIT()) {
-        Yarr::jitCompile(pattern, charSize, vm, m_regExpJITCode, Yarr::MatchOnly);
+        Yarr::jitCompile(pattern, charSize, m_regExpJITCode, Yarr::MatchOnly);
         if (!m_regExpJITCode.failureReason()) {
             m_state = JITCode;
@@ -383 +383 @@
 MatchResult RegExp::match(VM& vm, const String& s, unsigned startOffset)
 {
-    return matchInline(vm, s, startOffset);
+    return matchInline(vm, Concurrency::MainThread, s, startOffset);
 }
 
@@ -393 +393 @@
         return false;
 
-    result = match(vm, s, startOffset);
+    result = matchInline(vm, Concurrency::Concurrent, s, startOffset);
     return true;
 }
@@ -408 +408 @@
 #endif
     m_regExpBytecode = nullptr;
+}
+
+String RegExp::toSourceString() const
+{
+    char postfix[8] = { '/', 0, 0, 0, 0, 0, 0, 0 };
+    int index = 1;
+    if (global())
+        postfix[index++] = 'g';
+    if (ignoreCase())
+        postfix[index++] = 'i';
+    if (multiline())
+        postfix[index++] = 'm';
+    if (dotAll())
+        postfix[index++] = 's';
+    if (unicode())
+        postfix[index++] = 'u';
+    if (sticky())
+        postfix[index++] = 'y';
+
+    return makeString("/", pattern(), postfix);
 }