: m_vm(vm)

{

if (matchFrom == MatchFrom::VMThread)

m_stackLimit = vm.softStackLimit();

else {

StackBounds stack = Thread::current().stack();

m_stackLimit = stack.recursionLimit(Options::reservedZoneSize());

}

#if ENABLE(YARR_JIT_ALL_PARENS_EXPRESSIONS)

if (yarrCodeBlock->usesPatternContextBuffer()) {

m_patternContextBuffer = m_vm.acquireRegExpPatternContexBuffer();

m_patternContextBufferSize = VM::patternContextBufferSize;

}

#else

UNUSED_PARAM(yarrCodeBlock);

#endif

#if CPU(ARM_THUMB2)

static const RegisterID input = ARMRegisters::r0;

static const RegisterID index = ARMRegisters::r1;

static const RegisterID length = ARMRegisters::r2;

static const RegisterID output = ARMRegisters::r3;

static const RegisterID regT0 = ARMRegisters::r4;

static const RegisterID regT1 = ARMRegisters::r5;

static const RegisterID initialStart = ARMRegisters::r8;

static const RegisterID returnRegister = ARMRegisters::r0;

static const RegisterID returnRegister2 = ARMRegisters::r1;

#elif CPU(ARM64)

// Argument registers

static const RegisterID input = ARM64Registers::x0;

static const RegisterID index = ARM64Registers::x1;

static const RegisterID length = ARM64Registers::x2;

static const RegisterID output = ARM64Registers::x3;

static const RegisterID matchingContext = ARM64Registers::x4;

static const RegisterID freelistRegister = ARM64Registers::x4; // Loaded from the MatchingContextHolder in the prologue.

static const RegisterID freelistSizeRegister = ARM64Registers::x5; // Only used during initialization.

// Scratch registers

static const RegisterID regT0 = ARM64Registers::x6;

static const RegisterID regT1 = ARM64Registers::x7;

static const RegisterID regT2 = ARM64Registers::x8;

static const RegisterID remainingMatchCount = ARM64Registers::x9;

static const RegisterID regUnicodeInputAndTrail = ARM64Registers::x10;

static const RegisterID unicodeTemp = ARM64Registers::x5;

static const RegisterID initialStart = ARM64Registers::x11;

static const RegisterID supplementaryPlanesBase = ARM64Registers::x12;

static const RegisterID leadingSurrogateTag = ARM64Registers::x13;

static const RegisterID trailingSurrogateTag = ARM64Registers::x14;

static const RegisterID endOfStringAddress = ARM64Registers::x15;

static const RegisterID returnRegister = ARM64Registers::x0;

static const RegisterID returnRegister2 = ARM64Registers::x1;

const TrustedImm32 surrogateTagMask = TrustedImm32(0xfffffc00);

#define JIT_UNICODE_EXPRESSIONS

#elif CPU(MIPS)

static const RegisterID input = MIPSRegisters::a0;

static const RegisterID index = MIPSRegisters::a1;

static const RegisterID length = MIPSRegisters::a2;

static const RegisterID output = MIPSRegisters::a3;

static const RegisterID regT0 = MIPSRegisters::t4;

static const RegisterID regT1 = MIPSRegisters::t5;

static const RegisterID initialStart = MIPSRegisters::t6;

static const RegisterID returnRegister = MIPSRegisters::v0;

static const RegisterID returnRegister2 = MIPSRegisters::v1;

#elif CPU(X86_64)

#if !OS(WINDOWS)

// Argument registers

static const RegisterID input = X86Registers::edi;

static const RegisterID index = X86Registers::esi;

static const RegisterID length = X86Registers::edx;

static const RegisterID output = X86Registers::ecx;

static const RegisterID matchingContext = X86Registers::r8;

static const RegisterID freelistRegister = X86Registers::r8; // Loaded from the MatchingContextHolder in the prologue.

static const RegisterID freelistSizeRegister = X86Registers::r9; // Only used during initialization.

#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

// Scratch registers

static const RegisterID regT0 = X86Registers::eax;

#if !OS(WINDOWS)

static const RegisterID regT1 = X86Registers::r9;

static const RegisterID regT2 = X86Registers::r10;

#else

static const RegisterID regT1 = X86Registers::ecx;

static const RegisterID regT2 = X86Registers::edi;

#endif

static const RegisterID initialStart = X86Registers::ebx;

#if !OS(WINDOWS)

static const RegisterID remainingMatchCount = X86Registers::r12;

#else

static const RegisterID remainingMatchCount = X86Registers::esi;

#endif

static const RegisterID regUnicodeInputAndTrail = X86Registers::r13;

static const RegisterID unicodeTemp = X86Registers::r14;

static const RegisterID endOfStringAddress = X86Registers::r15;

static const RegisterID returnRegister = X86Registers::eax;

static const RegisterID returnRegister2 = X86Registers::edx;

const TrustedImm32 supplementaryPlanesBase = TrustedImm32(0x10000);

const TrustedImm32 leadingSurrogateTag = TrustedImm32(0xd800);

const TrustedImm32 trailingSurrogateTag = TrustedImm32(0xdc00);

const TrustedImm32 surrogateTagMask = TrustedImm32(0xfffffc00);

#define JIT_UNICODE_EXPRESSIONS

#endif

#if ENABLE(YARR_JIT_ALL_PARENS_EXPRESSIONS)

struct ParenContextSizes {

size_t m_numSubpatterns;

size_t m_frameSlots;

ParenContextSizes(size_t numSubpatterns, size_t frameSlots)

: m_numSubpatterns(numSubpatterns)

, m_frameSlots(frameSlots)

{

}

size_t numSubpatterns() { return m_numSubpatterns; }

size_t frameSlots() { return m_frameSlots; }

};

struct ParenContext {

struct ParenContext* next;

uint32_t begin;

uint32_t matchAmount;

uintptr_t returnAddress;

struct Subpatterns {

unsigned start;

unsigned end;

} subpatterns[0];

uintptr_t frameSlots[0];

static size_t sizeFor(ParenContextSizes& parenContextSizes)

{

return sizeof(ParenContext) + sizeof(Subpatterns) * parenContextSizes.numSubpatterns() + sizeof(uintptr_t) * parenContextSizes.frameSlots();

}

static ptrdiff_t nextOffset()

{

return offsetof(ParenContext, next);

}

static ptrdiff_t beginOffset()

{

return offsetof(ParenContext, begin);

}

static ptrdiff_t matchAmountOffset()

{

return offsetof(ParenContext, matchAmount);

}

static ptrdiff_t returnAddressOffset()

{

return offsetof(ParenContext, returnAddress);

}

static ptrdiff_t subpatternOffset(size_t subpattern)

{

return offsetof(ParenContext, subpatterns) + (subpattern - 1) * sizeof(Subpatterns);

}

static ptrdiff_t savedFrameOffset(ParenContextSizes& parenContextSizes)

{

return offsetof(ParenContext, subpatterns) + (parenContextSizes.numSubpatterns()) * sizeof(Subpatterns);

}

};

void initParenContextFreeList()

{

RegisterID parenContextPointer = regT0;

RegisterID nextParenContextPointer = regT2;

size_t parenContextSize = ParenContext::sizeFor(m_parenContextSizes);

parenContextSize = WTF::roundUpToMultipleOf<sizeof(uintptr_t)>(parenContextSize);

if (parenContextSize > VM::patternContextBufferSize) {

m_failureReason = JITFailureReason::ParenthesisNestedTooDeep;

return;

}

load32(Address(matchingContext, MatchingContextHolder::offsetOfPatternContextBufferSize()), freelistSizeRegister);

// Note that matchingContext and freelistRegister are likely the same register.

loadPtr(Address(matchingContext, MatchingContextHolder::offsetOfPatternContextBuffer()), freelistRegister);

Jump emptyFreeList = branchTestPtr(Zero, freelistRegister);

move(freelistRegister, parenContextPointer);

addPtr(TrustedImm32(parenContextSize), freelistRegister, nextParenContextPointer);

addPtr(freelistRegister, freelistSizeRegister);

subPtr(TrustedImm32(parenContextSize), freelistSizeRegister);

Label loopTop(this);

Jump initDone = branchPtr(Above, nextParenContextPointer, freelistSizeRegister);

storePtr(nextParenContextPointer, Address(parenContextPointer, ParenContext::nextOffset()));

move(nextParenContextPointer, parenContextPointer);

addPtr(TrustedImm32(parenContextSize), parenContextPointer, nextParenContextPointer);

jump(loopTop);

initDone.link(this);

storePtr(TrustedImmPtr(nullptr), Address(parenContextPointer, ParenContext::nextOffset()));

emptyFreeList.link(this);

}

void allocateParenContext(RegisterID result)

{

m_abortExecution.append(branchTestPtr(Zero, freelistRegister));

sub32(TrustedImm32(1), remainingMatchCount);

m_hitMatchLimit.append(branchTestPtr(Zero, remainingMatchCount));

move(freelistRegister, result);

loadPtr(Address(freelistRegister, ParenContext::nextOffset()), freelistRegister);

}

void freeParenContext(RegisterID headPtrRegister, RegisterID newHeadPtrRegister)

{

loadPtr(Address(headPtrRegister, ParenContext::nextOffset()), newHeadPtrRegister);

storePtr(freelistRegister, Address(headPtrRegister, ParenContext::nextOffset()));

move(headPtrRegister, freelistRegister);

}

void saveParenContext(RegisterID parenContextReg, RegisterID tempReg, unsigned firstSubpattern, unsigned lastSubpattern, unsigned subpatternBaseFrameLocation)

{

store32(index, Address(parenContextReg, ParenContext::beginOffset()));

loadFromFrame(subpatternBaseFrameLocation + BackTrackInfoParentheses::matchAmountIndex(), tempReg);

store32(tempReg, Address(parenContextReg, ParenContext::matchAmountOffset()));

loadFromFrame(subpatternBaseFrameLocation + BackTrackInfoParentheses::returnAddressIndex(), tempReg);

storePtr(tempReg, Address(parenContextReg, ParenContext::returnAddressOffset()));

if (compileMode == IncludeSubpatterns) {

for (unsigned subpattern = firstSubpattern; subpattern <= lastSubpattern; subpattern++) {

loadPtr(Address(output, (subpattern << 1) * sizeof(unsigned)), tempReg);

storePtr(tempReg, Address(parenContextReg, ParenContext::subpatternOffset(subpattern)));

clearSubpatternStart(subpattern);

}

}

subpatternBaseFrameLocation += YarrStackSpaceForBackTrackInfoParentheses;

for (unsigned frameLocation = subpatternBaseFrameLocation; frameLocation < m_parenContextSizes.frameSlots(); frameLocation++) {

loadFromFrame(frameLocation, tempReg);

storePtr(tempReg, Address(parenContextReg, ParenContext::savedFrameOffset(m_parenContextSizes) + frameLocation * sizeof(uintptr_t)));

}

}

void restoreParenContext(RegisterID parenContextReg, RegisterID tempReg, unsigned firstSubpattern, unsigned lastSubpattern, unsigned subpatternBaseFrameLocation)

{

load32(Address(parenContextReg, ParenContext::beginOffset()), index);

storeToFrame(index, subpatternBaseFrameLocation + BackTrackInfoParentheses::beginIndex());

load32(Address(parenContextReg, ParenContext::matchAmountOffset()), tempReg);

storeToFrame(tempReg, subpatternBaseFrameLocation + BackTrackInfoParentheses::matchAmountIndex());

loadPtr(Address(parenContextReg, ParenContext::returnAddressOffset()), tempReg);

storeToFrame(tempReg, subpatternBaseFrameLocation + BackTrackInfoParentheses::returnAddressIndex());

if (compileMode == IncludeSubpatterns) {

for (unsigned subpattern = firstSubpattern; subpattern <= lastSubpattern; subpattern++) {

loadPtr(Address(parenContextReg, ParenContext::subpatternOffset(subpattern)), tempReg);

storePtr(tempReg, Address(output, (subpattern << 1) * sizeof(unsigned)));

}

}

subpatternBaseFrameLocation += YarrStackSpaceForBackTrackInfoParentheses;

for (unsigned frameLocation = subpatternBaseFrameLocation; frameLocation < m_parenContextSizes.frameSlots(); frameLocation++) {

loadPtr(Address(parenContextReg, ParenContext::savedFrameOffset(m_parenContextSizes) + frameLocation * sizeof(uintptr_t)), tempReg);

storeToFrame(tempReg, frameLocation);

}

}

#endif

void optimizeAlternative(PatternAlternative* alternative)

{

if (!alternative->m_terms.size())

return;

for (unsigned i = 0; i < alternative->m_terms.size() - 1; ++i) {

PatternTerm& term = alternative->m_terms[i];

PatternTerm& nextTerm = alternative->m_terms[i + 1];

// We can move BMP only character classes after fixed character terms.

if ((term.type == PatternTerm::TypeCharacterClass)

&& (term.quantityType == QuantifierFixedCount)

&& (!m_decodeSurrogatePairs || (term.characterClass->hasOneCharacterSize() && !term.m_invert))

&& (nextTerm.type == PatternTerm::TypePatternCharacter)

&& (nextTerm.quantityType == QuantifierFixedCount)) {

PatternTerm termCopy = term;

alternative->m_terms[i] = nextTerm;

alternative->m_terms[i + 1] = termCopy;

}

}

}

void matchCharacterClassRange(RegisterID character, JumpList& failures, JumpList& matchDest, const CharacterRange* ranges, unsigned count, unsigned* matchIndex, const UChar32* matches, unsigned matchCount)

{

do {

// pick which range we're going to generate

int which = count >> 1;

char lo = ranges[which].begin;

char hi = ranges[which].end;

// check if there are any ranges or matches below lo. If not, just jl to failure -

// if there is anything else to check, check that first, if it falls through jmp to failure.

if ((*matchIndex < matchCount) && (matches[*matchIndex] < lo)) {

Jump loOrAbove = branch32(GreaterThanOrEqual, character, Imm32((unsigned short)lo));

// generate code for all ranges before this one

if (which)

matchCharacterClassRange(character, failures, matchDest, ranges, which, matchIndex, matches, matchCount);

while ((*matchIndex < matchCount) && (matches[*matchIndex] < lo)) {

matchDest.append(branch32(Equal, character, Imm32((unsigned short)matches[*matchIndex])));

++*matchIndex;

}

failures.append(jump());

loOrAbove.link(this);

} else if (which) {

Jump loOrAbove = branch32(GreaterThanOrEqual, character, Imm32((unsigned short)lo));

matchCharacterClassRange(character, failures, matchDest, ranges, which, matchIndex, matches, matchCount);

failures.append(jump());

loOrAbove.link(this);

} else

failures.append(branch32(LessThan, character, Imm32((unsigned short)lo)));

while ((*matchIndex < matchCount) && (matches[*matchIndex] <= hi))

++*matchIndex;

matchDest.append(branch32(LessThanOrEqual, character, Imm32((unsigned short)hi)));

// fall through to here, the value is above hi.

// shuffle along & loop around if there are any more matches to handle.

unsigned next = which + 1;

ranges += next;

count -= next;

} while (count);

}

void matchCharacterClass(RegisterID character, JumpList& matchDest, const CharacterClass* charClass)

{

if (charClass->m_table && !m_decodeSurrogatePairs) {

ExtendedAddress tableEntry(character, reinterpret_cast<intptr_t>(charClass->m_table));

matchDest.append(branchTest8(charClass->m_tableInverted ? Zero : NonZero, tableEntry));

return;

}

JumpList unicodeFail;

if (charClass->m_matchesUnicode.size() || charClass->m_rangesUnicode.size()) {

JumpList isAscii;

if (charClass->m_matches.size() || charClass->m_ranges.size())

isAscii.append(branch32(LessThanOrEqual, character, TrustedImm32(0x7f)));

if (charClass->m_matchesUnicode.size()) {

for (unsigned i = 0; i < charClass->m_matchesUnicode.size(); ++i) {

UChar32 ch = charClass->m_matchesUnicode[i];

matchDest.append(branch32(Equal, character, Imm32(ch)));

}

}

if (charClass->m_rangesUnicode.size()) {

for (unsigned i = 0; i < charClass->m_rangesUnicode.size(); ++i) {

UChar32 lo = charClass->m_rangesUnicode[i].begin;

UChar32 hi = charClass->m_rangesUnicode[i].end;

Jump below = branch32(LessThan, character, Imm32(lo));

matchDest.append(branch32(LessThanOrEqual, character, Imm32(hi)));

below.link(this);

}

}

if (charClass->m_matches.size() || charClass->m_ranges.size())

unicodeFail = jump();

isAscii.link(this);

}

if (charClass->m_ranges.size()) {

unsigned matchIndex = 0;

JumpList failures;

matchCharacterClassRange(character, failures, matchDest, charClass->m_ranges.begin(), charClass->m_ranges.size(), &matchIndex, charClass->m_matches.begin(), charClass->m_matches.size());

while (matchIndex < charClass->m_matches.size())

matchDest.append(branch32(Equal, character, Imm32((unsigned short)charClass->m_matches[matchIndex++])));

failures.link(this);

} else if (charClass->m_matches.size()) {

// optimization: gather 'a','A' etc back together, can mask & test once.

Vector<char> matchesAZaz;

for (unsigned i = 0; i < charClass->m_matches.size(); ++i) {

char ch = charClass->m_matches[i];

if (m_pattern.ignoreCase()) {

if (isASCIILower(ch)) {

matchesAZaz.append(ch);

continue;

}

if (isASCIIUpper(ch))

continue;

}

matchDest.append(branch32(Equal, character, Imm32((unsigned short)ch)));

}

if (unsigned countAZaz = matchesAZaz.size()) {

or32(TrustedImm32(32), character);

for (unsigned i = 0; i < countAZaz; ++i)

matchDest.append(branch32(Equal, character, TrustedImm32(matchesAZaz[i])));

}

}

if (charClass->m_matchesUnicode.size() || charClass->m_rangesUnicode.size())

unicodeFail.link(this);

}

#ifdef JIT_UNICODE_EXPRESSIONS

void advanceIndexAfterCharacterClassTermMatch(const PatternTerm* term, JumpList& failuresAfterIncrementingIndex, const RegisterID character)

{

ASSERT(term->type == PatternTerm::TypeCharacterClass);

if (term->isFixedWidthCharacterClass())

add32(TrustedImm32(term->characterClass->hasNonBMPCharacters() ? 2 : 1), index);

else {

add32(TrustedImm32(1), index);

Jump isBMPChar = branch32(LessThan, character, supplementaryPlanesBase);

failuresAfterIncrementingIndex.append(atEndOfInput());

add32(TrustedImm32(1), index);

isBMPChar.link(this);

}

}

#endif

// Jumps if input not available; will have (incorrectly) incremented already!

Jump jumpIfNoAvailableInput(unsigned countToCheck = 0)

{

if (countToCheck)

add32(Imm32(countToCheck), index);

return branch32(Above, index, length);

}

Jump jumpIfAvailableInput(unsigned countToCheck)

{

add32(Imm32(countToCheck), index);

return branch32(BelowOrEqual, index, length);

}

Jump checkNotEnoughInput(RegisterID additionalAmount)

{

add32(index, additionalAmount);

return branch32(Above, additionalAmount, length);

}

Jump checkInput()

{

return branch32(BelowOrEqual, index, length);

}

Jump atEndOfInput()

{

return branch32(Equal, index, length);

}

Jump notAtEndOfInput()

{

return branch32(NotEqual, index, length);

}

BaseIndex negativeOffsetIndexedAddress(Checked<unsigned> negativeCharacterOffset, RegisterID tempReg, RegisterID indexReg = index)

{

RegisterID base = input;

// BaseIndex() addressing can take a int32_t offset. Given that we can have a regular

// expression that has unsigned character offsets, BaseIndex's signed offset is insufficient

// for addressing in extreme cases where we might underflow. Therefore we check to see if

// negativeCharacterOffset will underflow directly or after converting for 16 bit characters.

// If so, we do our own address calculating by adjusting the base, using the result register

// as a temp address register.

unsigned maximumNegativeOffsetForCharacterSize = m_charSize == Char8 ? 0x7fffffff : 0x3fffffff;

unsigned offsetAdjustAmount = 0x40000000;

if (negativeCharacterOffset.unsafeGet() > maximumNegativeOffsetForCharacterSize) {

base = tempReg;

move(input, base);

while (negativeCharacterOffset.unsafeGet() > maximumNegativeOffsetForCharacterSize) {

subPtr(TrustedImm32(offsetAdjustAmount), base);

if (m_charSize != Char8)

subPtr(TrustedImm32(offsetAdjustAmount), base);

negativeCharacterOffset -= offsetAdjustAmount;

}

}

Checked<int32_t> characterOffset(-static_cast<int32_t>(negativeCharacterOffset.unsafeGet()));

if (m_charSize == Char8)

return BaseIndex(input, indexReg, TimesOne, (characterOffset * static_cast<int32_t>(sizeof(char))).unsafeGet());

return BaseIndex(input, indexReg, TimesTwo, (characterOffset * static_cast<int32_t>(sizeof(UChar))).unsafeGet());

}

#ifdef JIT_UNICODE_EXPRESSIONS

void tryReadUnicodeCharImpl(RegisterID resultReg)

{

ASSERT(m_charSize == Char16);

JumpList notUnicode;

load16Unaligned(regUnicodeInputAndTrail, resultReg);

// Is the character a leading surrogate?

and32(surrogateTagMask, resultReg, unicodeTemp);

notUnicode.append(branch32(NotEqual, unicodeTemp, leadingSurrogateTag));

// Is the input long enough to read a trailing surrogate?

addPtr(TrustedImm32(2), regUnicodeInputAndTrail);

notUnicode.append(branchPtr(AboveOrEqual, regUnicodeInputAndTrail, endOfStringAddress));

// Is the character a trailing surrogate?

load16Unaligned(Address(regUnicodeInputAndTrail), regUnicodeInputAndTrail);

and32(surrogateTagMask, regUnicodeInputAndTrail, unicodeTemp);

notUnicode.append(branch32(NotEqual, unicodeTemp, trailingSurrogateTag));

// Combine leading and trailing surrogates to produce a code point.

lshift32(TrustedImm32(10), resultReg);

getEffectiveAddress(BaseIndex(resultReg, regUnicodeInputAndTrail, TimesOne, -U16_SURROGATE_OFFSET), resultReg);

notUnicode.link(this);

}

void tryReadUnicodeChar(BaseIndex address, RegisterID resultReg)

{

ASSERT(m_charSize == Char16);

getEffectiveAddress(address, regUnicodeInputAndTrail);

if (resultReg == regT0)

m_tryReadUnicodeCharacterCalls.append(nearCall());

else

tryReadUnicodeCharImpl(resultReg);

}

#endif

void readCharacter(Checked<unsigned> negativeCharacterOffset, RegisterID resultReg, RegisterID indexReg = index)

{

BaseIndex address = negativeOffsetIndexedAddress(negativeCharacterOffset, resultReg, indexReg);

if (m_charSize == Char8)

load8(address, resultReg);

#ifdef JIT_UNICODE_EXPRESSIONS

else if (m_decodeSurrogatePairs)

tryReadUnicodeChar(address, resultReg);

#endif

else

load16Unaligned(address, resultReg);

}

Jump jumpIfCharNotEquals(UChar32 ch, Checked<unsigned> negativeCharacterOffset, RegisterID character)

{

readCharacter(negativeCharacterOffset, character);

// For case-insesitive compares, non-ascii characters that have different

// upper & lower case representations are converted to a character class.

ASSERT(!m_pattern.ignoreCase() || isASCIIAlpha(ch) || isCanonicallyUnique(ch, m_canonicalMode));

if (m_pattern.ignoreCase() && isASCIIAlpha(ch)) {

or32(TrustedImm32(0x20), character);

ch |= 0x20;

}

return branch32(NotEqual, character, Imm32(ch));

}

void storeToFrame(RegisterID reg, unsigned frameLocation)

{

poke(reg, frameLocation);

}

void storeToFrame(TrustedImm32 imm, unsigned frameLocation)

{

poke(imm, frameLocation);

}

#if CPU(ARM64) || CPU(X86_64)

void storeToFrame(TrustedImmPtr imm, unsigned frameLocation)

{

poke(imm, frameLocation);

}

#endif

DataLabelPtr storeToFrameWithPatch(unsigned frameLocation)

{

return storePtrWithPatch(TrustedImmPtr(nullptr), Address(stackPointerRegister, frameLocation * sizeof(void*)));

}

void loadFromFrame(unsigned frameLocation, RegisterID reg)

{

peek(reg, frameLocation);

}

void loadFromFrameAndJump(unsigned frameLocation)

{

farJump(Address(stackPointerRegister, frameLocation * sizeof(void*)), YarrBacktrackPtrTag);

}

unsigned alignCallFrameSizeInBytes(unsigned callFrameSize)

{

if (!callFrameSize)

return 0;

callFrameSize *= sizeof(void*);

if (callFrameSize / sizeof(void*) != m_pattern.m_body->m_callFrameSize)

CRASH();

callFrameSize = (callFrameSize + 0x3f) & ~0x3f;

return callFrameSize;

}

void removeCallFrame()

{

unsigned callFrameSizeInBytes = alignCallFrameSizeInBytes(m_pattern.m_body->m_callFrameSize);

if (callFrameSizeInBytes)

addPtr(Imm32(callFrameSizeInBytes), stackPointerRegister);

}

void generateFailReturn()

{

move(TrustedImmPtr((void*)WTF::notFound), returnRegister);

move(TrustedImm32(0), returnRegister2);

generateReturn();

}

void generateJITFailReturn()

{

if (m_abortExecution.empty() && m_hitMatchLimit.empty())

return;

JumpList finishExiting;

if (!m_abortExecution.empty()) {

m_abortExecution.link(this);

move(TrustedImmPtr((void*)static_cast<size_t>(-2)), returnRegister);

finishExiting.append(jump());

}

if (!m_hitMatchLimit.empty()) {

m_hitMatchLimit.link(this);

move(TrustedImmPtr((void*)static_cast<size_t>(-1)), returnRegister);

}

finishExiting.link(this);

removeCallFrame();

move(TrustedImm32(0), returnRegister2);

generateReturn();

}

// Used to record subpatterns, should only be called if compileMode is IncludeSubpatterns.

void setSubpatternStart(RegisterID reg, unsigned subpattern)

{

ASSERT(subpattern);

// FIXME: should be able to ASSERT(compileMode == IncludeSubpatterns), but then this function is conditionally NORETURN. :-(

store32(reg, Address(output, (subpattern << 1) * sizeof(int)));

}

void setSubpatternEnd(RegisterID reg, unsigned subpattern)

{

ASSERT(subpattern);

// FIXME: should be able to ASSERT(compileMode == IncludeSubpatterns), but then this function is conditionally NORETURN. :-(

store32(reg, Address(output, ((subpattern << 1) + 1) * sizeof(int)));

}

void clearSubpatternStart(unsigned subpattern)

{

ASSERT(subpattern);

// FIXME: should be able to ASSERT(compileMode == IncludeSubpatterns), but then this function is conditionally NORETURN. :-(

store32(TrustedImm32(-1), Address(output, (subpattern << 1) * sizeof(int)));

}

void clearMatches(unsigned subpattern, unsigned lastSubpattern)

{

for (; subpattern <= lastSubpattern; subpattern++)

clearSubpatternStart(subpattern);

}

// We use one of three different strategies to track the start of the current match,

// while matching.

// 1) If the pattern has a fixed size, do nothing! - we calculate the value lazily

// at the end of matching. This is irrespective of compileMode, and in this case

// these methods should never be called.

// 2) If we're compiling IncludeSubpatterns, 'output' contains a pointer to an output

// vector, store the match start in the output vector.

// 3) If we're compiling MatchOnly, 'output' is unused, store the match start directly

// in this register.

void setMatchStart(RegisterID reg)

{

ASSERT(!m_pattern.m_body->m_hasFixedSize);

if (compileMode == IncludeSubpatterns)

store32(reg, output);

else

move(reg, output);

}

void getMatchStart(RegisterID reg)

{

ASSERT(!m_pattern.m_body->m_hasFixedSize);

if (compileMode == IncludeSubpatterns)

load32(output, reg);

else

move(output, reg);

}

enum YarrOpCode : uint8_t {

// These nodes wrap body alternatives - those in the main disjunction,

// rather than subpatterns or assertions. These are chained together in

// a doubly linked list, with a 'begin' node for the first alternative,

// a 'next' node for each subsequent alternative, and an 'end' node at

// the end. In the case of repeating alternatives, the 'end' node also

// has a reference back to 'begin'.

OpBodyAlternativeBegin,

OpBodyAlternativeNext,

OpBodyAlternativeEnd,

// Similar to the body alternatives, but used for subpatterns with two

// or more alternatives.

OpNestedAlternativeBegin,

OpNestedAlternativeNext,

OpNestedAlternativeEnd,

// Used for alternatives in subpatterns where there is only a single

// alternative (backtracking is easier in these cases), or for alternatives

// which never need to be backtracked (those in parenthetical assertions,

// terminal subpatterns).

OpSimpleNestedAlternativeBegin,

OpSimpleNestedAlternativeNext,

OpSimpleNestedAlternativeEnd,

// Used to wrap 'Once' subpattern matches (quantityMaxCount == 1).

OpParenthesesSubpatternOnceBegin,

OpParenthesesSubpatternOnceEnd,

// Used to wrap 'Terminal' subpattern matches (at the end of the regexp).

OpParenthesesSubpatternTerminalBegin,

OpParenthesesSubpatternTerminalEnd,

// Used to wrap generic captured matches

OpParenthesesSubpatternBegin,

OpParenthesesSubpatternEnd,

// Used to wrap parenthetical assertions.

OpParentheticalAssertionBegin,

OpParentheticalAssertionEnd,

// Wraps all simple terms (pattern characters, character classes).

OpTerm,

// Where an expression contains only 'once through' body alternatives

// and no repeating ones, this op is used to return match failure.

OpMatchFailed

};

// This structure is used to hold the compiled opcode information,

// including reference back to the original PatternTerm/PatternAlternatives,

// and JIT compilation data structures.

struct YarrOp {

explicit YarrOp(PatternTerm* term)

: m_term(term)

, m_op(OpTerm)

, m_isDeadCode(false)

{

}

explicit YarrOp(YarrOpCode op)

: m_op(op)

, m_isDeadCode(false)

{

}

// For alternatives, this holds the PatternAlternative and doubly linked

// references to this alternative's siblings. In the case of the

// OpBodyAlternativeEnd node at the end of a section of repeating nodes,

// m_nextOp will reference the OpBodyAlternativeBegin node of the first

// repeating alternative.

PatternAlternative* m_alternative;

size_t m_previousOp;

size_t m_nextOp;

// The operation, as a YarrOpCode, and also a reference to the PatternTerm.

PatternTerm* m_term;

YarrOpCode m_op;

// Used to record a set of Jumps out of the generated code, typically

// used for jumps out to backtracking code, and a single reentry back

// into the code for a node (likely where a backtrack will trigger

// rematching).

Label m_reentry;

JumpList m_jumps;

// Used for backtracking when the prior alternative did not consume any

// characters but matched.

Jump m_zeroLengthMatch;

// This flag is used to null out the second pattern character, when

// two are fused to match a pair together.

bool m_isDeadCode;

// Currently used in the case of some of the more complex management of

// 'm_checkedOffset', to cache the offset used in this alternative, to avoid

// recalculating it.

Checked<unsigned> m_checkAdjust;

// Used by OpNestedAlternativeNext/End to hold the pointer to the

// value that will be pushed into the pattern's frame to return to,

// upon backtracking back into the disjunction.

DataLabelPtr m_returnAddress;

};

// BacktrackingState

// This class encapsulates information about the state of code generation

// whilst generating the code for backtracking, when a term fails to match.

// Upon entry to code generation of the backtracking code for a given node,

// the Backtracking state will hold references to all control flow sources

// that are outputs in need of further backtracking from the prior node

// generated (which is the subsequent operation in the regular expression,

// and in the m_ops Vector, since we generated backtracking backwards).

// These references to control flow take the form of:

// - A jump list of jumps, to be linked to code that will backtrack them

// further.

// - A set of DataLabelPtr values, to be populated with values to be

// treated effectively as return addresses backtracking into complex

// subpatterns.

// - A flag indicating that the current sequence of generated code up to

// this point requires backtracking.

class BacktrackingState {

public:

BacktrackingState()

: m_pendingFallthrough(false)

{

}

// Add a jump or jumps, a return address, or set the flag indicating

// that the current 'fallthrough' control flow requires backtracking.

void append(const Jump& jump)

{

m_laterFailures.append(jump);

}

void append(JumpList& jumpList)

{

m_laterFailures.append(jumpList);

}

void append(const DataLabelPtr& returnAddress)

{

m_pendingReturns.append(returnAddress);

}

void fallthrough()

{

ASSERT(!m_pendingFallthrough);

m_pendingFallthrough = true;

}

// These methods clear the backtracking state, either linking to the

// current location, a provided label, or copying the backtracking out

// to a JumpList. All actions may require code generation to take place,

// and as such are passed a pointer to the assembler.

void link(MacroAssembler* assembler)

{

if (m_pendingReturns.size()) {

Label here(assembler);

for (unsigned i = 0; i < m_pendingReturns.size(); ++i)

m_backtrackRecords.append(ReturnAddressRecord(m_pendingReturns[i], here));

m_pendingReturns.clear();

}

m_laterFailures.link(assembler);

m_laterFailures.clear();

m_pendingFallthrough = false;

}

void linkTo(Label label, MacroAssembler* assembler)

{

if (m_pendingReturns.size()) {

for (unsigned i = 0; i < m_pendingReturns.size(); ++i)

m_backtrackRecords.append(ReturnAddressRecord(m_pendingReturns[i], label));

m_pendingReturns.clear();

}

if (m_pendingFallthrough)

assembler->jump(label);

m_laterFailures.linkTo(label, assembler);

m_laterFailures.clear();

m_pendingFallthrough = false;

}

void takeBacktracksToJumpList(JumpList& jumpList, MacroAssembler* assembler)

{

if (m_pendingReturns.size()) {

Label here(assembler);

for (unsigned i = 0; i < m_pendingReturns.size(); ++i)

m_backtrackRecords.append(ReturnAddressRecord(m_pendingReturns[i], here));

m_pendingReturns.clear();

m_pendingFallthrough = true;

}

if (m_pendingFallthrough)

jumpList.append(assembler->jump());

jumpList.append(m_laterFailures);

m_laterFailures.clear();

m_pendingFallthrough = false;

}

bool isEmpty()

{

return m_laterFailures.empty() && m_pendingReturns.isEmpty() && !m_pendingFallthrough;

}

// Called at the end of code generation to link all return addresses.

void linkDataLabels(LinkBuffer& linkBuffer)

{

ASSERT(isEmpty());

for (unsigned i = 0; i < m_backtrackRecords.size(); ++i)

linkBuffer.patch(m_backtrackRecords[i].m_dataLabel, linkBuffer.locationOf<YarrBacktrackPtrTag>(m_backtrackRecords[i].m_backtrackLocation));

}

private:

struct ReturnAddressRecord {

ReturnAddressRecord(DataLabelPtr dataLabel, Label backtrackLocation)

: m_dataLabel(dataLabel)

, m_backtrackLocation(backtrackLocation)

{

}

DataLabelPtr m_dataLabel;

Label m_backtrackLocation;

};

JumpList m_laterFailures;

bool m_pendingFallthrough;

Vector<DataLabelPtr, 4> m_pendingReturns;

Vector<ReturnAddressRecord, 4> m_backtrackRecords;

};

// Generation methods:

// ===================

// This method provides a default implementation of backtracking common

// to many terms; terms commonly jump out of the forwards matching path

// on any failed conditions, and add these jumps to the m_jumps list. If

// no special handling is required we can often just backtrack to m_jumps.

void backtrackTermDefault(size_t opIndex)

{

YarrOp& op = m_ops[opIndex];

m_backtrackingState.append(op.m_jumps);

}

void generateAssertionBOL(size_t opIndex)

{

YarrOp& op = m_ops[opIndex];

PatternTerm* term = op.m_term;

if (m_pattern.multiline()) {

const RegisterID character = regT0;

JumpList matchDest;

if (!term->inputPosition)