WTF_MAKE_NONCOPYABLE(AccessCase);

WTF_MAKE_FAST_ALLOCATED;

enum AccessType {

Load,

Transition,

Replace,

Miss,

Getter,

Setter,

CustomGetter,

CustomSetter,

InHit,

InMiss,

ArrayLength,

StringLength

};

static bool isGet(AccessType type)

{

switch (type) {

case Transition:

case Replace:

case Setter:

case CustomSetter:

case InHit:

case InMiss:

return false;

case Load:

case Miss:

case Getter:

case CustomGetter:

case ArrayLength:

case StringLength:

return true;

}

}

static bool isPut(AccessType type)

{

switch (type) {

case Load:

case Miss:

case Getter:

case CustomGetter:

case InHit:

case InMiss:

case ArrayLength:

case StringLength:

return false;

case Transition:

case Replace:

case Setter:

case CustomSetter:

return true;

}

}

static bool isIn(AccessType type)

{

switch (type) {

case Load:

case Miss:

case Getter:

case CustomGetter:

case Transition:

case Replace:

case Setter:

case CustomSetter:

case ArrayLength:

case StringLength:

return false;

case InHit:

case InMiss:

return true;

}

}

static std::unique_ptr<AccessCase> get(

VM&, JSCell* owner, AccessType, PropertyOffset, Structure*,

const ObjectPropertyConditionSet& = ObjectPropertyConditionSet(),

bool viaProxy = false,

WatchpointSet* additionalSet = nullptr,

PropertySlot::GetValueFunc = nullptr,

JSObject* customSlotBase = nullptr);

static std::unique_ptr<AccessCase> replace(VM&, JSCell* owner, Structure*, PropertyOffset);

static std::unique_ptr<AccessCase> transition(

VM&, JSCell* owner, Structure* oldStructure, Structure* newStructure, PropertyOffset,

const ObjectPropertyConditionSet& = ObjectPropertyConditionSet());

static std::unique_ptr<AccessCase> setter(

VM&, JSCell* owner, AccessType, Structure*, PropertyOffset,

const ObjectPropertyConditionSet&, PutPropertySlot::PutValueFunc = nullptr,

JSObject* customSlotBase = nullptr);

static std::unique_ptr<AccessCase> in(

VM&, JSCell* owner, AccessType, Structure*,

const ObjectPropertyConditionSet& = ObjectPropertyConditionSet());

static std::unique_ptr<AccessCase> getLength(VM&, JSCell* owner, AccessType);

static std::unique_ptr<AccessCase> fromStructureStubInfo(VM&, JSCell* owner, StructureStubInfo&);

~AccessCase();

std::unique_ptr<AccessCase> clone() const;

AccessType type() const { return m_type; }

PropertyOffset offset() const { return m_offset; }

bool viaProxy() const { return m_rareData ? m_rareData->viaProxy : false; }

Structure* structure() const

{

if (m_type == Transition)

return m_structure->previousID();

return m_structure.get();

}

bool guardedByStructureCheck() const;

Structure* newStructure() const

{

ASSERT(m_type == Transition);

return m_structure.get();

}

ObjectPropertyConditionSet conditionSet() const { return m_conditionSet; }

WatchpointSet* additionalSet() const

{

return m_rareData ? m_rareData->additionalSet.get() : nullptr;

}

JSObject* customSlotBase() const

{

return m_rareData ? m_rareData->customSlotBase.get() : nullptr;

}

JSObject* alternateBase() const;

bool doesCalls() const

{

switch (type()) {

case Getter:

case Setter:

case CustomGetter:

case CustomSetter:

return true;

default:

return false;

}

}

CallLinkInfo* callLinkInfo() const

{

if (!m_rareData)

return nullptr;

return m_rareData->callLinkInfo.get();

}

// If this method returns true, then it's a good idea to remove 'other' from the access once 'this'

// is added. This method assumes that in case of contradictions, 'this' represents a newer, and so

// more useful, truth. This method can be conservative; it will return false when it doubt.

bool canReplace(const AccessCase& other);

void dump(PrintStream& out) const;

friend class CodeBlock;

friend class PolymorphicAccess;

AccessCase();

bool visitWeak(VM&) const;

// Fall through on success. Two kinds of failures are supported: fall-through, which means that we

// should try a different case; and failure, which means that this was the right case but it needs

// help from the slow path.

void generateWithGuard(AccessGenerationState&, MacroAssembler::JumpList& fallThrough);

// Fall through on success, add a jump to the failure list on failure.

void generate(AccessGenerationState&);

AccessType m_type { Load };

PropertyOffset m_offset { invalidOffset };

// Usually this is the structure that we expect the base object to have. But, this is the *new*

// structure for a transition and we rely on the fact that it has a strong reference to the old

// structure. For proxies, this is the structure of the object behind the proxy.

WriteBarrier<Structure> m_structure;

ObjectPropertyConditionSet m_conditionSet;

class RareData {

WTF_MAKE_FAST_ALLOCATED;

public:

RareData()

: viaProxy(false)

{

customAccessor.opaque = nullptr;

}

bool viaProxy;

RefPtr<WatchpointSet> additionalSet;

std::unique_ptr<CallLinkInfo> callLinkInfo;

union {

PropertySlot::GetValueFunc getter;

PutPropertySlot::PutValueFunc setter;

void* opaque;

} customAccessor;

WriteBarrier<JSObject> customSlotBase;

};

std::unique_ptr<RareData> m_rareData;

WTF_MAKE_NONCOPYABLE(PolymorphicAccess);

WTF_MAKE_FAST_ALLOCATED;

PolymorphicAccess();

~PolymorphicAccess();

// This may return null, in which case the old stub routine is left intact. You are required to

// pass a vector of non-null access cases. This will prune the access cases by rejecting any case

// in the list that is subsumed by a later case in the list.

MacroAssemblerCodePtr regenerateWithCases(

VM&, CodeBlock*, StructureStubInfo&, const Identifier&, Vector<std::unique_ptr<AccessCase>>);

MacroAssemblerCodePtr regenerateWithCase(

VM&, CodeBlock*, StructureStubInfo&, const Identifier&, std::unique_ptr<AccessCase>);

bool isEmpty() const { return m_list.isEmpty(); }

unsigned size() const { return m_list.size(); }

const AccessCase& at(unsigned i) const { return *m_list[i]; }

const AccessCase& operator[](unsigned i) const { return *m_list[i]; }

// If this returns false then we are requesting a reset of the owning StructureStubInfo.

bool visitWeak(VM&) const;

void dump(PrintStream& out) const;

friend class AccessCase;

friend class CodeBlock;

friend struct AccessGenerationState;

typedef Vector<std::unique_ptr<AccessCase>, 2> ListType;

MacroAssemblerCodePtr regenerate(

VM&, CodeBlock*, StructureStubInfo&, const Identifier&, ListType& cases);

ListType m_list;

RefPtr<JITStubRoutine> m_stubRoutine;

std::unique_ptr<WatchpointsOnStructureStubInfo> m_watchpoints;