/*

* Copyright (C) 2013-2021 Apple Inc. All rights reserved.

* Copyright (C) 2014 Yusuke Suzuki <utatane.tea@gmail.com>

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

*

* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

* THE POSSIBILITY OF SUCH DAMAGE.

*/

#include "config.h"

#include "SelectorCompiler.h"

#if ENABLE(CSS_SELECTOR_JIT)

#include "CSSSelector.h"

#include "CSSSelectorList.h"

#include "DOMJITHelpers.h"

#include "Element.h"

#include "ElementData.h"

#include "ElementRareData.h"

#include "FunctionCall.h"

#include "HTMLDocument.h"

#include "HTMLNames.h"

#include "HTMLParserIdioms.h"

#include "InspectorInstrumentation.h"

#include "NodeRenderStyle.h"

#include "QualifiedName.h"

#include "RegisterAllocator.h"

#include "RenderElement.h"

#include "RenderStyle.h"

#include "SVGElement.h"

#include "SelectorCheckerTestFunctions.h"

#include "StackAllocator.h"

#include "StyleRelations.h"

#include "StyledElement.h"

#include <JavaScriptCore/GPRInfo.h>

#include <JavaScriptCore/LinkBuffer.h>

#include <JavaScriptCore/MacroAssembler.h>

#include <JavaScriptCore/VM.h>

#include <limits>

#include <wtf/Deque.h>

#include <wtf/HashSet.h>

#include <wtf/Vector.h>

#include <wtf/text/CString.h>

namespace WebCore {

namespace SelectorCompiler {

extern "C" {

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationAddStyleRelationFunction, void, (SelectorChecker::CheckingContext*, const Element*));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationElementIsActive, bool, (const Element*));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationElementIsHovered, bool, (const Element*));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationIsPlaceholderShown, bool, (const Element*));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMakeContextStyleUniqueIfNecessaryAndTestIsPlaceholderShown, bool, (const Element*, SelectorChecker::CheckingContext*));

#if CPU(ARM_THUMB2) && !CPU(APPLE_ARMV7S)

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationModuloHelper, int, (int dividend, int divisor));

#endif

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationSynchronizeAllAnimatedSVGAttribute, void, (SVGElement&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationSynchronizeStyleAttributeInternal, void, (StyledElement* styledElement));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationEqualIgnoringASCIICaseNonNull, bool, (const StringImpl*, const StringImpl*));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationIsAutofilled, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationIsAutofilledAndObscured, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationIsAutofilledStrongPassword, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationIsAutofilledStrongPasswordViewable, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationIsChecked, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesDefaultPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesDisabledPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesEnabledPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationIsDefinedElement, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesFocusPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesFocusVisiblePseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesFocusWithinPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationIsMediaDocument, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationIsInRange, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesIndeterminatePseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationIsInvalid, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationIsOptionalFormControl, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationIsOutOfRange, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesReadOnlyPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesReadWritePseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationIsRequiredFormControl, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationIsValid, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationIsWindowInactive, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesLangPseudoClass, bool, (const Element&, const Vector<AtomString>&));

#if ENABLE(FULLSCREEN_API)

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesFullScreenPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesFullScreenDocumentPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesFullScreenAncestorPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesFullScreenAnimatingFullScreenTransitionPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesFullScreenControlsHiddenPseudoClass, bool, (const Element&));

#endif

#if ENABLE(PICTURE_IN_PICTURE_API)

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesPictureInPicturePseudoClass, bool, (const Element&));

#endif

#if ENABLE(VIDEO)

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesFutureCuePseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesPastCuePseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesPlayingPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesPausedPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesSeekingPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesBufferingPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesStalledPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesMutedPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesVolumeLockedPseudoClass, bool, (const Element&));

#endif

#if ENABLE(ATTACHMENT_ELEMENT)

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationHasAttachment, bool, (const Element&));

#endif

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationMatchesModalDialogPseudoClass, bool, (const Element&));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationAttributeValueBeginsWithCaseSensitive, bool, (const Attribute* attribute, AtomStringImpl* expectedString));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationAttributeValueBeginsWithCaseInsensitive, bool, (const Attribute* attribute, AtomStringImpl* expectedString));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationAttributeValueContainsCaseSensitive, bool, (const Attribute* attribute, AtomStringImpl* expectedString));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationAttributeValueContainsCaseInsensitive, bool, (const Attribute* attribute, AtomStringImpl* expectedString));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationAttributeValueEndsWithCaseSensitive, bool, (const Attribute* attribute, AtomStringImpl* expectedString));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationAttributeValueEndsWithCaseInsensitive, bool, (const Attribute* attribute, AtomStringImpl* expectedString));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationAttributeValueMatchHyphenRuleCaseSensitive, bool, (const Attribute* attribute, AtomStringImpl* expectedString));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationAttributeValueMatchHyphenRuleCaseInsensitive, bool, (const Attribute* attribute, AtomStringImpl* expectedString));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationAttributeValueSpaceSeparatedListContainsCaseSensitive, bool, (const Attribute* attribute, AtomStringImpl* expectedString));

