Ignore:
Timestamp:
Mar 28, 2012, 3:18:20 PM (13 years ago)
Author:
[email protected]
Message:

Yarr: if we're not using the output array, don't populate it!
​https://bugs.webkit.org/show_bug.cgi?id=82519

Reviewed by Sam Weinig.

../JavaScriptCore:

Add a new variant of the match method to RegExp that returns a MatchResult,
and modify YarrJIT to be able to compile code that doesn't use an output vector.

This is a 3% progression on v8-regexp.

  • JavaScriptCore.xcodeproj/project.pbxproj:
    • Moved MatchResult into its own header.
  • assembler/AbstractMacroAssembler.h:
    • Added missing include.
  • runtime/MatchResult.h: Added.

(MatchResult::MatchResult):
(MatchResult):
(MatchResult::failed):
(MatchResult::operator bool):
(MatchResult::empty):

  • Moved MatchResult into its own header.
  • runtime/RegExp.cpp:

(JSC::RegExp::compile):
(JSC::RegExp::compileIfNecessary):
(JSC::RegExp::match):

  • Changed due to execute & representation changes.

(JSC::RegExp::compileMatchOnly):
(JSC::RegExp::compileIfNecessaryMatchOnly):

  • Added helper to compile MatchOnly code.

(JSC::RegExp::invalidateCode):
(JSC::RegExp::matchCompareWithInterpreter):
(JSC::RegExp::printTraceData):

  • Changed due representation changes.
  • runtime/RegExp.h:

(RegExp):
(JSC::RegExp::hasCode):

  • Made YarrCodeBlock a member.
  • runtime/RegExpConstructor.h:

(RegExpConstructor):
(JSC::RegExpConstructor::performMatch):

  • Added no-ovector form.
  • runtime/RegExpMatchesArray.cpp:

(JSC::RegExpMatchesArray::reifyAllProperties):

  • Match now takes a reference to ovector, not a pointer.
  • runtime/RegExpObject.h:

(JSC):

  • Moved MatchResult into its own header.
  • runtime/StringPrototype.cpp:

(JSC::stringProtoFuncSplit):

  • Match now takes a reference to ovector, not a pointer.
  • testRegExp.cpp:

(testOneRegExp):

  • Match now takes a reference to ovector, not a pointer.
  • yarr/YarrJIT.cpp:

(Yarr):
(YarrGenerator):
(JSC::Yarr::YarrGenerator::initCallFrame):
(JSC::Yarr::YarrGenerator::removeCallFrame):
(JSC::Yarr::YarrGenerator::setSubpatternStart):
(JSC::Yarr::YarrGenerator::setSubpatternEnd):
(JSC::Yarr::YarrGenerator::clearSubpatternStart):
(JSC::Yarr::YarrGenerator::setMatchStart):
(JSC::Yarr::YarrGenerator::getMatchStart):

  • Added helper functions to intermediate access to output.

(JSC::Yarr::YarrGenerator::generateDotStarEnclosure):
(JSC::Yarr::YarrGenerator::generate):
(JSC::Yarr::YarrGenerator::backtrack):
(JSC::Yarr::YarrGenerator::generateEnter):
(JSC::Yarr::YarrGenerator::compile):

  • Changed to use the new helpers, only generate subpatterns if IncludeSubpatterns.

(JSC::Yarr::jitCompile):

  • Needs to template of MatchOnly or IncludeSubpatterns.
  • yarr/YarrJIT.h:

(YarrCodeBlock):
(JSC::Yarr::YarrCodeBlock::set8BitCode):
(JSC::Yarr::YarrCodeBlock::set16BitCode):
(JSC::Yarr::YarrCodeBlock::has8BitCodeMatchOnly):
(JSC::Yarr::YarrCodeBlock::has16BitCodeMatchOnly):
(JSC::Yarr::YarrCodeBlock::set8BitCodeMatchOnly):
(JSC::Yarr::YarrCodeBlock::set16BitCodeMatchOnly):
(JSC::Yarr::YarrCodeBlock::execute):
(JSC::Yarr::YarrCodeBlock::clear):

  • Added a second set of CodeRefs, so that we can compile RexExps with/without subpattern matching.

