From fd09b7d9b54ccb4d737747ee7fba26f15f4901cd Mon Sep 17 00:00:00 2001 From: Simon Hausmann Date: Fri, 12 Apr 2013 12:58:29 +0200 Subject: WTF/JSC update to r148273 This brings in various bug fixes in the ARM and MIPS assemblers as well as a Yarr crash fix and performance fix. This change doesn't compile as-is, but the next change will apply the modifications necessary to compile. That'll make future updates easier as it allows for cherry-picking because the modifications are usually always the same. Change-Id: Iac32f62c71e8ff908deb41f28f12fbc98c0823e1 Reviewed-by: Lars Knoll --- src/3rdparty/masm/yarr/YarrCanonicalizeUCS2.h | 6 +-- src/3rdparty/masm/yarr/YarrInterpreter.cpp | 59 ++++++++++----------- src/3rdparty/masm/yarr/YarrInterpreter.h | 23 ++++---- src/3rdparty/masm/yarr/YarrJIT.cpp | 59 ++++++++++++++++----- src/3rdparty/masm/yarr/YarrParser.h | 4 +- src/3rdparty/masm/yarr/YarrPattern.cpp | 76 +++++++++++++++------------ src/3rdparty/masm/yarr/YarrPattern.h | 68 +++++++++--------------- 7 files changed, 153 insertions(+), 142 deletions(-) (limited to 'src/3rdparty/masm/yarr') diff --git a/src/3rdparty/masm/yarr/YarrCanonicalizeUCS2.h b/src/3rdparty/masm/yarr/YarrCanonicalizeUCS2.h index be0ead43d2..9dce78200c 100644 --- a/src/3rdparty/masm/yarr/YarrCanonicalizeUCS2.h +++ b/src/3rdparty/masm/yarr/YarrCanonicalizeUCS2.h @@ -93,9 +93,9 @@ inline UChar getCanonicalPair(UCS2CanonicalizationRange* info, UChar ch) case CanonicalizeAlternatingUnaligned: return ((ch - 1) ^ 1) + 1; default: - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); } - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); return 0; } @@ -129,7 +129,7 @@ inline bool areCanonicallyEquivalent(UChar a, UChar b) return ((a - 1) | 1) == ((b - 1) | 1); } - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); return false; } diff --git a/src/3rdparty/masm/yarr/YarrInterpreter.cpp b/src/3rdparty/masm/yarr/YarrInterpreter.cpp index 31603f6d34..f0312ea251 100644 --- a/src/3rdparty/masm/yarr/YarrInterpreter.cpp +++ b/src/3rdparty/masm/yarr/YarrInterpreter.cpp @@ -83,8 +83,8 @@ public: static inline void popParenthesesDisjunctionContext(BackTrackInfoParentheses* backTrack) { - ASSERT(backTrack->matchAmount); - ASSERT(backTrack->lastContext); + RELEASE_ASSERT(backTrack->matchAmount); + RELEASE_ASSERT(backTrack->lastContext); backTrack->lastContext = backTrack->lastContext->next; --backTrack->matchAmount; } @@ -111,8 +111,7 @@ public: { size_t size = sizeof(DisjunctionContext) - sizeof(uintptr_t) + disjunction->m_frameSize * sizeof(uintptr_t); allocatorPool = allocatorPool->ensureCapacity(size); - if (!allocatorPool) - CRASH(); + RELEASE_ASSERT(allocatorPool); return new (allocatorPool->alloc(size)) DisjunctionContext(); } @@ -161,8 +160,7 @@ public: { size_t size = sizeof(ParenthesesDisjunctionContext) - sizeof(unsigned) + (term.atom.parenthesesDisjunction->m_numSubpatterns << 1) * sizeof(unsigned) + sizeof(DisjunctionContext) - sizeof(uintptr_t) + disjunction->m_frameSize * sizeof(uintptr_t); allocatorPool = allocatorPool->ensureCapacity(size); - if (!allocatorPool) - CRASH(); + RELEASE_ASSERT(allocatorPool); return new (allocatorPool->alloc(size)) ParenthesesDisjunctionContext(output, term); } @@ -207,8 +205,7 @@ public: int readChecked(unsigned negativePositionOffest) { - if (pos < negativePositionOffest) - CRASH(); + RELEASE_ASSERT(pos >= negativePositionOffest); unsigned p = pos - negativePositionOffest; ASSERT(p < length); return input[p]; @@ -264,8 +261,7 @@ public: void uncheckInput(unsigned count) { - if (pos < count) - CRASH(); + RELEASE_ASSERT(pos >= count); pos -= count; } @@ -276,8 +272,7 @@ public: bool atEnd(unsigned negativePositionOffest) { - if (pos < negativePositionOffest) - CRASH(); + RELEASE_ASSERT(pos >= negativePositionOffest); return (pos - negativePositionOffest) == length; } @@ -485,7 +480,7 @@ public: return true; } - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); return false; } @@ -567,7 +562,7 @@ public: return true; } - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); return false; } @@ -801,7 +796,7 @@ public: { // 'Terminal' parentheses are at the end of the regex, and as such a match past end // should always be returned as a successful match - we should never backtrack to here. - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); return false; } @@ -927,7 +922,7 @@ public: return JSRegExpMatch; } - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); return JSRegExpErrorNoMatch; } @@ -1067,7 +1062,7 @@ public: } } - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); return JSRegExpErrorNoMatch; } @@ -1273,7 +1268,7 @@ public: } // We should never fall-through to here. - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); backtrack: ASSERT(context->term < static_cast(disjunction->terms.size())); @@ -1282,7 +1277,7 @@ public: case ByteTerm::TypeSubpatternBegin: return JSRegExpNoMatch; case ByteTerm::TypeSubpatternEnd: - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); case ByteTerm::TypeBodyAlternativeBegin: case ByteTerm::TypeBodyAlternativeDisjunction: { @@ -1304,7 +1299,7 @@ public: MATCH_NEXT(); } case ByteTerm::TypeBodyAlternativeEnd: - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); case ByteTerm::TypeAlternativeBegin: case ByteTerm::TypeAlternativeDisjunction: { @@ -1393,10 +1388,10 @@ public: BACKTRACK(); case ByteTerm::TypeDotStarEnclosure: - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); } - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); return JSRegExpErrorNoMatch; } @@ -1425,8 +1420,7 @@ public: output[i << 1] = offsetNoMatch; allocatorPool = pattern->m_allocator->startAllocator(); - if (!allocatorPool) - CRASH(); + RELEASE_ASSERT(allocatorPool); DisjunctionContext* context = allocDisjunctionContext(pattern->m_body.get()); @@ -1461,8 +1455,6 @@ private: unsigned remainingMatchCount; }; - - class ByteCompiler { struct ParenthesesStackEntry { unsigned beginTerm; @@ -1718,17 +1710,20 @@ public: unsigned subpatternId = parenthesesBegin.atom.subpatternId; unsigned numSubpatterns = lastSubpatternId - subpatternId + 1; - ByteDisjunction* parenthesesDisjunction = new ByteDisjunction(numSubpatterns, callFrameSize); + OwnPtr parenthesesDisjunction = adoptPtr(new ByteDisjunction(numSubpatterns, callFrameSize)); + + unsigned firstTermInParentheses = beginTerm + 1; + parenthesesDisjunction->terms.reserveInitialCapacity(endTerm - firstTermInParentheses + 2); parenthesesDisjunction->terms.append(ByteTerm::SubpatternBegin()); - for (unsigned termInParentheses = beginTerm + 1; termInParentheses < endTerm; ++termInParentheses) + for (unsigned termInParentheses = firstTermInParentheses; termInParentheses < endTerm; ++termInParentheses) parenthesesDisjunction->terms.append(m_bodyDisjunction->terms[termInParentheses]); parenthesesDisjunction->terms.append(ByteTerm::SubpatternEnd()); m_bodyDisjunction->terms.shrink(beginTerm); - m_allParenthesesInfo.append(parenthesesDisjunction); - m_bodyDisjunction->terms.append(ByteTerm(ByteTerm::TypeParenthesesSubpattern, subpatternId, parenthesesDisjunction, capture, inputPosition)); + m_bodyDisjunction->terms.append(ByteTerm(ByteTerm::TypeParenthesesSubpattern, subpatternId, parenthesesDisjunction.get(), capture, inputPosition)); + m_allParenthesesInfo.append(parenthesesDisjunction.release()); m_bodyDisjunction->terms[beginTerm].atom.quantityCount = quantityCount.unsafeGet(); m_bodyDisjunction->terms[beginTerm].atom.quantityType = quantityType; @@ -1815,7 +1810,7 @@ public: for (unsigned alt = 0; alt < disjunction->m_alternatives.size(); ++alt) { unsigned currentCountAlreadyChecked = inputCountAlreadyChecked; - PatternAlternative* alternative = disjunction->m_alternatives[alt]; + PatternAlternative* alternative = disjunction->m_alternatives[alt].get(); if (alt) { if (disjunction == m_pattern.m_body) @@ -1926,7 +1921,7 @@ private: OwnPtr m_bodyDisjunction; unsigned m_currentAlternativeIndex; Vector m_parenthesesStack; - Vector m_allParenthesesInfo; + Vector > m_allParenthesesInfo; }; PassOwnPtr byteCompile(YarrPattern& pattern, BumpPointerAllocator* allocator) diff --git a/src/3rdparty/masm/yarr/YarrInterpreter.h b/src/3rdparty/masm/yarr/YarrInterpreter.h index fb60bd979d..3b44acbd2b 100644 --- a/src/3rdparty/masm/yarr/YarrInterpreter.h +++ b/src/3rdparty/masm/yarr/YarrInterpreter.h @@ -337,27 +337,22 @@ public: struct BytecodePattern { WTF_MAKE_FAST_ALLOCATED; public: - BytecodePattern(PassOwnPtr body, Vector allParenthesesInfo, YarrPattern& pattern, BumpPointerAllocator* allocator) + BytecodePattern(PassOwnPtr body, Vector >& parenthesesInfoToAdopt, YarrPattern& pattern, BumpPointerAllocator* allocator) : m_body(body) , m_ignoreCase(pattern.m_ignoreCase) , m_multiline(pattern.m_multiline) , m_allocator(allocator) { + m_body->terms.shrinkToFit(); + newlineCharacterClass = pattern.newlineCharacterClass(); wordcharCharacterClass = pattern.wordcharCharacterClass(); - m_allParenthesesInfo.append(allParenthesesInfo); - m_userCharacterClasses.append(pattern.m_userCharacterClasses); - // 'Steal' the YarrPattern's CharacterClasses! We clear its - // array, so that it won't delete them on destruction. We'll - // take responsibility for that. - pattern.m_userCharacterClasses.clear(); - } + m_allParenthesesInfo.swap(parenthesesInfoToAdopt); + m_allParenthesesInfo.shrinkToFit(); - ~BytecodePattern() - { - deleteAllValues(m_allParenthesesInfo); - deleteAllValues(m_userCharacterClasses); + m_userCharacterClasses.swap(pattern.m_userCharacterClasses); + m_userCharacterClasses.shrinkToFit(); } OwnPtr m_body; @@ -371,8 +366,8 @@ public: CharacterClass* wordcharCharacterClass; private: - Vector m_allParenthesesInfo; - Vector m_userCharacterClasses; + Vector > m_allParenthesesInfo; + Vector > m_userCharacterClasses; }; JS_EXPORT_PRIVATE PassOwnPtr byteCompile(YarrPattern&, BumpPointerAllocator*); diff --git a/src/3rdparty/masm/yarr/YarrJIT.cpp b/src/3rdparty/masm/yarr/YarrJIT.cpp index ce84e2c74f..20b26c1eb9 100644 --- a/src/3rdparty/masm/yarr/YarrJIT.cpp +++ b/src/3rdparty/masm/yarr/YarrJIT.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 Apple Inc. All rights reserved. + * Copyright (C) 2009, 2013 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -87,10 +87,20 @@ class YarrGenerator : private MacroAssembler { static const RegisterID returnRegister = X86Registers::eax; static const RegisterID returnRegister2 = X86Registers::edx; #elif CPU(X86_64) +#if !OS(WINDOWS) static const RegisterID input = X86Registers::edi; static const RegisterID index = X86Registers::esi; static const RegisterID length = X86Registers::edx; static const RegisterID output = X86Registers::ecx; +#else + // If the return value doesn't fit in 64bits, its destination is pointed by rcx and the parameters are shifted. + // http://msdn.microsoft.com/en-us/library/7572ztz4.aspx + COMPILE_ASSERT(sizeof(MatchResult) > sizeof(void*), MatchResult_does_not_fit_in_64bits); + static const RegisterID input = X86Registers::edx; + static const RegisterID index = X86Registers::r8; + static const RegisterID length = X86Registers::r9; + static const RegisterID output = X86Registers::r10; +#endif static const RegisterID regT0 = X86Registers::eax; static const RegisterID regT1 = X86Registers::ebx; @@ -169,8 +179,8 @@ class YarrGenerator : private MacroAssembler { void matchCharacterClass(RegisterID character, JumpList& matchDest, const CharacterClass* charClass) { if (charClass->m_table) { - ExtendedAddress tableEntry(character, reinterpret_cast(charClass->m_table->m_table)); - matchDest.append(branchTest8(charClass->m_table->m_inverted ? Zero : NonZero, tableEntry)); + ExtendedAddress tableEntry(character, reinterpret_cast(charClass->m_table)); + matchDest.append(branchTest8(charClass->m_tableInverted ? Zero : NonZero, tableEntry)); return; } Jump unicodeFail; @@ -746,7 +756,11 @@ class YarrGenerator : private MacroAssembler { const RegisterID character = regT0; int maxCharactersAtOnce = m_charSize == Char8 ? 4 : 2; unsigned ignoreCaseMask = 0; +#if CPU(BIG_ENDIAN) + int allCharacters = ch << (m_charSize == Char8 ? 24 : 16); +#else int allCharacters = ch; +#endif int numberCharacters; int startTermPosition = term->inputPosition; @@ -755,7 +769,11 @@ class YarrGenerator : private MacroAssembler { ASSERT(!m_pattern.m_ignoreCase || isASCIIAlpha(ch) || isCanonicallyUnique(ch)); if (m_pattern.m_ignoreCase && isASCIIAlpha(ch)) +#if CPU(BIG_ENDIAN) + ignoreCaseMask |= 32 << (m_charSize == Char8 ? 24 : 16); +#else ignoreCaseMask |= 32; +#endif for (numberCharacters = 1; numberCharacters < maxCharactersAtOnce && nextOp->m_op == OpTerm; ++numberCharacters, nextOp = &m_ops[opIndex + numberCharacters]) { PatternTerm* nextTerm = nextOp->m_term; @@ -768,7 +786,11 @@ class YarrGenerator : private MacroAssembler { nextOp->m_isDeadCode = true; +#if CPU(BIG_ENDIAN) + int shiftAmount = (m_charSize == Char8 ? 24 : 16) - ((m_charSize == Char8 ? 8 : 16) * numberCharacters); +#else int shiftAmount = (m_charSize == Char8 ? 8 : 16) * numberCharacters; +#endif UChar currentCharacter = nextTerm->patternCharacter; @@ -1243,7 +1265,7 @@ class YarrGenerator : private MacroAssembler { case PatternTerm::TypeParenthesesSubpattern: case PatternTerm::TypeParentheticalAssertion: - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); case PatternTerm::TypeBackReference: m_shouldFallBack = true; break; @@ -1309,7 +1331,7 @@ class YarrGenerator : private MacroAssembler { case PatternTerm::TypeParenthesesSubpattern: case PatternTerm::TypeParentheticalAssertion: - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); case PatternTerm::TypeDotStarEnclosure: backtrackDotStarEnclosure(opIndex); @@ -2303,11 +2325,11 @@ class YarrGenerator : private MacroAssembler { m_ops.append(alternativeBeginOpCode); m_ops.last().m_previousOp = notFound; m_ops.last().m_term = term; - Vector& alternatives = term->parentheses.disjunction->m_alternatives; + Vector >& alternatives = term->parentheses.disjunction->m_alternatives; for (unsigned i = 0; i < alternatives.size(); ++i) { size_t lastOpIndex = m_ops.size() - 1; - PatternAlternative* nestedAlternative = alternatives[i]; + PatternAlternative* nestedAlternative = alternatives[i].get(); opCompileAlternative(nestedAlternative); size_t thisOpIndex = m_ops.size(); @@ -2354,11 +2376,11 @@ class YarrGenerator : private MacroAssembler { m_ops.append(OpSimpleNestedAlternativeBegin); m_ops.last().m_previousOp = notFound; m_ops.last().m_term = term; - Vector& alternatives = term->parentheses.disjunction->m_alternatives; + Vector >& alternatives = term->parentheses.disjunction->m_alternatives; for (unsigned i = 0; i < alternatives.size(); ++i) { size_t lastOpIndex = m_ops.size() - 1; - PatternAlternative* nestedAlternative = alternatives[i]; + PatternAlternative* nestedAlternative = alternatives[i].get(); opCompileAlternative(nestedAlternative); size_t thisOpIndex = m_ops.size(); @@ -2428,7 +2450,7 @@ class YarrGenerator : private MacroAssembler { // to return the failing result. void opCompileBody(PatternDisjunction* disjunction) { - Vector& alternatives = disjunction->m_alternatives; + Vector >& alternatives = disjunction->m_alternatives; size_t currentAlternativeIndex = 0; // Emit the 'once through' alternatives. @@ -2438,7 +2460,7 @@ class YarrGenerator : private MacroAssembler { do { size_t lastOpIndex = m_ops.size() - 1; - PatternAlternative* alternative = alternatives[currentAlternativeIndex]; + PatternAlternative* alternative = alternatives[currentAlternativeIndex].get(); opCompileAlternative(alternative); size_t thisOpIndex = m_ops.size(); @@ -2473,7 +2495,7 @@ class YarrGenerator : private MacroAssembler { m_ops.last().m_previousOp = notFound; do { size_t lastOpIndex = m_ops.size() - 1; - PatternAlternative* alternative = alternatives[currentAlternativeIndex]; + PatternAlternative* alternative = alternatives[currentAlternativeIndex].get(); ASSERT(!alternative->onceThrough()); opCompileAlternative(alternative); @@ -2502,6 +2524,13 @@ class YarrGenerator : private MacroAssembler { push(X86Registers::ebp); move(stackPointerRegister, X86Registers::ebp); push(X86Registers::ebx); + // The ABI doesn't guarantee the upper bits are zero on unsigned arguments, so clear them ourselves. + zeroExtend32ToPtr(index, index); + zeroExtend32ToPtr(length, length); +#if OS(WINDOWS) + if (compileMode == IncludeSubpatterns) + loadPtr(Address(X86Registers::ebp, 6 * sizeof(void*)), output); +#endif #elif CPU(X86) push(X86Registers::ebp); move(stackPointerRegister, X86Registers::ebp); @@ -2540,6 +2569,12 @@ class YarrGenerator : private MacroAssembler { void generateReturn() { #if CPU(X86_64) +#if OS(WINDOWS) + // Store the return value in the allocated space pointed by rcx. + store64(returnRegister, Address(X86Registers::ecx)); + store64(returnRegister2, Address(X86Registers::ecx, sizeof(void*))); + move(X86Registers::ecx, returnRegister); +#endif pop(X86Registers::ebx); pop(X86Registers::ebp); #elif CPU(X86) diff --git a/src/3rdparty/masm/yarr/YarrParser.h b/src/3rdparty/masm/yarr/YarrParser.h index 4bab1a0903..8c5d71b5fe 100644 --- a/src/3rdparty/masm/yarr/YarrParser.h +++ b/src/3rdparty/masm/yarr/YarrParser.h @@ -212,8 +212,8 @@ private: // parseEscape() should never call these delegate methods when // invoked with inCharacterClass set. - NO_RETURN_DUE_TO_ASSERT void assertionWordBoundary(bool) { ASSERT_NOT_REACHED(); } - NO_RETURN_DUE_TO_ASSERT void atomBackReference(unsigned) { ASSERT_NOT_REACHED(); } + NO_RETURN_DUE_TO_ASSERT void assertionWordBoundary(bool) { RELEASE_ASSERT_NOT_REACHED(); } + NO_RETURN_DUE_TO_ASSERT void atomBackReference(unsigned) { RELEASE_ASSERT_NOT_REACHED(); } private: Delegate& m_delegate; diff --git a/src/3rdparty/masm/yarr/YarrPattern.cpp b/src/3rdparty/masm/yarr/YarrPattern.cpp index c953a38d2f..3ce0216e5f 100644 --- a/src/3rdparty/masm/yarr/YarrPattern.cpp +++ b/src/3rdparty/masm/yarr/YarrPattern.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 Apple Inc. All rights reserved. + * Copyright (C) 2009, 2013 Apple Inc. All rights reserved. * Copyright (C) 2010 Peter Varga (pvarga@inf.u-szeged.hu), University of Szeged * * Redistribution and use in source and binary forms, with or without @@ -175,16 +175,16 @@ public: } - CharacterClass* charClass() + PassOwnPtr charClass() { - CharacterClass* characterClass = new CharacterClass(0); + OwnPtr characterClass = adoptPtr(new CharacterClass); characterClass->m_matches.swap(m_matches); characterClass->m_ranges.swap(m_ranges); characterClass->m_matchesUnicode.swap(m_matchesUnicode); characterClass->m_rangesUnicode.swap(m_rangesUnicode); - return characterClass; + return characterClass.release(); } private: @@ -274,9 +274,10 @@ public: , m_characterClassConstructor(pattern.m_ignoreCase) , m_invertParentheticalAssertion(false) { - m_pattern.m_body = new PatternDisjunction(); - m_alternative = m_pattern.m_body->addNewAlternative(); - m_pattern.m_disjunctions.append(m_pattern.m_body); + OwnPtr body = adoptPtr(new PatternDisjunction); + m_pattern.m_body = body.get(); + m_alternative = body->addNewAlternative(); + m_pattern.m_disjunctions.append(body.release()); } ~YarrPatternConstructor() @@ -288,9 +289,10 @@ public: m_pattern.reset(); m_characterClassConstructor.reset(); - m_pattern.m_body = new PatternDisjunction(); - m_alternative = m_pattern.m_body->addNewAlternative(); - m_pattern.m_disjunctions.append(m_pattern.m_body); + OwnPtr body = adoptPtr(new PatternDisjunction); + m_pattern.m_body = body.get(); + m_alternative = body->addNewAlternative(); + m_pattern.m_disjunctions.append(body.release()); } void assertionBOL() @@ -327,9 +329,9 @@ public: } m_characterClassConstructor.putUnicodeIgnoreCase(ch, info); - CharacterClass* newCharacterClass = m_characterClassConstructor.charClass(); - m_pattern.m_userCharacterClasses.append(newCharacterClass); - m_alternative->m_terms.append(PatternTerm(newCharacterClass, false)); + OwnPtr newCharacterClass = m_characterClassConstructor.charClass(); + m_alternative->m_terms.append(PatternTerm(newCharacterClass.get(), false)); + m_pattern.m_userCharacterClasses.append(newCharacterClass.release()); } void atomBuiltInCharacterClass(BuiltInCharacterClassID classID, bool invert) @@ -383,15 +385,15 @@ public: break; default: - ASSERT_NOT_REACHED(); + RELEASE_ASSERT_NOT_REACHED(); } } void atomCharacterClassEnd() { - CharacterClass* newCharacterClass = m_characterClassConstructor.charClass(); - m_pattern.m_userCharacterClasses.append(newCharacterClass); - m_alternative->m_terms.append(PatternTerm(newCharacterClass, m_invertCharacterClass)); + OwnPtr newCharacterClass = m_characterClassConstructor.charClass(); + m_alternative->m_terms.append(PatternTerm(newCharacterClass.get(), m_invertCharacterClass)); + m_pattern.m_userCharacterClasses.append(newCharacterClass.release()); } void atomParenthesesSubpatternBegin(bool capture = true) @@ -400,19 +402,19 @@ public: if (capture) m_pattern.m_numSubpatterns++; - PatternDisjunction* parenthesesDisjunction = new PatternDisjunction(m_alternative); - m_pattern.m_disjunctions.append(parenthesesDisjunction); - m_alternative->m_terms.append(PatternTerm(PatternTerm::TypeParenthesesSubpattern, subpatternId, parenthesesDisjunction, capture, false)); + OwnPtr parenthesesDisjunction = adoptPtr(new PatternDisjunction(m_alternative)); + m_alternative->m_terms.append(PatternTerm(PatternTerm::TypeParenthesesSubpattern, subpatternId, parenthesesDisjunction.get(), capture, false)); m_alternative = parenthesesDisjunction->addNewAlternative(); + m_pattern.m_disjunctions.append(parenthesesDisjunction.release()); } void atomParentheticalAssertionBegin(bool invert = false) { - PatternDisjunction* parenthesesDisjunction = new PatternDisjunction(m_alternative); - m_pattern.m_disjunctions.append(parenthesesDisjunction); - m_alternative->m_terms.append(PatternTerm(PatternTerm::TypeParentheticalAssertion, m_pattern.m_numSubpatterns + 1, parenthesesDisjunction, false, invert)); + OwnPtr parenthesesDisjunction = adoptPtr(new PatternDisjunction(m_alternative)); + m_alternative->m_terms.append(PatternTerm(PatternTerm::TypeParentheticalAssertion, m_pattern.m_numSubpatterns + 1, parenthesesDisjunction.get(), false, invert)); m_alternative = parenthesesDisjunction->addNewAlternative(); m_invertParentheticalAssertion = invert; + m_pattern.m_disjunctions.append(parenthesesDisjunction.release()); } void atomParenthesesEnd() @@ -477,23 +479,27 @@ public: // skip alternatives with m_startsWithBOL set true. PatternDisjunction* copyDisjunction(PatternDisjunction* disjunction, bool filterStartsWithBOL = false) { - PatternDisjunction* newDisjunction = 0; + OwnPtr newDisjunction; for (unsigned alt = 0; alt < disjunction->m_alternatives.size(); ++alt) { - PatternAlternative* alternative = disjunction->m_alternatives[alt]; + PatternAlternative* alternative = disjunction->m_alternatives[alt].get(); if (!filterStartsWithBOL || !alternative->m_startsWithBOL) { if (!newDisjunction) { - newDisjunction = new PatternDisjunction(); + newDisjunction = adoptPtr(new PatternDisjunction()); newDisjunction->m_parent = disjunction->m_parent; } PatternAlternative* newAlternative = newDisjunction->addNewAlternative(); + newAlternative->m_terms.reserveInitialCapacity(alternative->m_terms.size()); for (unsigned i = 0; i < alternative->m_terms.size(); ++i) newAlternative->m_terms.append(copyTerm(alternative->m_terms[i], filterStartsWithBOL)); } } - if (newDisjunction) - m_pattern.m_disjunctions.append(newDisjunction); - return newDisjunction; + if (!newDisjunction) + return 0; + + PatternDisjunction* copiedDisjunction = newDisjunction.get(); + m_pattern.m_disjunctions.append(newDisjunction.release()); + return copiedDisjunction; } PatternTerm copyTerm(PatternTerm& term, bool filterStartsWithBOL = false) @@ -655,7 +661,7 @@ public: bool hasFixedSize = true; for (unsigned alt = 0; alt < disjunction->m_alternatives.size(); ++alt) { - PatternAlternative* alternative = disjunction->m_alternatives[alt]; + PatternAlternative* alternative = disjunction->m_alternatives[alt].get(); unsigned currentAlternativeCallFrameSize = setupAlternativeOffsets(alternative, initialCallFrameSize, initialInputPosition); minimumInputSize = std::min(minimumInputSize, alternative->m_minimumSize); maximumCallFrameSize = std::max(maximumCallFrameSize, currentAlternativeCallFrameSize); @@ -690,7 +696,7 @@ public: if (m_pattern.m_numSubpatterns) return; - Vector& alternatives = m_pattern.m_body->m_alternatives; + Vector >& alternatives = m_pattern.m_body->m_alternatives; for (size_t i = 0; i < alternatives.size(); ++i) { Vector& terms = alternatives[i]->m_terms; if (terms.size()) { @@ -725,7 +731,7 @@ public: if (loopDisjunction) { // Move alternatives from loopDisjunction to disjunction for (unsigned alt = 0; alt < loopDisjunction->m_alternatives.size(); ++alt) - disjunction->m_alternatives.append(loopDisjunction->m_alternatives[alt]); + disjunction->m_alternatives.append(loopDisjunction->m_alternatives[alt].release()); loopDisjunction->m_alternatives.clear(); } @@ -744,7 +750,7 @@ public: if (term.type == PatternTerm::TypeParenthesesSubpattern) { PatternDisjunction* nestedDisjunction = term.parentheses.disjunction; for (unsigned alt = 0; alt < nestedDisjunction->m_alternatives.size(); ++alt) { - if (containsCapturingTerms(nestedDisjunction->m_alternatives[alt], 0, nestedDisjunction->m_alternatives[alt]->m_terms.size() - 1)) + if (containsCapturingTerms(nestedDisjunction->m_alternatives[alt].get(), 0, nestedDisjunction->m_alternatives[alt]->m_terms.size() - 1)) return true; } } @@ -760,11 +766,11 @@ public: // beginning and the end of the match. void optimizeDotStarWrappedExpressions() { - Vector& alternatives = m_pattern.m_body->m_alternatives; + Vector >& alternatives = m_pattern.m_body->m_alternatives; if (alternatives.size() != 1) return; - PatternAlternative* alternative = alternatives[0]; + PatternAlternative* alternative = alternatives[0].get(); Vector& terms = alternative->m_terms; if (terms.size() >= 3) { bool startsWithBOL = false; diff --git a/src/3rdparty/masm/yarr/YarrPattern.h b/src/3rdparty/masm/yarr/YarrPattern.h index 14e89b8e09..e7d187c2b3 100644 --- a/src/3rdparty/masm/yarr/YarrPattern.h +++ b/src/3rdparty/masm/yarr/YarrPattern.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009 Apple Inc. All rights reserved. + * Copyright (C) 2009, 2013 Apple Inc. All rights reserved. * Copyright (C) 2010 Peter Varga (pvarga@inf.u-szeged.hu), University of Szeged * * Redistribution and use in source and binary forms, with or without @@ -28,6 +28,8 @@ #define YarrPattern_h #include +#include +#include #include #include #include @@ -48,37 +50,28 @@ struct CharacterRange { } }; -struct CharacterClassTable : RefCounted { - const char* m_table; - bool m_inverted; - static PassRefPtr create(const char* table, bool inverted) - { - return adoptRef(new CharacterClassTable(table, inverted)); - } - -private: - CharacterClassTable(const char* table, bool inverted) - : m_table(table) - , m_inverted(inverted) - { - } -}; - struct CharacterClass { WTF_MAKE_FAST_ALLOCATED; public: // All CharacterClass instances have to have the full set of matches and ranges, - // they may have an optional table for faster lookups (which must match the + // they may have an optional m_table for faster lookups (which must match the // specified matches and ranges) - CharacterClass(PassRefPtr table) + CharacterClass() + : m_table(0) + { + } + CharacterClass(const char* table, bool inverted) : m_table(table) + , m_tableInverted(inverted) { } Vector m_matches; Vector m_ranges; Vector m_matchesUnicode; Vector m_rangesUnicode; - RefPtr m_table; + + const char* m_table; + bool m_tableInverted; }; enum QuantifierType { @@ -275,19 +268,14 @@ public: { } - ~PatternDisjunction() - { - deleteAllValues(m_alternatives); - } - PatternAlternative* addNewAlternative() { PatternAlternative* alternative = new PatternAlternative(this); - m_alternatives.append(alternative); + m_alternatives.append(adoptPtr(alternative)); return alternative; } - Vector m_alternatives; + Vector > m_alternatives; PatternAlternative* m_parent; unsigned m_minimumSize; unsigned m_callFrameSize; @@ -318,12 +306,6 @@ struct TermChain { struct YarrPattern { JS_EXPORT_PRIVATE YarrPattern(const String& pattern, bool ignoreCase, bool multiline, const char** error); - ~YarrPattern() - { - deleteAllValues(m_disjunctions); - deleteAllValues(m_userCharacterClasses); - } - void reset() { m_numSubpatterns = 0; @@ -340,9 +322,7 @@ struct YarrPattern { nonspacesCached = 0; nonwordcharCached = 0; - deleteAllValues(m_disjunctions); m_disjunctions.clear(); - deleteAllValues(m_userCharacterClasses); m_userCharacterClasses.clear(); } @@ -354,43 +334,43 @@ struct YarrPattern { CharacterClass* newlineCharacterClass() { if (!newlineCached) - m_userCharacterClasses.append(newlineCached = newlineCreate()); + m_userCharacterClasses.append(adoptPtr(newlineCached = newlineCreate())); return newlineCached; } CharacterClass* digitsCharacterClass() { if (!digitsCached) - m_userCharacterClasses.append(digitsCached = digitsCreate()); + m_userCharacterClasses.append(adoptPtr(digitsCached = digitsCreate())); return digitsCached; } CharacterClass* spacesCharacterClass() { if (!spacesCached) - m_userCharacterClasses.append(spacesCached = spacesCreate()); + m_userCharacterClasses.append(adoptPtr(spacesCached = spacesCreate())); return spacesCached; } CharacterClass* wordcharCharacterClass() { if (!wordcharCached) - m_userCharacterClasses.append(wordcharCached = wordcharCreate()); + m_userCharacterClasses.append(adoptPtr(wordcharCached = wordcharCreate())); return wordcharCached; } CharacterClass* nondigitsCharacterClass() { if (!nondigitsCached) - m_userCharacterClasses.append(nondigitsCached = nondigitsCreate()); + m_userCharacterClasses.append(adoptPtr(nondigitsCached = nondigitsCreate())); return nondigitsCached; } CharacterClass* nonspacesCharacterClass() { if (!nonspacesCached) - m_userCharacterClasses.append(nonspacesCached = nonspacesCreate()); + m_userCharacterClasses.append(adoptPtr(nonspacesCached = nonspacesCreate())); return nonspacesCached; } CharacterClass* nonwordcharCharacterClass() { if (!nonwordcharCached) - m_userCharacterClasses.append(nonwordcharCached = nonwordcharCreate()); + m_userCharacterClasses.append(adoptPtr(nonwordcharCached = nonwordcharCreate())); return nonwordcharCached; } @@ -401,8 +381,8 @@ struct YarrPattern { unsigned m_numSubpatterns; unsigned m_maxBackReference; PatternDisjunction* m_body; - Vector m_disjunctions; - Vector m_userCharacterClasses; + Vector, 4> m_disjunctions; + Vector > m_userCharacterClasses; private: const char* compile(const String& patternString); -- cgit v1.2.3