static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(operationAttributeValueSpaceSeparatedListContainsCaseInsensitive, bool, (const Attribute* attribute, AtomStringImpl* expectedString));

} // extern "C"

#define CSS_SELECTOR_JIT_DEBUGGING 0

enum class BacktrackingAction {

NoBacktracking,

JumpToDescendantEntryPoint,

JumpToIndirectAdjacentEntryPoint,

JumpToDescendantTreeWalkerEntryPoint,

JumpToIndirectAdjacentTreeWalkerEntryPoint,

JumpToDescendantTail,

JumpToDirectAdjacentTail

};

struct BacktrackingFlag {

enum {

DescendantEntryPoint = 1,

IndirectAdjacentEntryPoint = 1 << 1,

SaveDescendantBacktrackingStart = 1 << 2,

SaveAdjacentBacktrackingStart = 1 << 3,

DirectAdjacentTail = 1 << 4,

DescendantTail = 1 << 5,

InChainWithDescendantTail = 1 << 6,

InChainWithAdjacentTail = 1 << 7

};

};

enum class FragmentRelation {

Rightmost,

Descendant,

Child,

DirectAdjacent,

IndirectAdjacent

};

enum class FunctionType {

SimpleSelectorChecker,

SelectorCheckerWithCheckingContext,

CannotMatchAnything,

CannotCompile

};

enum class FragmentPositionInRootFragments {

Rightmost,

AdjacentToRightmost,

Other

};

enum class VisitedMode {

None,

Visited

};

enum class AttributeCaseSensitivity {

CaseSensitive,

// Some values are matched case-insensitively for HTML elements.

// That is a legacy behavior decided by HTMLDocument::isCaseSensitiveAttribute().

HTMLLegacyCaseInsensitive,

CaseInsensitive

};

static AttributeCaseSensitivity attributeSelectorCaseSensitivity(const CSSSelector& selector)

{

ASSERT(selector.isAttributeSelector());

// This is by convention, the case is irrelevant for Set.

if (selector.match() == CSSSelector::Set)

return AttributeCaseSensitivity::CaseSensitive;

if (selector.attributeValueMatchingIsCaseInsensitive())

return AttributeCaseSensitivity::CaseInsensitive;

if (HTMLDocument::isCaseSensitiveAttribute(selector.attribute()))

return AttributeCaseSensitivity::CaseSensitive;

return AttributeCaseSensitivity::HTMLLegacyCaseInsensitive;

}

class AttributeMatchingInfo {

public:

explicit AttributeMatchingInfo(const CSSSelector& selector)

: m_selector(&selector)

, m_attributeCaseSensitivity(attributeSelectorCaseSensitivity(selector))

{

ASSERT(!(m_attributeCaseSensitivity == AttributeCaseSensitivity::CaseInsensitive && !selector.attributeValueMatchingIsCaseInsensitive()));

ASSERT(!(selector.match() == CSSSelector::Set && m_attributeCaseSensitivity != AttributeCaseSensitivity::CaseSensitive));

}

AttributeCaseSensitivity attributeCaseSensitivity() const { return m_attributeCaseSensitivity; }

const CSSSelector& selector() const { return *m_selector; }

private:

const CSSSelector* m_selector;

AttributeCaseSensitivity m_attributeCaseSensitivity;

};

static const unsigned invalidHeight = std::numeric_limits<unsigned>::max();

static const unsigned invalidWidth = std::numeric_limits<unsigned>::max();

struct SelectorFragment;

class SelectorFragmentList;

class SelectorList : public Vector<SelectorFragmentList> {

public:

unsigned registerRequirements = std::numeric_limits<unsigned>::max();

unsigned stackRequirements = std::numeric_limits<unsigned>::max();

bool clobberElementAddressRegister = true;

};

struct NthChildOfSelectorInfo {

int a;

int b;

SelectorList selectorList;

};

