#pragma once
#include "MacroAssemblerCodeRef.h"
#if ENABLE(ASSEMBLER)
namespace JSC {
enum class NearCallMode : uint8_t { Regular, Tail };
template<PtrTag> class CodeLocationInstruction;
template<PtrTag> class CodeLocationLabel;
template<PtrTag> class CodeLocationJump;
template<PtrTag> class CodeLocationCall;
template<PtrTag> class CodeLocationNearCall;
template<PtrTag> class CodeLocationDataLabelCompact;
template<PtrTag> class CodeLocationDataLabel32;
template<PtrTag> class CodeLocationDataLabelPtr;
template<PtrTag> class CodeLocationConvertibleLoad;
template<PtrTag tag>
class CodeLocationCommon : public MacroAssemblerCodePtr<tag> {
using Base = MacroAssemblerCodePtr<tag>;
public:
template<PtrTag resultTag = tag> CodeLocationInstruction<resultTag> instructionAtOffset(int offset);
template<PtrTag resultTag = tag> CodeLocationLabel<resultTag> labelAtOffset(int offset);
template<PtrTag resultTag = tag> CodeLocationJump<resultTag> jumpAtOffset(int offset);
template<PtrTag resultTag = tag> CodeLocationCall<resultTag> callAtOffset(int offset);
template<PtrTag resultTag = tag> CodeLocationNearCall<resultTag> nearCallAtOffset(int offset, NearCallMode);
template<PtrTag resultTag = tag> CodeLocationDataLabelPtr<resultTag> dataLabelPtrAtOffset(int offset);
template<PtrTag resultTag = tag> CodeLocationDataLabel32<resultTag> dataLabel32AtOffset(int offset);
template<PtrTag resultTag = tag> CodeLocationDataLabelCompact<resultTag> dataLabelCompactAtOffset(int offset);
template<PtrTag resultTag = tag> CodeLocationConvertibleLoad<resultTag> convertibleLoadAtOffset(int offset);
template<typename T = void*>
T dataLocation() const { return Base::template dataLocation<T>(); }
template<typename T, typename = std::enable_if_t<std::is_base_of<CodeLocationCommon<tag>, T>::value>>
operator T()
{
return T(MacroAssemblerCodePtr<tag>::createFromExecutableAddress(this->executableAddress()));
}
protected:
CodeLocationCommon()
{
}
CodeLocationCommon(MacroAssemblerCodePtr<tag> location)
: MacroAssemblerCodePtr<tag>(location)
{
}
};
template<PtrTag tag>
class CodeLocationInstruction : public CodeLocationCommon<tag> {
public:
CodeLocationInstruction() { }
explicit CodeLocationInstruction(MacroAssemblerCodePtr<tag> location)
: CodeLocationCommon<tag>(location) { }
explicit CodeLocationInstruction(void* location)
: CodeLocationCommon<tag>(MacroAssemblerCodePtr<tag>(location)) { }
};
template<PtrTag tag>
class CodeLocationLabel : public CodeLocationCommon<tag> {
public:
CodeLocationLabel() { }
explicit CodeLocationLabel(MacroAssemblerCodePtr<tag> location)
: CodeLocationCommon<tag>(location) { }
explicit CodeLocationLabel(void* location)
: CodeLocationCommon<tag>(MacroAssemblerCodePtr<tag>(location)) { }
template<PtrTag newTag>
CodeLocationLabel<newTag> retagged() { return CodeLocationLabel<newTag>(CodeLocationCommon<tag>::template retagged<newTag>()); }
template<typename T = void*>
T untaggedExecutableAddress() const { return CodeLocationCommon<tag>::template untaggedExecutableAddress<T>(); }
template<typename T = void*>
T dataLocation() const { return CodeLocationCommon<tag>::template dataLocation<T>(); }
};
template<PtrTag tag>
class CodeLocationJump : public CodeLocationCommon<tag> {
public:
CodeLocationJump() { }
explicit CodeLocationJump(MacroAssemblerCodePtr<tag> location)
: CodeLocationCommon<tag>(location) { }
explicit CodeLocationJump(void* location)
: CodeLocationCommon<tag>(MacroAssemblerCodePtr<tag>(location)) { }
template<PtrTag newTag>
CodeLocationJump<newTag> retagged() { return CodeLocationJump<newTag>(MacroAssemblerCodePtr<tag>::template retagged<newTag>()); }
};
template<PtrTag tag>
class CodeLocationCall : public CodeLocationCommon<tag> {
public:
CodeLocationCall() { }
explicit CodeLocationCall(MacroAssemblerCodePtr<tag> location)
: CodeLocationCommon<tag>(location) { }
explicit CodeLocationCall(void* location)
: CodeLocationCommon<tag>(MacroAssemblerCodePtr<tag>(location)) { }
template<PtrTag newTag>
CodeLocationCall<newTag> retagged() { return CodeLocationCall<newTag>(CodeLocationCommon<tag>::template retagged<newTag>()); }
};
template<PtrTag tag>
class CodeLocationNearCall : public CodeLocationCommon<tag> {
public:
CodeLocationNearCall() { }
explicit CodeLocationNearCall(MacroAssemblerCodePtr<tag> location, NearCallMode callMode)
: CodeLocationCommon<tag>(location), m_callMode(callMode) { }
explicit CodeLocationNearCall(void* location, NearCallMode callMode)
: CodeLocationCommon<tag>(MacroAssemblerCodePtr<tag>(location)), m_callMode(callMode) { }
NearCallMode callMode() { return m_callMode; }
private:
NearCallMode m_callMode { NearCallMode::Regular };
};
template<PtrTag tag>
class CodeLocationDataLabel32 : public CodeLocationCommon<tag> {
public:
CodeLocationDataLabel32() { }
explicit CodeLocationDataLabel32(MacroAssemblerCodePtr<tag> location)
: CodeLocationCommon<tag>(location) { }
explicit CodeLocationDataLabel32(void* location)
: CodeLocationCommon<tag>(MacroAssemblerCodePtr<tag>(location)) { }
};
template<PtrTag tag>
class CodeLocationDataLabelCompact : public CodeLocationCommon<tag> {
public:
CodeLocationDataLabelCompact() { }
explicit CodeLocationDataLabelCompact(MacroAssemblerCodePtr<tag> location)
: CodeLocationCommon<tag>(location) { }
explicit CodeLocationDataLabelCompact(void* location)
: CodeLocationCommon<tag>(MacroAssemblerCodePtr<tag>(location)) { }
};
template<PtrTag tag>
class CodeLocationDataLabelPtr : public CodeLocationCommon<tag> {
public:
CodeLocationDataLabelPtr() { }
explicit CodeLocationDataLabelPtr(MacroAssemblerCodePtr<tag> location)
: CodeLocationCommon<tag>(location) { }
explicit CodeLocationDataLabelPtr(void* location)
: CodeLocationCommon<tag>(MacroAssemblerCodePtr<tag>(location)) { }
};
template<PtrTag tag>
class CodeLocationConvertibleLoad : public CodeLocationCommon<tag> {
public:
CodeLocationConvertibleLoad() { }
explicit CodeLocationConvertibleLoad(MacroAssemblerCodePtr<tag> location)
: CodeLocationCommon<tag>(location) { }
explicit CodeLocationConvertibleLoad(void* location)
: CodeLocationCommon<tag>(MacroAssemblerCodePtr<tag>(location)) { }
};
template<PtrTag tag>
template<PtrTag resultTag>
inline CodeLocationInstruction<resultTag> CodeLocationCommon<tag>::instructionAtOffset(int offset)
{
ASSERT_VALID_CODE_OFFSET(offset);
return CodeLocationInstruction<resultTag>(tagCodePtr<resultTag>(dataLocation<char*>() + offset));
}
template<PtrTag tag>
template<PtrTag resultTag>
inline CodeLocationLabel<resultTag> CodeLocationCommon<tag>::labelAtOffset(int offset)
{
ASSERT_VALID_CODE_OFFSET(offset);
return CodeLocationLabel<resultTag>(tagCodePtr<resultTag>(dataLocation<char*>() + offset));
}
template<PtrTag tag>
template<PtrTag resultTag>
inline CodeLocationJump<resultTag> CodeLocationCommon<tag>::jumpAtOffset(int offset)
{
ASSERT_VALID_CODE_OFFSET(offset);
return CodeLocationJump<resultTag>(tagCodePtr<resultTag>(dataLocation<char*>() + offset));
}
template<PtrTag tag>
template<PtrTag resultTag>
inline CodeLocationCall<resultTag> CodeLocationCommon<tag>::callAtOffset(int offset)
{
ASSERT_VALID_CODE_OFFSET(offset);
return CodeLocationCall<resultTag>(tagCodePtr<resultTag>(dataLocation<char*>() + offset));
}
template<PtrTag tag>
template<PtrTag resultTag>
inline CodeLocationNearCall<resultTag> CodeLocationCommon<tag>::nearCallAtOffset(int offset, NearCallMode callMode)
{
ASSERT_VALID_CODE_OFFSET(offset);
return CodeLocationNearCall<resultTag>(tagCodePtr<resultTag>(dataLocation<char*>() + offset), callMode);
}
template<PtrTag tag>
template<PtrTag resultTag>
inline CodeLocationDataLabelPtr<resultTag> CodeLocationCommon<tag>::dataLabelPtrAtOffset(int offset)
{
ASSERT_VALID_CODE_OFFSET(offset);
return CodeLocationDataLabelPtr<resultTag>(tagCodePtr<resultTag>(dataLocation<char*>() + offset));
}
template<PtrTag tag>
template<PtrTag resultTag>
inline CodeLocationDataLabel32<resultTag> CodeLocationCommon<tag>::dataLabel32AtOffset(int offset)
{
ASSERT_VALID_CODE_OFFSET(offset);
return CodeLocationDataLabel32<resultTag>(tagCodePtr<resultTag>(dataLocation<char*>() + offset));
}
template<PtrTag tag>
template<PtrTag resultTag>
inline CodeLocationDataLabelCompact<resultTag> CodeLocationCommon<tag>::dataLabelCompactAtOffset(int offset)
{
ASSERT_VALID_CODE_OFFSET(offset);
return CodeLocationDataLabelCompact<resultTag>(tagCodePtr<resultTag>(dataLocation<char*>() + offset));
}
template<PtrTag tag>
template<PtrTag resultTag>
inline CodeLocationConvertibleLoad<resultTag> CodeLocationCommon<tag>::convertibleLoadAtOffset(int offset)
{
ASSERT_VALID_CODE_OFFSET(offset);
return CodeLocationConvertibleLoad<resultTag>(tagCodePtr<resultTag>(dataLocation<char*>() + offset));
}
}
#endif // ENABLE(ASSEMBLER)