diff options
Diffstat (limited to 'lib/AsmJit/Compiler.h')
| -rw-r--r-- | lib/AsmJit/Compiler.h | 863 |
1 files changed, 863 insertions, 0 deletions
diff --git a/lib/AsmJit/Compiler.h b/lib/AsmJit/Compiler.h new file mode 100644 index 0000000..7d44a43 --- /dev/null +++ b/lib/AsmJit/Compiler.h @@ -0,0 +1,863 @@ +// AsmJit - Complete JIT Assembler for C++ Language. + +// Copyright (c) 2008-2010, Petr Kobalicek <kobalicek.petr@gmail.com> +// +// Permission is hereby granted, free of charge, to any person +// obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without +// restriction, including without limitation the rights to use, +// copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following +// conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. + +// [Guard] +#ifndef _ASMJIT_COMPILER_H +#define _ASMJIT_COMPILER_H + +// [Dependencies] +#include "Build.h" +#include "Defs.h" +#include "Operand.h" +#include "Util.h" + +// [Api-Begin] +#include "ApiBegin.h" + +namespace AsmJit { + +// ============================================================================ +// [Forward Declarations] +// ============================================================================ + +struct Assembler; +struct Compiler; +struct CompilerContext; +struct CompilerCore; +struct CompilerIntrinsics; + +struct FunctionDefinition; + +struct ForwardJumpData; + +struct VarData; +struct VarAllocRecord; +struct StateData; + +struct Emittable; +struct EAlign; +struct ECall; +struct EComment; +struct EData; +struct EEpilog; +struct EFunction; +struct EFunctionEnd; +struct EInstruction; +struct EJmp; +struct EProlog; +struct ERet; + +// ============================================================================ +// [AsmJit::TypeToId] +// ============================================================================ + +#if !defined(ASMJIT_NODOC) + +#if defined(ASMJIT_HAS_PARTIAL_TEMPLATE_SPECIALIZATION) + +template<typename T> +struct TypeToId +{ +#if defined(ASMJIT_NODOC) + enum { Id = INVALID_VALUE }; +#endif // ASMJIT_NODOC +}; + +template<typename T> +struct TypeToId<T*> { enum { Id = VARIABLE_TYPE_INTPTR }; }; + +#else + +// Same trict is used in Qt, Boost, Fog and all other libraries that need +// something similar. +// +// It's easy. It's needed to use sizeof() to determine the size +// of return value of this function. If size will be sizeof(char) +// (this is our type) then type is pointer, otherwise it's not. +template<typename T> +char TypeToId_NoPtiHelper(T*(*)()); +// And specialization. +void* TypeToId_NoPtiHelper(...); + +template<typename T> +struct TypeToId +{ + // TypeInfo constants + enum + { + // This is the hackery result. + Id = (sizeof(char) == sizeof( TypeToId_NoPtiHelper((T(*)())0) ) + ? VARIABLE_TYPE_INTPTR + : INVALID_VALUE) + }; +}; + +#endif // ASMJIT_HAS_PARTIAL_TEMPLATE_SPECIALIZATION + +#define ASMJIT_DECLARE_TYPE_AS_ID(__T__, __Id__) \ + template<> \ + struct TypeToId<__T__> { enum { Id = __Id__ }; } + +// Declare void type and alternative. +struct Void {}; +ASMJIT_DECLARE_TYPE_AS_ID(void, INVALID_VALUE); +ASMJIT_DECLARE_TYPE_AS_ID(Void, INVALID_VALUE); + +#endif // ASMJIT_NODOC + +// ============================================================================ +// [AsmJit::Function Builder] +// ============================================================================ + +struct FunctionDefinition +{ + //! @brief Get function arguments IDs. + inline const uint32_t* getArguments() const + { + return _arguments; + } + + //! @brief Get function arguments count. + inline uint32_t getArgumentsCount() const + { + return _argumentsCount; + } + + inline uint32_t getArgument(uint32_t id) const + { + ASMJIT_ASSERT(id < _argumentsCount); + return _arguments[id]; + } + + //! @brief Get function return value. + inline uint32_t getReturnValue() const + { + return _returnValue; + } + +protected: + inline void _setDefinition(const uint32_t* arguments, uint32_t argumentsCount, uint32_t returnValue) + { + _arguments = arguments; + _argumentsCount = argumentsCount; + _returnValue = returnValue; + } + + const uint32_t* _arguments; + uint32_t _argumentsCount; + uint32_t _returnValue; +}; + +//! @brief Custom function builder for up to 32 function arguments. +struct FunctionBuilderX : public FunctionDefinition +{ + inline FunctionBuilderX() + { + _setDefinition(_argumentsData, 0, INVALID_VALUE); + } + + template<typename T> + inline void addArgument() + { + addArgumentRaw(TypeToId<ASMJIT_TYPE_TO_TYPE(T)>::Id); + } + + template<typename T> + inline void setArgument(uint32_t id) + { + setArgumentRaw(id, TypeToId<ASMJIT_TYPE_TO_TYPE(T)>::Id); + } + + template<typename T> + inline void setReturnValue() + { + setReturnValueRaw(TypeToId<ASMJIT_TYPE_TO_TYPE(T)>::Id); + } + + inline void addArgumentRaw(uint32_t type) + { + ASMJIT_ASSERT(_argumentsCount < FUNC_MAX_ARGS); + _argumentsData[_argumentsCount++] = type; + } + + inline void setArgumentRaw(uint32_t id, uint32_t type) + { + ASMJIT_ASSERT(id < _argumentsCount); + _argumentsData[id] = type; + } + + inline void setReturnValueRaw(uint32_t returnValue) + { + _returnValue = returnValue; + } + +protected: + uint32_t _argumentsData[FUNC_MAX_ARGS]; +}; + +//! @brief Class used to build function without arguments. +template<typename RET> +struct FunctionBuilder0 : public FunctionDefinition +{ + inline FunctionBuilder0() + { + _setDefinition(NULL, 0, TypeToId<RET>::Id); + } +}; + +//! @brief Class used to build function with 1 argument. +template<typename RET, typename P0> +struct FunctionBuilder1 : public FunctionDefinition +{ + inline FunctionBuilder1() + { + static const uint32_t args[] = + { + TypeToId<P0>::Id + }; + _setDefinition(args, ASMJIT_ARRAY_SIZE(args), TypeToId<RET>::Id); + } +}; + +//! @brief Class used to build function with 2 arguments. +template<typename RET, typename P0, typename P1> +struct FunctionBuilder2 : public FunctionDefinition +{ + inline FunctionBuilder2() + { + static const uint32_t args[] = + { + TypeToId<P0>::Id, + TypeToId<P1>::Id + }; + _setDefinition(args, ASMJIT_ARRAY_SIZE(args), TypeToId<RET>::Id); + } +}; + +//! @brief Class used to build function with 3 arguments. +template<typename RET, typename P0, typename P1, typename P2> +struct FunctionBuilder3 : public FunctionDefinition +{ + inline FunctionBuilder3() + { + static const uint32_t args[] = + { + TypeToId<P0>::Id, + TypeToId<P1>::Id, + TypeToId<P2>::Id + }; + _setDefinition(args, ASMJIT_ARRAY_SIZE(args), TypeToId<RET>::Id); + } +}; + +//! @brief Class used to build function with 4 arguments. +template<typename RET, typename P0, typename P1, typename P2, typename P3> +struct FunctionBuilder4 : public FunctionDefinition +{ + inline FunctionBuilder4() + { + static const uint32_t args[] = + { + TypeToId<P0>::Id, + TypeToId<P1>::Id, + TypeToId<P2>::Id, + TypeToId<P3>::Id + }; + _setDefinition(args, ASMJIT_ARRAY_SIZE(args), TypeToId<RET>::Id); + } +}; + +//! @brief Class used to build function with 5 arguments. +template<typename RET, typename P0, typename P1, typename P2, typename P3, typename P4> +struct FunctionBuilder5 : public FunctionDefinition +{ + inline FunctionBuilder5() + { + static const uint32_t args[] = + { + TypeToId<P0>::Id, + TypeToId<P1>::Id, + TypeToId<P2>::Id, + TypeToId<P3>::Id, + TypeToId<P4>::Id + }; + _setDefinition(args, ASMJIT_ARRAY_SIZE(args), TypeToId<RET>::Id); + } +}; + +//! @brief Class used to build function with 6 arguments. +template<typename RET, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5> +struct FunctionBuilder6 : public FunctionDefinition +{ + inline FunctionBuilder6() + { + static const uint32_t args[] = + { + TypeToId<P0>::Id, + TypeToId<P1>::Id, + TypeToId<P2>::Id, + TypeToId<P3>::Id, + TypeToId<P4>::Id, + TypeToId<P5>::Id + }; + _setDefinition(args, ASMJIT_ARRAY_SIZE(args), TypeToId<RET>::Id); + } +}; + +//! @brief Class used to build function with 7 arguments. +template<typename RET, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6> +struct FunctionBuilder7 : public FunctionDefinition +{ + inline FunctionBuilder7() + { + static const uint32_t args[] = + { + TypeToId<P0>::Id, + TypeToId<P1>::Id, + TypeToId<P2>::Id, + TypeToId<P3>::Id, + TypeToId<P4>::Id, + TypeToId<P5>::Id, + TypeToId<P6>::Id + }; + _setDefinition(args, ASMJIT_ARRAY_SIZE(args), TypeToId<RET>::Id); + } +}; + +//! @brief Class used to build function with 8 arguments. +template<typename RET, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7> +struct FunctionBuilder8 : public FunctionDefinition +{ + inline FunctionBuilder8() + { + static const uint32_t args[] = + { + TypeToId<P0>::Id, + TypeToId<P1>::Id, + TypeToId<P2>::Id, + TypeToId<P3>::Id, + TypeToId<P4>::Id, + TypeToId<P5>::Id, + TypeToId<P6>::Id, + TypeToId<P7>::Id + }; + _setDefinition(args, ASMJIT_ARRAY_SIZE(args), TypeToId<RET>::Id); + } +}; + +//! @brief Class used to build function with 9 arguments. +template<typename RET, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8> +struct FunctionBuilder9 : public FunctionDefinition +{ + inline FunctionBuilder9() + { + static const uint32_t args[] = + { + TypeToId<P0>::Id, + TypeToId<P1>::Id, + TypeToId<P2>::Id, + TypeToId<P3>::Id, + TypeToId<P4>::Id, + TypeToId<P5>::Id, + TypeToId<P6>::Id, + TypeToId<P7>::Id, + TypeToId<P8>::Id + }; + _setDefinition(args, ASMJIT_ARRAY_SIZE(args), TypeToId<RET>::Id); + } +}; + +//! @brief Class used to build function with 10 arguments. +template<typename RET, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9> +struct FunctionBuilder10 : public FunctionDefinition +{ + inline FunctionBuilder10() + { + static const uint32_t args[] = + { + TypeToId<P0>::Id, + TypeToId<P1>::Id, + TypeToId<P2>::Id, + TypeToId<P3>::Id, + TypeToId<P4>::Id, + TypeToId<P5>::Id, + TypeToId<P6>::Id, + TypeToId<P7>::Id, + TypeToId<P8>::Id, + TypeToId<P9>::Id + }; + _setDefinition(args, ASMJIT_ARRAY_SIZE(args), TypeToId<RET>::Id); + } +}; + +// ============================================================================ +// [AsmJit::Emittable] +// ============================================================================ + +//! @brief Emmitable. +//! +//! Emittable is object that can emit single or more instructions. To +//! create your custom emittable it's needed to override the abstract virtual +//! method @c emit(). +//! +//! When you are finished serializing instructions to the @c Compiler and you +//! call @c Compiler::make(), it will first call @c prepare() method for each +//! emittable in list, then @c translate(), @c emit() and @c post() is the last. +//! Prepare can be used to calculate something that can be only calculated when +//! emitting instructions is finished (for example @c Function uses @c prepare() +//! to relocate memory home for all memory/spilled variables). The @c emit() should +//! be used to emit instruction or multiple instructions into @a Assembler stream, +//! and the @c post() is here to allow emitting embedded data (after function +//! declaration), etc. +struct ASMJIT_API Emittable +{ + // -------------------------------------------------------------------------- + // [Construction / Destruction] + // -------------------------------------------------------------------------- + + //! @brief Create new emittable. + //! + //! Never create @c Emittable by @c new operator or on the stack, use + //! @c Compiler::newObject template to do that. + Emittable(Compiler* c, uint32_t type) ASMJIT_NOTHROW; + + //! @brief Destroy emittable. + //! + //! @note Never destroy emittable using @c delete keyword, @c Compiler + //! manages all emittables in internal memory pool and it will destroy + //! all emittables after you destroy it. + virtual ~Emittable() ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Emit and Helpers] + // -------------------------------------------------------------------------- + + //! @brief Step 1. Extract emittable variables, update statistics, ... + virtual void prepare(CompilerContext& cc) ASMJIT_NOTHROW; + //! @brief Step 2. Translate instruction, alloc variables, ... + virtual Emittable* translate(CompilerContext& cc) ASMJIT_NOTHROW; + //! @brief Step 3. Emit to @c Assembler. + virtual void emit(Assembler& a) ASMJIT_NOTHROW; + //! @brief Step 4. Last post step (verify, add data, etc). + virtual void post(Assembler& a) ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Utilities] + // -------------------------------------------------------------------------- + + //! @brief Get maximum size in bytes of this emittable (in binary). + virtual int getMaxSize() const ASMJIT_NOTHROW; + + //! @brief Try to unuse the variable @a. + //! + //! Returns @c true only if the variable will be unused by the instruction, + //! otherwise @c false is returned. + virtual bool _tryUnuseVar(VarData* v) ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Compiler] + // -------------------------------------------------------------------------- + + //! @brief Get associated compiler instance. + inline Compiler* getCompiler() const ASMJIT_NOTHROW { return _compiler; } + + // -------------------------------------------------------------------------- + // [Type / Offset] + // -------------------------------------------------------------------------- + + //! @brief Get emittable type, see @c EMITTABLE_TYPE. + inline uint32_t getType() const ASMJIT_NOTHROW { return _type; } + + //! @brief Get whether the emittable was translated. + inline uint8_t isTranslated() const ASMJIT_NOTHROW { return _translated; } + + //! @brief Get emittable offset in the stream + //! + //! Emittable offset is not byte offset, each emittable increments offset by 1 + //! and this value is then used by register allocator. Emittable offset is + //! set by compiler by the register allocator, don't use it in your code. + inline uint32_t getOffset() const ASMJIT_NOTHROW { return _offset; } + + // -------------------------------------------------------------------------- + // [Emittables List] + // -------------------------------------------------------------------------- + + //! @brief Get previous emittable in list. + inline Emittable* getPrev() const ASMJIT_NOTHROW { return _prev; } + //! @brief Get next emittable in list. + inline Emittable* getNext() const ASMJIT_NOTHROW { return _next; } + + // -------------------------------------------------------------------------- + // [Comment] + // -------------------------------------------------------------------------- + + //! @brief Get comment string. + inline const char* getComment() const ASMJIT_NOTHROW { return _comment; } + + //! @brief Set comment string to @a str. + void setComment(const char* str) ASMJIT_NOTHROW; + + //! @brief Format comment string using @a fmt string and variable argument list. + void setCommentF(const char* fmt, ...) ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Protected] + // -------------------------------------------------------------------------- + +protected: + //! @brief Mark emittable as translated and return next. + inline Emittable* translated() ASMJIT_NOTHROW + { + ASMJIT_ASSERT(_translated == false); + + _translated = true; + return _next; + } + + // -------------------------------------------------------------------------- + // [Members] + // -------------------------------------------------------------------------- + + //! @brief Compiler where this emittable is connected to. + Compiler* _compiler; + + //! @brief Type of emittable, see @c EMITTABLE_TYPE. + uint8_t _type; + //! @brief Whether the emittable was translated, see @c translate(). + uint8_t _translated; + //! @brief Reserved flags for future use. + uint8_t _reserved0; + //! @brief Reserved flags for future use. + uint8_t _reserved1; + + //! @brief Emittable offset. + uint32_t _offset; + + //! @brief Previous emittable. + Emittable* _prev; + //! @brief Next emittable. + Emittable* _next; + + //! @brief Embedded comment string (also used by a @c Comment emittable). + const char* _comment; + +private: + friend struct CompilerCore; + + ASMJIT_DISABLE_COPY(Emittable) +}; + +// ============================================================================ +// [AsmJit::EDummy] +// ============================================================================ + +//! @brief Dummy emittable, used as a mark. +//! +//! This emittable does nothing and it's only used by @ref Compiler to mark +//! specific location in the code. +struct ASMJIT_API EDummy : public Emittable +{ + // -------------------------------------------------------------------------- + // [Construction / Destruction] + // -------------------------------------------------------------------------- + + //! @brief Create a new @ref EDummy instance. + EDummy(Compiler* c) ASMJIT_NOTHROW; + //! @brief Destroy the @ref EDummy instance. + virtual ~EDummy() ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Utilities] + // -------------------------------------------------------------------------- + + virtual int getMaxSize() const ASMJIT_NOTHROW; + +private: + ASMJIT_DISABLE_COPY(EDummy) +}; + +// ============================================================================ +// [AsmJit::EFunctionEnd] +// ============================================================================ + +//! @brief End of function. +//! +//! This emittable does nothing and it's only used by @ref Compiler to mark +//! specific location in the code. The @c EFunctionEnd is similar to @c EDummy, +//! except that it overrides @c translate() to return @c NULL. +struct ASMJIT_API EFunctionEnd : public EDummy +{ + // -------------------------------------------------------------------------- + // [Construction / Destruction] + // -------------------------------------------------------------------------- + + //! @brief Create a new @ref EDummy instance. + EFunctionEnd(Compiler* c) ASMJIT_NOTHROW; + //! @brief Destroy the @ref EDummy instance. + virtual ~EFunctionEnd() ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Emit and Helpers] + // -------------------------------------------------------------------------- + + virtual Emittable* translate(CompilerContext& cc) ASMJIT_NOTHROW; + +private: + ASMJIT_DISABLE_COPY(EFunctionEnd) +}; + +// ============================================================================ +// [AsmJit::EComment] +// ============================================================================ + +//! @brief Emittable used to emit comment into @c Assembler logger. +//! +//! Comments allows to comment your assembler stream for better debugging +//! and visualization what's happening. Comments are ignored if logger is +//! not set. +//! +//! Comment string can't be modified after comment was created. +struct ASMJIT_API EComment : public Emittable +{ + // -------------------------------------------------------------------------- + // [Construction / Destruction] + // -------------------------------------------------------------------------- + + //! @brief Create a new @ref EComment instance. + EComment(Compiler* c, const char* comment) ASMJIT_NOTHROW; + //! @brief Destroy the @ref EComment instance. + virtual ~EComment() ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Emit] + // -------------------------------------------------------------------------- + + virtual void emit(Assembler& a) ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Utilities] + // -------------------------------------------------------------------------- + + virtual int getMaxSize() const ASMJIT_NOTHROW; + +private: + friend struct CompilerCore; + + ASMJIT_DISABLE_COPY(EComment) +}; + +// ============================================================================ +// [AsmJit::EData] +// ============================================================================ + +//! @brief Emittable used to emit comment into @c Assembler logger. +//! +//! @note This class is always allocated by @c AsmJit::Compiler. +struct ASMJIT_API EData : public Emittable +{ + // -------------------------------------------------------------------------- + // [Construction / Destruction] + // -------------------------------------------------------------------------- + + //! @brief Create a new @ref EData instance. + EData(Compiler* c, const void* data, sysuint_t length) ASMJIT_NOTHROW; + //! @brief Destroy the @ref EData instance. + virtual ~EData() ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Emit] + // -------------------------------------------------------------------------- + + virtual void emit(Assembler& a) ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Utilities] + // -------------------------------------------------------------------------- + + virtual int getMaxSize() const ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Data] + // -------------------------------------------------------------------------- + + //! @brief Get pointer to embedded data. + uint8_t* getData() const ASMJIT_NOTHROW { return (uint8_t*)_data; } + + //! @brief Get length of embedded data. + sysuint_t getLength() const ASMJIT_NOTHROW { return _length; } + + // -------------------------------------------------------------------------- + // [Members] + // -------------------------------------------------------------------------- + +protected: + //! @brief Data length. + sysuint_t _length; + //! @brief Data buffer (that will be embedded to the assembler stream). + uint8_t _data[sizeof(void*)]; + +private: + friend struct CompilerCore; + + ASMJIT_DISABLE_COPY(EData) +}; + +// ============================================================================ +// [AsmJit::EAlign] +// ============================================================================ + +//! @brief Emittable used to align assembler code. +struct ASMJIT_API EAlign : public Emittable +{ + // -------------------------------------------------------------------------- + // [Construction / Destruction] + // -------------------------------------------------------------------------- + + //! @brief Create a new @ref EAlign instance. + EAlign(Compiler* c, uint32_t size = 0) ASMJIT_NOTHROW; + //! @brief Destroy the @ref EAlign instance. + virtual ~EAlign() ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Emit] + // -------------------------------------------------------------------------- + + virtual void emit(Assembler& a) ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Utilities] + // -------------------------------------------------------------------------- + + virtual int getMaxSize() const ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Align Size] + // -------------------------------------------------------------------------- + + //! @brief Get align size in bytes. + inline uint32_t getSize() const ASMJIT_NOTHROW { return _size; } + //! @brief Set align size in bytes to @a size. + inline void setSize(uint32_t size) ASMJIT_NOTHROW { _size = size; } + + // -------------------------------------------------------------------------- + // [Members] + // -------------------------------------------------------------------------- + +protected: + //! @brief Align size. + uint32_t _size; + +private: + friend struct CompilerCore; + + ASMJIT_DISABLE_COPY(EAlign) +}; + +// ============================================================================ +// [AsmJit::ETarget] +// ============================================================================ + +//! @brief Target - the bound label. +struct ASMJIT_API ETarget : public Emittable +{ + // -------------------------------------------------------------------------- + // [Construction / Destruction] + // -------------------------------------------------------------------------- + + //! @brief Create a new @ref ETarget instance. + ETarget(Compiler* c, const Label& target) ASMJIT_NOTHROW; + //! @brief Destroy the @ref ETarget instance. + virtual ~ETarget() ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Emit] + // -------------------------------------------------------------------------- + + virtual void prepare(CompilerContext& cc) ASMJIT_NOTHROW; + virtual Emittable* translate(CompilerContext& cc) ASMJIT_NOTHROW; + virtual void emit(Assembler& a) ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Utilities] + // -------------------------------------------------------------------------- + + virtual int getMaxSize() const ASMJIT_NOTHROW; + + // -------------------------------------------------------------------------- + // [Methods] + // -------------------------------------------------------------------------- + + //! @brief Return label bound to this target. + inline const Label& getLabel() const ASMJIT_NOTHROW { return _label; } + + //! @brief Get first jmp instruction. + inline EJmp* getFrom() const ASMJIT_NOTHROW { return _from; } + + //! @brief Get register allocator state for this target. + inline StateData* getState() const ASMJIT_NOTHROW { return _state; } + + //! @brief Get number of jumps to this target. + inline uint32_t getJumpsCount() const ASMJIT_NOTHROW { return _jumpsCount; } + + // -------------------------------------------------------------------------- + // [Members] + // -------------------------------------------------------------------------- + +protected: + //! @brief Label. + Label _label; + //! @brief First jump instruction that points to this target (label). + EJmp* _from; + //! @brief State at this location. + StateData* _state; + + //! @brief Count of jumps to this target (label). + uint32_t _jumpsCount; + +private: + friend struct CompilerContext; + friend struct CompilerCore; + friend struct EInstruction; + friend struct EJmp; + + ASMJIT_DISABLE_COPY(ETarget) +}; + +} // AsmJit namespace + +// [Api-End] +#include "ApiEnd.h" + +// ============================================================================ +// [Platform Specific] +// ============================================================================ + +// [X86 / X64] +#if defined(ASMJIT_X86) || defined(ASMJIT_X64) +#include "CompilerX86X64.h" +#endif // ASMJIT_X86 || ASMJIT_X64 + +// [Guard] +#endif // _ASMJIT_COMPILER_H |