struct SelectorFragment {

FragmentRelation relationToLeftFragment;

FragmentRelation relationToRightFragment;

FragmentPositionInRootFragments positionInRootFragments;

bool isRightmostOrAdjacent { false };

BacktrackingAction traversalBacktrackingAction = BacktrackingAction::NoBacktracking;

BacktrackingAction matchingTagNameBacktrackingAction = BacktrackingAction::NoBacktracking;

BacktrackingAction matchingPostTagNameBacktrackingAction = BacktrackingAction::NoBacktracking;

unsigned char backtrackingFlags = 0;

unsigned tagNameMatchedBacktrackingStartHeightFromDescendant = invalidHeight;

unsigned tagNameNotMatchedBacktrackingStartHeightFromDescendant = invalidHeight;

unsigned heightFromDescendant = 0;

unsigned tagNameMatchedBacktrackingStartWidthFromIndirectAdjacent = invalidWidth;

unsigned tagNameNotMatchedBacktrackingStartWidthFromIndirectAdjacent = invalidWidth;

unsigned widthFromIndirectAdjacent = 0;

// FIXME: the large stack allocation caused by the inline capacity causes memory inefficiency. We should dump

// the min/max/average of the vectors and pick better inline capacity.

const CSSSelector* tagNameSelector = nullptr;

const AtomString* id = nullptr;

Vector<const Vector<AtomString>*> languageArgumentsList;

Vector<const AtomStringImpl*, 8> classNames;

HashSet<unsigned> pseudoClasses;

Vector<JSC::FunctionPtr<JSC::OperationPtrTag>, 4> unoptimizedPseudoClasses;

Vector<AttributeMatchingInfo, 4> attributes;

Vector<std::pair<int, int>, 2> nthChildFilters;

Vector<NthChildOfSelectorInfo> nthChildOfFilters;

Vector<std::pair<int, int>, 2> nthLastChildFilters;

Vector<NthChildOfSelectorInfo> nthLastChildOfFilters;

SelectorList notFilters;

Vector<SelectorList> matchesFilters;

Vector<Vector<SelectorFragment>> anyFilters;

const CSSSelector* pseudoElementSelector = nullptr;

// For quirks mode, follow this: http://quirks.spec.whatwg.org/#the-:active-and-:hover-quirk

// In quirks mode, a compound selector 'selector' that matches the following conditions must not match elements that would not also match the ':any-link' selector.

//

// selector uses the ':active' or ':hover' pseudo-classes.

// selector does not use a type selector.

// selector does not use an attribute selector.

// selector does not use an ID selector.

// selector does not use a class selector.

// selector does not use a pseudo-class selector other than ':active' and ':hover'.

// selector does not use a pseudo-element selector.

// selector is not part of an argument to a functional pseudo-class or pseudo-element.

bool onlyMatchesLinksInQuirksMode = true;

};

class SelectorFragmentList : public Vector<SelectorFragment, 4> {

public:

unsigned registerRequirements = std::numeric_limits<unsigned>::max();

unsigned stackRequirements = std::numeric_limits<unsigned>::max();

unsigned staticSpecificity = 0;

bool clobberElementAddressRegister = true;

};

struct TagNamePattern {

const CSSSelector* tagNameSelector = nullptr;

bool inverted = false;

};

typedef JSC::MacroAssembler Assembler;

typedef Vector<TagNamePattern, 32> TagNameList;

struct BacktrackingLevel {

Assembler::Label descendantEntryPoint;

Assembler::Label indirectAdjacentEntryPoint;

Assembler::Label descendantTreeWalkerBacktrackingPoint;

Assembler::Label indirectAdjacentTreeWalkerBacktrackingPoint;

StackAllocator::StackReference descendantBacktrackingStart;

Assembler::JumpList descendantBacktrackingFailureCases;

StackAllocator::StackReference adjacentBacktrackingStart;

Assembler::JumpList adjacentBacktrackingFailureCases;

};