../WebCore:

  • ForwardingHeaders/runtime/MatchResult.h: Added.
  • ForwardingHeaders/yarr/YarrJIT.h: Added.
    • Added forwarding headers.
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/runtime/RegExp.cpp

    r111889 r112454  
    219219
    220220struct RegExpRepresentation {
    221 #if ENABLE(YARR_JIT)
    222     Yarr::YarrCodeBlock m_regExpJITCode;
    223 #endif
    224     OwnPtr<Yarr::BytecodePattern> m_regExpBytecode;
    225221};
    226222
    … …  
    280276    ASSERT(m_numSubpatterns == pattern.m_numSubpatterns);
    281277
    282     if (!m_representation) {
     278    if (!hasCode()) {
    283279        ASSERT(m_state == NotCompiled);
    284         m_representation = adoptPtr(new RegExpRepresentation);
    285280        globalData->regExpCache()->addToStrongCache(this);
    286281        m_state = ByteCode;
    … …  
    289284#if ENABLE(YARR_JIT)
    290285    if (!pattern.m_containsBackreferences && globalData->canUseJIT()) {
    291         Yarr::jitCompile(pattern, charSize, globalData, m_representation->m_regExpJITCode);
     286        Yarr::jitCompile(pattern, charSize, globalData, m_regExpJITCode);
    292287#if ENABLE(YARR_JIT_DEBUG)
    293         if (!m_representation->m_regExpJITCode.isFallBack())
     288        if (!m_regExpJITCode.isFallBack())
    294289            m_state = JITCode;
    295290        else
    296291            m_state = ByteCode;
    297292#else
    298         if (!m_representation->m_regExpJITCode.isFallBack()) {
     293        if (!m_regExpJITCode.isFallBack()) {
    299294            m_state = JITCode;
    300295            return;
    … …  
    306301#endif
    307302
    308     m_representation->m_regExpBytecode = Yarr::byteCompile(pattern, &globalData->m_regExpAllocator);
     303    m_regExpBytecode = Yarr::byteCompile(pattern, &globalData->m_regExpAllocator);
    309304}
    310305
    311306void RegExp::compileIfNecessary(JSGlobalData& globalData, Yarr::YarrCharSize charSize)
    312307{
    313     // If the state is NotCompiled or ParseError, then there is no representation.
    314     // If there is a representation, and the state must be either JITCode or ByteCode.
    315     ASSERT(!!m_representation == (m_state == JITCode || m_state == ByteCode));
    316    
    317     if (m_representation) {
     308    if (hasCode()) {
    318309#if ENABLE(YARR_JIT)
    319310        if (m_state != JITCode)
    320311            return;
    321         if ((charSize == Yarr::Char8) && (m_representation->m_regExpJITCode.has8BitCode()))
    322             return;
    323         if ((charSize == Yarr::Char16) && (m_representation->m_regExpJITCode.has16BitCode()))
     312        if ((charSize == Yarr::Char8) && (m_regExpJITCode.has8BitCode()))
     313            return;
     314        if ((charSize == Yarr::Char16) && (m_regExpJITCode.has16BitCode()))
    324315            return;
    325316#else
    … …  
    331322}
    332323
    333 int RegExp::match(JSGlobalData& globalData, const UString& s, unsigned startOffset, Vector<int, 32>* ovector)
     324int RegExp::match(JSGlobalData& globalData, const UString& s, unsigned startOffset, Vector<int, 32>& ovector)
    334325{
    335326#if ENABLE(REGEXP_TRACING)
    … …  
    341332
    342333    int offsetVectorSize = (m_numSubpatterns + 1) * 2;
    343     int* offsetVector;
    344     Vector<int, 32> nonReturnedOvector;
    345     if (ovector) {
    346         ovector->resize(offsetVectorSize);
    347         offsetVector = ovector->data();
    348     } else {
    349         nonReturnedOvector.resize(offsetVectorSize);
    350         offsetVector = nonReturnedOvector.data();
    351     }
    352     ASSERT(offsetVector);
     334    ovector.resize(offsetVectorSize);
     335    int* offsetVector = ovector.data();
    353336
    354337    int result;
    … …  
    356339    if (m_state == JITCode) {
    357340        if (s.is8Bit())
    358             result = Yarr::execute(m_representation->m_regExpJITCode, s.characters8(), startOffset, s.length(), offsetVector);
     341            result = m_regExpJITCode.execute(s.characters8(), startOffset, s.length(), offsetVector).start;
    359342        else
    360             result = Yarr::execute(m_representation->m_regExpJITCode, s.characters16(), startOffset, s.length(), offsetVector);
     343            result = m_regExpJITCode.execute(s.characters16(), startOffset, s.length(), offsetVector).start;
    361344#if ENABLE(YARR_JIT_DEBUG)
    362345        matchCompareWithInterpreter(s, startOffset, offsetVector, result);
    … …  
    364347    } else
    365348#endif
    366         result = Yarr::interpret(m_representation->m_regExpBytecode.get(), s, startOffset, s.length(), reinterpret_cast<unsigned*>(offsetVector));
     349        result = Yarr::interpret(m_regExpBytecode.get(), s, startOffset, s.length(), reinterpret_cast<unsigned*>(offsetVector));
    367350
    368351    // FIXME: The YARR engine should handle unsigned or size_t length matches.
    … …  
    405388}
    406389
     390void RegExp::compileMatchOnly(JSGlobalData* globalData, Yarr::YarrCharSize charSize)
     391{
     392    Yarr::YarrPattern pattern(m_patternString, ignoreCase(), multiline(), &m_constructionError);
     393    if (m_constructionError) {
     394        ASSERT_NOT_REACHED();
     395        m_state = ParseError;
     396        return;
     397    }
     398    ASSERT(m_numSubpatterns == pattern.m_numSubpatterns);
     399
     400    if (!hasCode()) {
     401        ASSERT(m_state == NotCompiled);
     402        globalData->regExpCache()->addToStrongCache(this);
     403        m_state = ByteCode;
     404    }
     405
     406#if ENABLE(YARR_JIT)
     407    if (!pattern.m_containsBackreferences && globalData->canUseJIT()) {
     408        Yarr::jitCompile(pattern, charSize, globalData, m_regExpJITCode, Yarr::MatchOnly);
     409#if ENABLE(YARR_JIT_DEBUG)
     410        if (!m_regExpJITCode.isFallBack())
     411            m_state = JITCode;
     412        else
     413            m_state = ByteCode;
     414#else
     415        if (!m_regExpJITCode.isFallBack()) {
     416            m_state = JITCode;
     417            return;
     418        }
     419#endif
     420    }
     421#else
     422    UNUSED_PARAM(charSize);
     423#endif
     424
     425    m_regExpBytecode = Yarr::byteCompile(pattern, &globalData->m_regExpAllocator);
     426}
     427
     428void RegExp::compileIfNecessaryMatchOnly(JSGlobalData& globalData, Yarr::YarrCharSize charSize)
     429{
     430    if (hasCode()) {
     431#if ENABLE(YARR_JIT)
     432        if (m_state != JITCode)
     433            return;
     434        if ((charSize == Yarr::Char8) && (m_regExpJITCode.has8BitCodeMatchOnly()))
     435            return;
     436        if ((charSize == Yarr::Char16) && (m_regExpJITCode.has16BitCodeMatchOnly()))
     437            return;
     438#else
     439        return;
     440#endif
     441    }
     442
     443    compileMatchOnly(&globalData, charSize);
     444}
     445
     446MatchResult RegExp::match(JSGlobalData& globalData, const UString& s, unsigned startOffset)
     447{
     448#if ENABLE(REGEXP_TRACING)
     449    m_rtMatchCallCount++;
     450#endif
     451
     452    ASSERT(m_state != ParseError);
     453    compileIfNecessaryMatchOnly(globalData, s.is8Bit() ? Yarr::Char8 : Yarr::Char16);
     454
     455#if ENABLE(YARR_JIT)
     456    if (m_state == JITCode) {
     457        MatchResult result = s.is8Bit() ?
     458            m_regExpJITCode.execute(s.characters8(), startOffset, s.length()) :
     459            m_regExpJITCode.execute(s.characters16(), startOffset, s.length());
     460#if ENABLE(REGEXP_TRACING)
     461        if (!result)
     462            m_rtMatchFoundCount++;
     463#endif
     464        return result;
     465    }
     466#endif
     467
     468    int offsetVectorSize = (m_numSubpatterns + 1) * 2;
     469    int* offsetVector;
     470    Vector<int, 32> nonReturnedOvector;
     471    nonReturnedOvector.resize(offsetVectorSize);
     472    offsetVector = nonReturnedOvector.data();
     473    int r = Yarr::interpret(m_regExpBytecode.get(), s, startOffset, s.length(), reinterpret_cast<unsigned*>(offsetVector));
     474#if REGEXP_FUNC_TEST_DATA_GEN
     475    RegExpFunctionalTestCollector::get()->outputOneTest(this, s, startOffset, offsetVector, result);
     476#endif
     477
     478    if (r >= 0) {
     479#if ENABLE(REGEXP_TRACING)
     480        m_rtMatchFoundCount++;
     481#endif
     482        return MatchResult(r, reinterpret_cast<unsigned*>(offsetVector)[1]);
     483    }
     484
     485    return MatchResult::failed();
     486}
     487
    407488void RegExp::invalidateCode()
    408489{
    409     if (!m_representation)
     490    if (!hasCode())
    410491        return;
    411492    m_state = NotCompiled;
    412     m_representation.clear();
     493    m_regExpJITCode.clear();
     494    m_regExpBytecode.clear();
    413495}
    414496
    … …  
    429511        interpreterOffsetVector[j] = -1;
    430512
    431     interpreterResult = Yarr::interpret(m_representation->m_regExpBytecode.get(), s, startOffset, s.length(), interpreterOffsetVector);
     513    interpreterResult = Yarr::interpret(m_regExpBytecode.get(), s, startOffset, s.length(), interpreterOffsetVector);
    432514
    433515    if (jitResult != interpreterResult)
    … …  
    478560
    479561#if ENABLE(YARR_JIT)
    480         Yarr::YarrCodeBlock& codeBlock = m_representation->m_regExpJITCode;
     562        Yarr::YarrCodeBlock& codeBlock = m_regExpJITCode;
    481563
    482564        const size_t jitAddrSize = 20;
Note: See TracChangeset for help on using the changeset viewer.