class SelectorCodeGenerator {

public:

SelectorCodeGenerator(const CSSSelector*, SelectorContext);

SelectorCompilationStatus compile(JSC::MacroAssemblerCodeRef<JSC::CSSSelectorPtrTag>&);

private:

static const Assembler::RegisterID returnRegister;

static const Assembler::RegisterID elementAddressRegister;

static const Assembler::RegisterID checkingContextRegister;

static const Assembler::RegisterID callFrameRegister;

void generateReturn();

void generateSelectorChecker();

void generateSelectorCheckerExcludingPseudoElements(Assembler::JumpList& failureCases, const SelectorFragmentList&);

void generateElementMatchesSelectorList(Assembler::JumpList& failureCases, Assembler::RegisterID elementToMatch, const SelectorList&);

// Element relations tree walker.

void generateRightmostTreeWalker(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateWalkToParentNode(Assembler::RegisterID targetRegister);

void generateWalkToParentElement(Assembler::JumpList& failureCases, Assembler::RegisterID targetRegister);

void generateWalkToParentElementOrShadowRoot(Assembler::JumpList& failureCases, Assembler::RegisterID targetRegister);

void generateParentElementTreeWalker(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateAncestorTreeWalker(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateWalkToNextAdjacentElement(Assembler::JumpList& failureCases, Assembler::RegisterID);

void generateWalkToPreviousAdjacentElement(Assembler::JumpList& failureCases, Assembler::RegisterID);

void generateWalkToPreviousAdjacent(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateDirectAdjacentTreeWalker(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateIndirectAdjacentTreeWalker(Assembler::JumpList& failureCases, const SelectorFragment&);

void linkFailures(Assembler::JumpList& globalFailureCases, BacktrackingAction, Assembler::JumpList& localFailureCases);

void generateAdjacentBacktrackingTail();

void generateDescendantBacktrackingTail();

void generateBacktrackingTailsIfNeeded(Assembler::JumpList& failureCases, const SelectorFragment&);

// Element properties matchers.

void generateElementMatching(Assembler::JumpList& matchingTagNameFailureCases, Assembler::JumpList& matchingPostTagNameFailureCases, const SelectorFragment&);

void generateElementDataMatching(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateElementLinkMatching(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateElementFunctionCallTest(Assembler::JumpList& failureCases, JSC::FunctionPtr<JSC::OperationPtrTag>);

void generateElementIsActive(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateElementIsEmpty(Assembler::JumpList& failureCases);

void generateElementIsFirstChild(Assembler::JumpList& failureCases);

void generateElementIsHovered(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateElementIsInLanguage(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateElementIsInLanguage(Assembler::JumpList& failureCases, const Vector<AtomString>*);

void generateElementIsLastChild(Assembler::JumpList& failureCases);

void generateElementIsOnlyChild(Assembler::JumpList& failureCases);

void generateElementHasPlaceholderShown(Assembler::JumpList& failureCases);

void generateSynchronizeStyleAttribute(Assembler::RegisterID elementDataArraySizeAndFlags);

void generateSynchronizeAllAnimatedSVGAttribute(Assembler::RegisterID elementDataArraySizeAndFlags);

void generateElementAttributesMatching(Assembler::JumpList& failureCases, const LocalRegister& elementDataAddress, const SelectorFragment&);

void generateElementAttributeMatching(Assembler::JumpList& failureCases, Assembler::RegisterID currentAttributeAddress, Assembler::RegisterID decIndexRegister, const AttributeMatchingInfo& attributeInfo);

void generateElementAttributeValueMatching(Assembler::JumpList& failureCases, Assembler::RegisterID currentAttributeAddress, const AttributeMatchingInfo& attributeInfo);

void generateElementAttributeValueExactMatching(Assembler::JumpList& failureCases, Assembler::RegisterID currentAttributeAddress, const AtomString& expectedValue, AttributeCaseSensitivity valueCaseSensitivity);

void generateElementAttributeFunctionCallValueMatching(Assembler::JumpList& failureCases, Assembler::RegisterID currentAttributeAddress, const AtomString& expectedValue, AttributeCaseSensitivity valueCaseSensitivity, JSC::FunctionPtr<JSC::OperationPtrTag> caseSensitiveTest, JSC::FunctionPtr<JSC::OperationPtrTag> caseInsensitiveTest);

void generateElementHasTagName(Assembler::JumpList& failureCases, const CSSSelector& tagMatchingSelector);

void generateElementHasId(Assembler::JumpList& failureCases, const LocalRegister& elementDataAddress, const AtomString& idToMatch);

void generateElementHasClasses(Assembler::JumpList& failureCases, const LocalRegister& elementDataAddress, const Vector<const AtomStringImpl*, 8>& classNames);

void generateElementIsLink(Assembler::JumpList& failureCases);

void generateElementIsNthChild(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateElementIsNthChildOf(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateElementIsNthLastChild(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateElementIsNthLastChildOf(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateElementMatchesNotPseudoClass(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateElementMatchesAnyPseudoClass(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateElementMatchesMatchesPseudoClass(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateElementHasPseudoElement(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateElementIsRoot(Assembler::JumpList& failureCases);

void generateElementIsScopeRoot(Assembler::JumpList& failureCases);

void generateElementIsTarget(Assembler::JumpList& failureCases);

// Helpers.

void generateAddStyleRelationIfResolvingStyle(Assembler::RegisterID element, Style::Relation::Type, std::optional<Assembler::RegisterID> value = { });

void generateAddStyleRelation(Assembler::RegisterID checkingContext, Assembler::RegisterID element, Style::Relation::Type, std::optional<Assembler::RegisterID> value = { });

Assembler::Jump branchOnResolvingModeWithCheckingContext(Assembler::RelationalCondition, SelectorChecker::Mode, Assembler::RegisterID checkingContext);

Assembler::Jump branchOnResolvingMode(Assembler::RelationalCondition, SelectorChecker::Mode, Assembler::RegisterID checkingContext);

void generateElementIsFirstLink(Assembler::JumpList& failureCases, Assembler::RegisterID element);

void generateStoreLastVisitedElement(Assembler::RegisterID element);

void generateMarkPseudoStyleForPseudoElement(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateNthFilterTest(Assembler::JumpList& failureCases, Assembler::RegisterID counter, int a, int b);

void generateRequestedPseudoElementEqualsToSelectorPseudoElement(Assembler::JumpList& failureCases, const SelectorFragment&, Assembler::RegisterID checkingContext);

void generateSpecialFailureInQuirksModeForActiveAndHoverIfNeeded(Assembler::JumpList& failureCases, const SelectorFragment&);

Assembler::JumpList jumpIfNoPreviousAdjacentElement();

Assembler::JumpList jumpIfNoNextAdjacentElement();

Assembler::Jump jumpIfNotResolvingStyle(Assembler::RegisterID checkingContextRegister);

void loadCheckingContext(Assembler::RegisterID checkingContext);

Assembler::Jump modulo(JSC::MacroAssembler::ResultCondition, Assembler::RegisterID inputDividend, int divisor);

void moduloIsZero(Assembler::JumpList& failureCases, Assembler::RegisterID inputDividend, int divisor);

void generateNthChildParentCheckAndRelationUpdate(Assembler::JumpList& failureCases, const SelectorFragment&);

void generateNthLastChildParentCheckAndRelationUpdate(Assembler::JumpList& failureCases, const SelectorFragment&);

void pushMacroAssemblerRegisters();

void popMacroAssemblerRegisters(StackAllocator&);

bool generatePrologue();

void generateEpilogue(StackAllocator&);

StackAllocator::StackReferenceVector m_macroAssemblerRegistersStackReferences;

StackAllocator::StackReferenceVector m_prologueStackReferences;

Assembler m_assembler;

RegisterAllocator m_registerAllocator;

StackAllocator m_stackAllocator;

Vector<std::pair<Assembler::Call, JSC::FunctionPtr<JSC::OperationPtrTag>>, 32> m_functionCalls;

SelectorContext m_selectorContext;

FunctionType m_functionType;

SelectorFragmentList m_selectorFragments;

VisitedMode m_visitedMode;

StackAllocator::StackReference m_checkingContextStackReference;

bool m_descendantBacktrackingStartInUse;

Assembler::RegisterID m_descendantBacktrackingStart;

StackAllocator::StackReferenceVector m_backtrackingStack;

Deque<BacktrackingLevel, 32> m_backtrackingLevels;

StackAllocator::StackReference m_lastVisitedElement;

StackAllocator::StackReference m_startElement;

#if CSS_SELECTOR_JIT_DEBUGGING

const CSSSelector* m_originalSelector;

#endif

};

const Assembler::RegisterID SelectorCodeGenerator::returnRegister = JSC::GPRInfo::returnValueGPR;

const Assembler::RegisterID SelectorCodeGenerator::elementAddressRegister = JSC::GPRInfo::argumentGPR0;

const Assembler::RegisterID SelectorCodeGenerator::checkingContextRegister = JSC::GPRInfo::argumentGPR1;

const Assembler::RegisterID SelectorCodeGenerator::callFrameRegister = JSC::GPRInfo::callFrameRegister;

enum class FragmentsLevel {

Root = 0,

InFunctionalPseudoType = 1

};

enum class PseudoElementMatchingBehavior { CanMatch, NeverMatch };

static FunctionType constructFragments(const CSSSelector* rootSelector, SelectorContext, SelectorFragmentList& selectorFragments, FragmentsLevel, FragmentPositionInRootFragments, bool visitedMatchEnabled, VisitedMode&, PseudoElementMatchingBehavior);

static void computeBacktrackingInformation(SelectorFragmentList& selectorFragments, unsigned level = 0);

void compileSelector(CompiledSelector& compiledSelector, const CSSSelector* selector, SelectorContext selectorContext)

{

ASSERT(compiledSelector.status == SelectorCompilationStatus::NotCompiled);

if (!JSC::Options::useJIT()) {

compiledSelector.status = SelectorCompilationStatus::CannotCompile;

return;

}

SelectorCodeGenerator codeGenerator(selector, selectorContext);

compiledSelector.status = codeGenerator.compile(compiledSelector.codeRef);

#if defined(CSS_SELECTOR_JIT_PROFILING) && CSS_SELECTOR_JIT_PROFILING

compiledSelector.selector = selector;

#endif

ASSERT(compiledSelector.status != SelectorCompilationStatus::NotCompiled);

}

static inline FragmentRelation fragmentRelationForSelectorRelation(CSSSelector::RelationType relation)

{

switch (relation) {

case CSSSelector::DescendantSpace:

return FragmentRelation::Descendant;

case CSSSelector::Child:

return FragmentRelation::Child;

case CSSSelector::DirectAdjacent:

return FragmentRelation::DirectAdjacent;

case CSSSelector::IndirectAdjacent:

return FragmentRelation::IndirectAdjacent;

case CSSSelector::Subselector:

case CSSSelector::ShadowDescendant:

case CSSSelector::ShadowPartDescendant:

case CSSSelector::ShadowSlotted:

ASSERT_NOT_REACHED();

}

ASSERT_NOT_REACHED();

return FragmentRelation::Descendant;

}

static inline FunctionType mostRestrictiveFunctionType(FunctionType a, FunctionType b)

{

return std::max(a, b);

}

static inline bool fragmentMatchesTheRightmostElement(const SelectorFragment& fragment)

{

return fragment.relationToRightFragment == FragmentRelation::Rightmost && fragment.positionInRootFragments == FragmentPositionInRootFragments::Rightmost;

}

static inline bool fragmentMatchesRightmostOrAdjacentElement(const SelectorFragment& fragment)

{

return fragment.isRightmostOrAdjacent && fragment.positionInRootFragments != FragmentPositionInRootFragments::Other;

}

static inline FunctionType addScrollbarPseudoClassType(const CSSSelector&, SelectorFragment&)

{

// FIXME: scrollbar pseudoclass interaction with :not doesn't behave correctly.

// Compile them when they are fixed and tested.

// https://bugs.webkit.org/show_bug.cgi?id=146221

return FunctionType::CannotCompile;

}

// Handle the forward :nth-child() and backward :nth-last-child().

static FunctionType addNthChildType(const CSSSelector& selector, SelectorContext selectorContext, FragmentPositionInRootFragments positionInRootFragments, CSSSelector::PseudoClassType firstMatchAlternative, bool visitedMatchEnabled, Vector<std::pair<int, int>, 2>& simpleCases, Vector<NthChildOfSelectorInfo>& filteredCases, HashSet<unsigned>& pseudoClasses)

{

int a = selector.nthA();

int b = selector.nthB();

// The element count is always positive.

if (a <= 0 && b < 1)

return FunctionType::CannotMatchAnything;

if (const CSSSelectorList* selectorList = selector.selectorList()) {

NthChildOfSelectorInfo nthChildOfSelectorInfo;

nthChildOfSelectorInfo.a = a;

nthChildOfSelectorInfo.b = b;

FunctionType globalFunctionType = FunctionType::SimpleSelectorChecker;

if (selectorContext != SelectorContext::QuerySelector)

globalFunctionType = FunctionType::SelectorCheckerWithCheckingContext;

SelectorFragmentList* selectorFragments = nullptr;

for (const CSSSelector* subselector = selectorList->first(); subselector; subselector = CSSSelectorList::next(subselector)) {

if (!selectorFragments) {

nthChildOfSelectorInfo.selectorList.append(SelectorFragmentList());

selectorFragments = &nthChildOfSelectorInfo.selectorList.last();

}

VisitedMode ignoreVisitedMode = VisitedMode::None;

FunctionType functionType = constructFragments(subselector, selectorContext, *selectorFragments, FragmentsLevel::InFunctionalPseudoType, positionInRootFragments, visitedMatchEnabled, ignoreVisitedMode, PseudoElementMatchingBehavior::NeverMatch);

ASSERT_WITH_MESSAGE(ignoreVisitedMode == VisitedMode::None, ":visited is disabled in the functional pseudo classes");

switch (functionType) {

case FunctionType::SimpleSelectorChecker:

case FunctionType::SelectorCheckerWithCheckingContext:

break;

case FunctionType::CannotMatchAnything:

continue;

case FunctionType::CannotCompile:

return FunctionType::CannotCompile;

}

globalFunctionType = mostRestrictiveFunctionType(globalFunctionType, functionType);

selectorFragments = nullptr;

}

// If there is still a SelectorFragmentList open, the last Fragment(s) cannot match anything,

// we have one FragmentList too many in our selector list.

if (selectorFragments)

nthChildOfSelectorInfo.selectorList.removeLast();

if (nthChildOfSelectorInfo.selectorList.isEmpty())

return FunctionType::CannotMatchAnything;

filteredCases.append(nthChildOfSelectorInfo);

return globalFunctionType;

}

if (b == 1 && a <= 0)

pseudoClasses.add(firstMatchAlternative);

else

simpleCases.append(std::pair<int, int>(a, b));

if (selectorContext == SelectorContext::QuerySelector)

return FunctionType::SimpleSelectorChecker;

return FunctionType::SelectorCheckerWithCheckingContext;

}

JSC_DEFINE_JIT_OPERATION(operationIsAutofilled, bool, (const Element& element))

{

return isAutofilled(element);

}

JSC_DEFINE_JIT_OPERATION(operationIsAutofilledAndObscured, bool, (const Element& element))

{

return isAutofilledAndObscured(element);

}

JSC_DEFINE_JIT_OPERATION(operationIsAutofilledStrongPassword, bool, (const Element& element))

{

return isAutofilledStrongPassword(element);

}

JSC_DEFINE_JIT_OPERATION(operationIsAutofilledStrongPasswordViewable, bool, (const Element& element))

{

return isAutofilledStrongPasswordViewable(element);

}

JSC_DEFINE_JIT_OPERATION(operationIsChecked, bool, (const Element& element))

{

return isChecked(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesDefaultPseudoClass, bool, (const Element& element))

{

return matchesDefaultPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesDisabledPseudoClass, bool, (const Element& element))

{

return matchesDisabledPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesEnabledPseudoClass, bool, (const Element& element))

{

return matchesEnabledPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationIsDefinedElement, bool, (const Element& element))

{

return isDefinedElement(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesFocusPseudoClass, bool, (const Element& element))

{

return matchesFocusPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesFocusVisiblePseudoClass, bool, (const Element& element))

{

return matchesFocusVisiblePseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesFocusWithinPseudoClass, bool, (const Element& element))

{

return matchesFocusWithinPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationIsMediaDocument, bool, (const Element& element))

{

return isMediaDocument(element);

}

JSC_DEFINE_JIT_OPERATION(operationIsInRange, bool, (const Element& element))

{

return isInRange(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesIndeterminatePseudoClass, bool, (const Element& element))

{

return matchesIndeterminatePseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationIsInvalid, bool, (const Element& element))

{

return isInvalid(element);

}

JSC_DEFINE_JIT_OPERATION(operationIsOptionalFormControl, bool, (const Element& element))

{

return isOptionalFormControl(element);

}

JSC_DEFINE_JIT_OPERATION(operationIsOutOfRange, bool, (const Element& element))

{

return isOutOfRange(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesReadOnlyPseudoClass, bool, (const Element& element))

{

return matchesReadOnlyPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesReadWritePseudoClass, bool, (const Element& element))

{

return matchesReadWritePseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationIsRequiredFormControl, bool, (const Element& element))

{

return isRequiredFormControl(element);

}

JSC_DEFINE_JIT_OPERATION(operationIsValid, bool, (const Element& element))

{

return isValid(element);

}

JSC_DEFINE_JIT_OPERATION(operationIsWindowInactive, bool, (const Element& element))

{

return isWindowInactive(element);

}

#if ENABLE(FULLSCREEN_API)

JSC_DEFINE_JIT_OPERATION(operationMatchesFullScreenPseudoClass, bool, (const Element& element))

{

return matchesFullScreenPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesFullScreenDocumentPseudoClass, bool, (const Element& element))

{

return matchesFullScreenDocumentPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesFullScreenAncestorPseudoClass, bool, (const Element& element))

{

return matchesFullScreenAncestorPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesFullScreenAnimatingFullScreenTransitionPseudoClass, bool, (const Element& element))

{

return matchesFullScreenAnimatingFullScreenTransitionPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesFullScreenControlsHiddenPseudoClass, bool, (const Element& element))

{

return matchesFullScreenControlsHiddenPseudoClass(element);

}

#endif

#if ENABLE(PICTURE_IN_PICTURE_API)

JSC_DEFINE_JIT_OPERATION(operationMatchesPictureInPicturePseudoClass, bool, (const Element& element))

{

return matchesPictureInPicturePseudoClass(element);

}

#endif

#if ENABLE(VIDEO)

JSC_DEFINE_JIT_OPERATION(operationMatchesFutureCuePseudoClass, bool, (const Element& element))

{

return matchesFutureCuePseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesPastCuePseudoClass, bool, (const Element& element))

{

return matchesPastCuePseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesPlayingPseudoClass, bool, (const Element& element))

{

return matchesPlayingPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesPausedPseudoClass, bool, (const Element& element))

{

return matchesPausedPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesSeekingPseudoClass, bool, (const Element& element))

{

return matchesSeekingPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesBufferingPseudoClass, bool, (const Element& element))

{

return matchesBufferingPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesStalledPseudoClass, bool, (const Element& element))

{

return matchesStalledPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesMutedPseudoClass, bool, (const Element& element))

{

return matchesMutedPseudoClass(element);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesVolumeLockedPseudoClass, bool, (const Element& element))

{

return matchesVolumeLockedPseudoClass(element);

}

#endif

#if ENABLE(ATTACHMENT_ELEMENT)

JSC_DEFINE_JIT_OPERATION(operationHasAttachment, bool, (const Element& element))

{

return hasAttachment(element);

}

#endif

JSC_DEFINE_JIT_OPERATION(operationMatchesLangPseudoClass, bool, (const Element& element, const Vector<AtomString>& argumentList))

{

return matchesLangPseudoClass(element, argumentList);

}

JSC_DEFINE_JIT_OPERATION(operationMatchesModalDialogPseudoClass, bool, (const Element& element))

{

return matchesModalDialogPseudoClass(element);

}

static inline FunctionType addPseudoClassType(const CSSSelector& selector, SelectorFragment& fragment, SelectorContext selectorContext, FragmentsLevel fragmentLevel, FragmentPositionInRootFragments positionInRootFragments, bool visitedMatchEnabled, VisitedMode& visitedMode, PseudoElementMatchingBehavior pseudoElementMatchingBehavior)

{

CSSSelector::PseudoClassType type = selector.pseudoClassType();

switch (type) {

// Unoptimized pseudo selector. They are just function call to a simple testing function.

case CSSSelector::PseudoClassAutofill:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationIsAutofilled));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassAutofillAndObscured:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationIsAutofilledAndObscured));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassAutofillStrongPassword:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationIsAutofilledStrongPassword));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassAutofillStrongPasswordViewable:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationIsAutofilledStrongPasswordViewable));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassChecked:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationIsChecked));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassDefault:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesDefaultPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassDisabled:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesDisabledPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassEnabled:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesEnabledPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassDefined:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationIsDefinedElement));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassFocus:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesFocusPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassFocusVisible:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesFocusVisiblePseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassFocusWithin:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesFocusWithinPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassFullPageMedia:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationIsMediaDocument));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassInRange:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationIsInRange));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassIndeterminate:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesIndeterminatePseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassInvalid:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationIsInvalid));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassOptional:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationIsOptionalFormControl));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassOutOfRange:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationIsOutOfRange));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassReadOnly:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesReadOnlyPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassReadWrite:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesReadWritePseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassRequired:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationIsRequiredFormControl));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassValid:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationIsValid));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassWindowInactive:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationIsWindowInactive));

return FunctionType::SimpleSelectorChecker;

#if ENABLE(FULLSCREEN_API)

case CSSSelector::PseudoClassFullScreen:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesFullScreenPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassFullScreenDocument:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesFullScreenDocumentPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassFullScreenAncestor:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesFullScreenAncestorPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassAnimatingFullScreenTransition:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesFullScreenAnimatingFullScreenTransitionPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassFullScreenControlsHidden:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesFullScreenControlsHiddenPseudoClass));

return FunctionType::SimpleSelectorChecker;

#endif

#if ENABLE(PICTURE_IN_PICTURE_API)

case CSSSelector::PseudoClassPictureInPicture:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesPictureInPicturePseudoClass));

return FunctionType::SimpleSelectorChecker;

#endif

#if ENABLE(VIDEO)

case CSSSelector::PseudoClassFuture:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesFutureCuePseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassPast:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesPastCuePseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassPlaying:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesPlayingPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassPaused:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesPausedPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassSeeking:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesSeekingPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassBuffering:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesBufferingPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassStalled:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesStalledPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassMuted:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesMutedPseudoClass));

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassVolumeLocked:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesVolumeLockedPseudoClass));

return FunctionType::SimpleSelectorChecker;

#endif

#if ENABLE(ATTACHMENT_ELEMENT)

case CSSSelector::PseudoClassHasAttachment:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationHasAttachment));

return FunctionType::SimpleSelectorChecker;

#endif

case CSSSelector::PseudoClassModalDialog:

fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr<JSC::OperationPtrTag>(operationMatchesModalDialogPseudoClass));

return FunctionType::SimpleSelectorChecker;

// These pseudo-classes only have meaning with scrollbars.

case CSSSelector::PseudoClassHorizontal:

case CSSSelector::PseudoClassVertical:

case CSSSelector::PseudoClassDecrement:

case CSSSelector::PseudoClassIncrement:

case CSSSelector::PseudoClassStart:

case CSSSelector::PseudoClassEnd:

case CSSSelector::PseudoClassDoubleButton:

case CSSSelector::PseudoClassSingleButton:

case CSSSelector::PseudoClassNoButton:

case CSSSelector::PseudoClassCornerPresent:

return FunctionType::CannotMatchAnything;

// FIXME: Compile these pseudoclasses, too!

case CSSSelector::PseudoClassFirstOfType:

case CSSSelector::PseudoClassLastOfType:

case CSSSelector::PseudoClassOnlyOfType:

case CSSSelector::PseudoClassNthOfType:

case CSSSelector::PseudoClassNthLastOfType:

case CSSSelector::PseudoClassDrag:

case CSSSelector::PseudoClassHas:

case CSSSelector::PseudoClassRelativeScope:

#if ENABLE(CSS_SELECTORS_LEVEL4)

case CSSSelector::PseudoClassDir:

case CSSSelector::PseudoClassRole:

#endif

return FunctionType::CannotCompile;

// Optimized pseudo selectors.

case CSSSelector::PseudoClassAnyLink:

case CSSSelector::PseudoClassLink:

case CSSSelector::PseudoClassRoot:

case CSSSelector::PseudoClassTarget:

fragment.pseudoClasses.add(type);

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassAnyLinkDeprecated:

fragment.pseudoClasses.add(CSSSelector::PseudoClassAnyLink);

return FunctionType::SimpleSelectorChecker;

case CSSSelector::PseudoClassVisited:

// Determine this :visited cannot match anything statically.

if (!visitedMatchEnabled)

return FunctionType::CannotMatchAnything;

// Inside functional pseudo class except for :not, :visited never matches.

// And in the case inside :not, returning CannotMatchAnything indicates that :not(:visited) can match over anything.

if (fragmentLevel == FragmentsLevel::InFunctionalPseudoType)

return FunctionType::CannotMatchAnything;

fragment.pseudoClasses.add(type);