// AsmJit - Machine code generation for C++ // // * Official AsmJit Home Page: https://asmjit.com // * Official Github Repository: https://github.com/asmjit/asmjit // // Copyright (c) 2008-2020 The AsmJit Authors // // This software is provided 'as-is', without any express or implied // warranty. In no event will the authors be held liable for any damages // arising from the use of this software. // // Permission is granted to anyone to use this software for any purpose, // including commercial applications, and to alter it and redistribute it // freely, subject to the following restrictions: // // 1. The origin of this software must not be misrepresented; you must not // claim that you wrote the original software. If you use this software // in a product, an acknowledgment in the product documentation would be // appreciated but is not required. // 2. Altered source versions must be plainly marked as such, and must not be // misrepresented as being the original software. // 3. This notice may not be removed or altered from any source distribution. #ifndef ASMJIT_CORE_CODEHOLDER_H_INCLUDED #define ASMJIT_CORE_CODEHOLDER_H_INCLUDED #include "../core/archtraits.h" #include "../core/codebuffer.h" #include "../core/datatypes.h" #include "../core/errorhandler.h" #include "../core/operand.h" #include "../core/string.h" #include "../core/support.h" #include "../core/target.h" #include "../core/zone.h" #include "../core/zonehash.h" #include "../core/zonestring.h" #include "../core/zonetree.h" #include "../core/zonevector.h" ASMJIT_BEGIN_NAMESPACE //! \addtogroup asmjit_core //! \{ // ============================================================================ // [Forward Declarations] // ============================================================================ class BaseEmitter; class CodeHolder; class LabelEntry; class Logger; // ============================================================================ // [asmjit::AlignMode] // ============================================================================ //! Align mode. enum AlignMode : uint32_t { //! Align executable code. kAlignCode = 0, //! Align non-executable code. kAlignData = 1, //! Align by a sequence of zeros. kAlignZero = 2, //! Count of alignment modes. kAlignCount = 3 }; // ============================================================================ // [asmjit::Expression] // ============================================================================ //! Expression node that can reference constants, labels, and another expressions. struct Expression { //! Operation type. enum OpType : uint8_t { //! Addition. kOpAdd = 0, //! Subtraction. kOpSub = 1, //! Multiplication kOpMul = 2, //! Logical left shift. kOpSll = 3, //! Logical right shift. kOpSrl = 4, //! Arithmetic right shift. kOpSra = 5 }; //! Type of \ref Value. enum ValueType : uint8_t { //! No value or invalid. kValueNone = 0, //! Value is 64-bit unsigned integer (constant). kValueConstant = 1, //! Value is \ref LabelEntry, which references a \ref Label. kValueLabel = 2, //! Value is \ref Expression kValueExpression = 3 }; //! Expression value. union Value { //! Constant. uint64_t constant; //! Pointer to another expression. Expression* expression; //! Poitner to \ref LabelEntry. LabelEntry* label; }; //! Operation type. uint8_t opType; //! Value types of \ref value. uint8_t valueType[2]; //! Reserved for future use, should be initialized to zero. uint8_t reserved[5]; //! Expression left and right values. Value value[2]; //! Resets the whole expression. //! //! Changes both values to \ref kValueNone. inline void reset() noexcept { memset(this, 0, sizeof(*this)); } //! Sets the value type at `index` to \ref kValueConstant and its content to `constant`. inline void setValueAsConstant(size_t index, uint64_t constant) noexcept { valueType[index] = kValueConstant; value[index].constant = constant; } //! Sets the value type at `index` to \ref kValueLabel and its content to `labelEntry`. inline void setValueAsLabel(size_t index, LabelEntry* labelEntry) noexcept { valueType[index] = kValueLabel; value[index].label = labelEntry; } //! Sets the value type at `index` to \ref kValueExpression and its content to `expression`. inline void setValueAsExpression(size_t index, Expression* expression) noexcept { valueType[index] = kValueLabel; value[index].expression = expression; } }; // ============================================================================ // [asmjit::Section] // ============================================================================ //! Section entry. class Section { public: //! Section id. uint32_t _id; //! Section flags. uint32_t _flags; //! Section alignment requirements (0 if no requirements). uint32_t _alignment; //! Order (lower value means higher priority). int32_t _order; //! Offset of this section from base-address. uint64_t _offset; //! Virtual size of the section (zero initialized sections). uint64_t _virtualSize; //! Section name (max 35 characters, PE allows max 8). FixedString _name; //! Code or data buffer. CodeBuffer _buffer; //! Section flags. enum Flags : uint32_t { //! Executable (.text sections). kFlagExec = 0x00000001u, //! Read-only (.text and .data sections). kFlagConst = 0x00000002u, //! Zero initialized by the loader (BSS). kFlagZero = 0x00000004u, //! Info / comment flag. kFlagInfo = 0x00000008u, //! Section created implicitly and can be deleted by \ref Target. kFlagImplicit = 0x80000000u }; //! \name Accessors //! \{ //! Returns the section id. inline uint32_t id() const noexcept { return _id; } //! Returns the section name, as a null terminated string. inline const char* name() const noexcept { return _name.str; } //! Returns the section data. inline uint8_t* data() noexcept { return _buffer.data(); } //! \overload inline const uint8_t* data() const noexcept { return _buffer.data(); } //! Returns the section flags, see \ref Flags. inline uint32_t flags() const noexcept { return _flags; } //! Tests whether the section has the given `flag`. inline bool hasFlag(uint32_t flag) const noexcept { return (_flags & flag) != 0; } //! Adds `flags` to the section flags. inline void addFlags(uint32_t flags) noexcept { _flags |= flags; } //! Removes `flags` from the section flags. inline void clearFlags(uint32_t flags) noexcept { _flags &= ~flags; } //! Returns the minimum section alignment inline uint32_t alignment() const noexcept { return _alignment; } //! Sets the minimum section alignment inline void setAlignment(uint32_t alignment) noexcept { _alignment = alignment; } //! Returns the section order, which has a higher priority than section id. inline int32_t order() const noexcept { return _order; } //! Returns the section offset, relative to base. inline uint64_t offset() const noexcept { return _offset; } //! Set the section offset. inline void setOffset(uint64_t offset) noexcept { _offset = offset; } //! Returns the virtual size of the section. //! //! Virtual size is initially zero and is never changed by AsmJit. It's normal //! if virtual size is smaller than size returned by `bufferSize()` as the buffer //! stores real data emitted by assemblers or appended by users. //! //! Use `realSize()` to get the real and final size of this section. inline uint64_t virtualSize() const noexcept { return _virtualSize; } //! Sets the virtual size of the section. inline void setVirtualSize(uint64_t virtualSize) noexcept { _virtualSize = virtualSize; } //! Returns the buffer size of the section. inline size_t bufferSize() const noexcept { return _buffer.size(); } //! Returns the real size of the section calculated from virtual and buffer sizes. inline uint64_t realSize() const noexcept { return Support::max(virtualSize(), bufferSize()); } //! Returns the `CodeBuffer` used by this section. inline CodeBuffer& buffer() noexcept { return _buffer; } //! Returns the `CodeBuffer` used by this section (const). inline const CodeBuffer& buffer() const noexcept { return _buffer; } //! \} }; // ============================================================================ // [asmjit::OffsetFormat] // ============================================================================ //! Provides information about formatting offsets, absolute addresses, or their //! parts. Offset format is used by both \ref RelocEntry and \ref LabelLink. //! //! The illustration above describes the relation of region size and offset size. //! Region size is the size of the whole unit whereas offset size is the size of //! the unit that will be patched. //! //! ``` //! +-> Code buffer | The subject of the relocation (region) | //! | | (Word-Offset) (Word-Size) | //! |xxxxxxxxxxxxxxx|................|*PATCHED*|................|xxxxxxxxxxxx-> //! | | //! [Word Offset points here]----+ +--- [WordOffset + WordSize] //! ``` //! //! Once the offset word has been located it can be patched like this: //! //! ``` //! |ImmDiscardLSB (discard LSB bits). //! |.. //! [0000000000000iiiiiiiiiiiiiiiiiDD] - Offset value (32-bit) //! [000000000000000iiiiiiiiiiiiiiiii] - Offset value after discard LSB. //! [00000000000iiiiiiiiiiiiiiiii0000] - Offset value shifted by ImmBitShift. //! [xxxxxxxxxxxiiiiiiiiiiiiiiiiixxxx] - Patched word (32-bit) //! |...............| //! (ImmBitCount) +- ImmBitShift //! ``` struct OffsetFormat { //! Type of the displacement. uint8_t _type; //! Encoding flags. uint8_t _flags; //! Size of the region (in bytes) containing the offset value, if the offset //! value is part of an instruction, otherwise it would be the same as //! `_valueSize`. uint8_t _regionSize; //! Size of the offset value, in bytes (1, 2, 4, or 8). uint8_t _valueSize; //! Offset of the offset value, in bytes, relative to the start of the region //! or data. Value offset would be zero if both region size and value size are //! equal. uint8_t _valueOffset; //! Size of the displacement immediate value in bits. uint8_t _immBitCount; //! Shift of the displacement immediate value in bits in the target word. uint8_t _immBitShift; //! Number of least significant bits to discard before writing the immediate //! to the destination. All discarded bits must be zero otherwise the value //! is invalid. uint8_t _immDiscardLsb; //! Type of the displacement. enum Type : uint8_t { //! A value having `_immBitCount` bits and shifted by `_immBitShift`. //! //! This displacement type is sufficient for both X86/X64 and many other //! architectures that store displacement as continuous bits within a machine //! word. kTypeCommon = 0, //! AARCH64 ADR format of `[.|immlo:2|.....|immhi:19|.....]`. kTypeAArch64_ADR, //! AARCH64 ADRP format of `[.|immlo:2|.....|immhi:19|.....]` (4kB pages). kTypeAArch64_ADRP, //! Count of displacement types. kTypeCount }; //! Returns the type of the displacement. inline uint32_t type() const noexcept { return _type; } //! Returns flags. inline uint32_t flags() const noexcept { return _flags; } //! Returns the size of the region/instruction where the displacement is encoded. inline uint32_t regionSize() const noexcept { return _regionSize; } //! Returns the the offset of the word relative to the start of the region //! where the displacement is. inline uint32_t valueOffset() const noexcept { return _valueOffset; } //! Returns the size of the data-type (word) that contains the displacement, in bytes. inline uint32_t valueSize() const noexcept { return _valueSize; } //! Returns the count of bits of the displacement value in the data it's stored in. inline uint32_t immBitCount() const noexcept { return _immBitCount; } //! Returns the bit-shift of the displacement value in the data it's stored in. inline uint32_t immBitShift() const noexcept { return _immBitShift; } //! Returns the number of least significant bits of the displacement value, //! that must be zero and that are not part of the encoded data. inline uint32_t immDiscardLsb() const noexcept { return _immDiscardLsb; } //! Resets this offset format to a simple data value of `dataSize` bytes. //! //! The region will be the same size as data and immediate bits would correspond //! to `dataSize * 8`. There will be no immediate bit shift or discarded bits. inline void resetToDataValue(size_t dataSize) noexcept { ASMJIT_ASSERT(dataSize <= 8u); _type = uint8_t(kTypeCommon); _flags = uint8_t(0); _regionSize = uint8_t(dataSize); _valueSize = uint8_t(dataSize); _valueOffset = uint8_t(0); _immBitCount = uint8_t(dataSize * 8u); _immBitShift = uint8_t(0); _immDiscardLsb = uint8_t(0); } inline void resetToImmValue(uint32_t type, size_t valueSize, uint32_t immBitShift, uint32_t immBitCount, uint32_t immDiscardLsb) noexcept { ASMJIT_ASSERT(valueSize <= 8u); ASMJIT_ASSERT(immBitShift < valueSize * 8u); ASMJIT_ASSERT(immBitCount <= 64u); ASMJIT_ASSERT(immDiscardLsb <= 64u); _type = uint8_t(type); _flags = uint8_t(0); _regionSize = uint8_t(valueSize); _valueSize = uint8_t(valueSize); _valueOffset = uint8_t(0); _immBitCount = uint8_t(immBitCount); _immBitShift = uint8_t(immBitShift); _immDiscardLsb = uint8_t(immDiscardLsb); } inline void setRegion(size_t regionSize, size_t valueOffset) noexcept { _regionSize = uint8_t(regionSize); _valueOffset = uint8_t(valueOffset); } inline void setLeadingAndTrailingSize(size_t leadingSize, size_t trailingSize) noexcept { _regionSize = uint8_t(leadingSize + trailingSize + _valueSize); _valueOffset = uint8_t(leadingSize); } }; // ============================================================================ // [asmjit::RelocEntry] // ============================================================================ //! Relocation entry. struct RelocEntry { //! Relocation id. uint32_t _id; //! Type of the relocation. uint32_t _relocType; //! Format of the relocated value. OffsetFormat _format; //! Source section id. uint32_t _sourceSectionId; //! Target section id. uint32_t _targetSectionId; //! Source offset (relative to start of the section). uint64_t _sourceOffset; //! Payload (target offset, target address, expression, etc). uint64_t _payload; //! Relocation type. enum RelocType : uint32_t { //! None/deleted (no relocation). kTypeNone = 0, //! Expression evaluation, `_payload` is pointer to `Expression`. kTypeExpression = 1, //! Relocate absolute to absolute. kTypeAbsToAbs = 2, //! Relocate relative to absolute. kTypeRelToAbs = 3, //! Relocate absolute to relative. kTypeAbsToRel = 4, //! Relocate absolute to relative or use trampoline. kTypeX64AddressEntry = 5 }; //! \name Accessors //! \{ inline uint32_t id() const noexcept { return _id; } inline uint32_t relocType() const noexcept { return _relocType; } inline const OffsetFormat& format() const noexcept { return _format; } inline uint32_t sourceSectionId() const noexcept { return _sourceSectionId; } inline uint32_t targetSectionId() const noexcept { return _targetSectionId; } inline uint64_t sourceOffset() const noexcept { return _sourceOffset; } inline uint64_t payload() const noexcept { return _payload; } Expression* payloadAsExpression() const noexcept { return reinterpret_cast(uintptr_t(_payload)); } //! \} }; // ============================================================================ // [asmjit::LabelLink] // ============================================================================ //! Data structure used to link either unbound labels or cross-section links. struct LabelLink { //! Next link (single-linked list). LabelLink* next; //! Section id where the label is bound. uint32_t sectionId; //! Relocation id or Globals::kInvalidId. uint32_t relocId; //! Label offset relative to the start of the section. size_t offset; //! Inlined rel8/rel32. intptr_t rel; //! Offset format information. OffsetFormat format; }; // ============================================================================ // [asmjit::LabelEntry] // ============================================================================ //! Label entry. //! //! Contains the following properties: //! * Label id - This is the only thing that is set to the `Label` operand. //! * Label name - Optional, used mostly to create executables and libraries. //! * Label type - Type of the label, default `Label::kTypeAnonymous`. //! * Label parent id - Derived from many assemblers that allow to define a //! local label that falls under a global label. This allows to define //! many labels of the same name that have different parent (global) label. //! * Offset - offset of the label bound by `Assembler`. //! * Links - single-linked list that contains locations of code that has //! to be patched when the label gets bound. Every use of unbound label //! adds one link to `_links` list. //! * HVal - Hash value of label's name and optionally parentId. //! * HashNext - Hash-table implementation detail. class LabelEntry : public ZoneHashNode { public: // Let's round the size of `LabelEntry` to 64 bytes (as `ZoneAllocator` has // granularity of 32 bytes anyway). This gives `_name` the remaining space, // which is should be 16 bytes on 64-bit and 28 bytes on 32-bit architectures. enum : uint32_t { kStaticNameSize = 64 - (sizeof(ZoneHashNode) + 8 + sizeof(Section*) + sizeof(size_t) + sizeof(LabelLink*)) }; //! Label type, see `Label::LabelType`. uint8_t _type; //! Must be zero. uint8_t _flags; //! Reserved. uint16_t _reserved16; //! Label parent id or zero. uint32_t _parentId; //! Label offset relative to the start of the `_section`. uint64_t _offset; //! Section where the label was bound. Section* _section; //! Label links. LabelLink* _links; //! Label name. ZoneString _name; //! \name Accessors //! \{ // NOTE: Label id is stored in `_customData`, which is provided by ZoneHashNode // to fill a padding that a C++ compiler targeting 64-bit CPU will add to align // the structure to 64-bits. //! Returns label id. inline uint32_t id() const noexcept { return _customData; } //! Sets label id (internal, used only by `CodeHolder`). inline void _setId(uint32_t id) noexcept { _customData = id; } //! Returns label type, see `Label::LabelType`. inline uint32_t type() const noexcept { return _type; } //! Returns label flags, returns 0 at the moment. inline uint32_t flags() const noexcept { return _flags; } //! Tests whether the label has a parent label. inline bool hasParent() const noexcept { return _parentId != Globals::kInvalidId; } //! Returns label's parent id. inline uint32_t parentId() const noexcept { return _parentId; } //! Returns the section where the label was bound. //! //! If the label was not yet bound the return value is `nullptr`. inline Section* section() const noexcept { return _section; } //! Tests whether the label has name. inline bool hasName() const noexcept { return !_name.empty(); } //! Returns the label's name. //! //! \note Local labels will return their local name without their parent //! part, for example ".L1". inline const char* name() const noexcept { return _name.data(); } //! Returns size of label's name. //! //! \note Label name is always null terminated, so you can use `strlen()` to //! get it, however, it's also cached in `LabelEntry` itself, so if you want //! to know the size the fastest way is to call `LabelEntry::nameSize()`. inline uint32_t nameSize() const noexcept { return _name.size(); } //! Returns links associated with this label. inline LabelLink* links() const noexcept { return _links; } //! Tests whether the label is bound. inline bool isBound() const noexcept { return _section != nullptr; } //! Tests whether the label is bound to a the given `sectionId`. inline bool isBoundTo(Section* section) const noexcept { return _section == section; } //! Returns the label offset (only useful if the label is bound). inline uint64_t offset() const noexcept { return _offset; } //! Returns the hash-value of label's name and its parent label (if any). //! //! Label hash is calculated as `HASH(Name) ^ ParentId`. The hash function //! is implemented in `Support::hashString()` and `Support::hashRound()`. inline uint32_t hashCode() const noexcept { return _hashCode; } //! \} }; // ============================================================================ // [asmjit::AddressTableEntry] // ============================================================================ //! Entry in an address table. class AddressTableEntry : public ZoneTreeNodeT { public: ASMJIT_NONCOPYABLE(AddressTableEntry) //! Address. uint64_t _address; //! Slot. uint32_t _slot; //! \name Construction & Destruction //! \{ inline explicit AddressTableEntry(uint64_t address) noexcept : _address(address), _slot(0xFFFFFFFFu) {} //! \} //! \name Accessors //! \{ inline uint64_t address() const noexcept { return _address; } inline uint32_t slot() const noexcept { return _slot; } inline bool hasAssignedSlot() const noexcept { return _slot != 0xFFFFFFFFu; } inline bool operator<(const AddressTableEntry& other) const noexcept { return _address < other._address; } inline bool operator>(const AddressTableEntry& other) const noexcept { return _address > other._address; } inline bool operator<(uint64_t queryAddress) const noexcept { return _address < queryAddress; } inline bool operator>(uint64_t queryAddress) const noexcept { return _address > queryAddress; } //! \} }; // ============================================================================ // [asmjit::CodeHolder] // ============================================================================ //! Contains basic information about the target architecture and its options. //! //! In addition, it holds assembled code & data (including sections, labels, and //! relocation information). `CodeHolder` can store both binary and intermediate //! representation of assembly, which can be generated by \ref BaseAssembler, //! \ref BaseBuilder, and \ref BaseCompiler //! //! \note `CodeHolder` has an ability to attach an \ref ErrorHandler, however, //! the error handler is not triggered by `CodeHolder` itself, it's instead //! propagated to all emitters that attach to it. class CodeHolder { public: ASMJIT_NONCOPYABLE(CodeHolder) //! Environment information. Environment _environment; //! Base address or \ref Globals::kNoBaseAddress. uint64_t _baseAddress; //! Attached `Logger`, used by all consumers. Logger* _logger; //! Attached `ErrorHandler`. ErrorHandler* _errorHandler; //! Code zone (used to allocate core structures). Zone _zone; //! Zone allocator, used to manage internal containers. ZoneAllocator _allocator; //! Attached emitters. ZoneVector _emitters; //! Section entries. ZoneVector _sections; //! Section entries sorted by section order and then section id. ZoneVector _sectionsByOrder; //! Label entries. ZoneVector _labelEntries; //! Relocation entries. ZoneVector _relocations; //! Label name -> LabelEntry (only named labels). ZoneHash _namedLabels; //! Count of label links, which are not resolved. size_t _unresolvedLinkCount; //! Pointer to an address table section (or null if this section doesn't exist). Section* _addressTableSection; //! Address table entries. ZoneTree _addressTableEntries; //! Options that can be used with \ref copySectionData() and \ref copyFlattenedData(). enum CopyOptions : uint32_t { //! If virtual size of a section is greater than the size of its \ref CodeBuffer //! then all bytes between the buffer size and virtual size will be zeroed. //! If this option is not set then those bytes would be left as is, which //! means that if the user didn't initialize them they would have a previous //! content, which may be unwanted. kCopyPadSectionBuffer = 0x00000001u, #ifndef ASMJIT_NO_DEPRECATED kCopyWithPadding = kCopyPadSectionBuffer, #endif // !ASMJIT_NO_DEPRECATED //! Zeroes the target buffer if the flattened data is less than the destination //! size. This option works only with \ref copyFlattenedData() as it processes //! multiple sections. It is ignored by \ref copySectionData(). kCopyPadTargetBuffer = 0x00000002u }; //! \name Construction & Destruction //! \{ //! Creates an uninitialized CodeHolder (you must init() it before it can be used). ASMJIT_API CodeHolder() noexcept; //! Destroys the CodeHolder. ASMJIT_API ~CodeHolder() noexcept; //! Tests whether the `CodeHolder` has been initialized. //! //! Emitters can be only attached to initialized `CodeHolder` instances. inline bool isInitialized() const noexcept { return _environment.isInitialized(); } //! Initializes CodeHolder to hold code described by code `info`. ASMJIT_API Error init(const Environment& environment, uint64_t baseAddress = Globals::kNoBaseAddress) noexcept; //! Detaches all code-generators attached and resets the `CodeHolder`. ASMJIT_API void reset(uint32_t resetPolicy = Globals::kResetSoft) noexcept; //! \} //! \name Attach & Detach //! \{ //! Attaches an emitter to this `CodeHolder`. ASMJIT_API Error attach(BaseEmitter* emitter) noexcept; //! Detaches an emitter from this `CodeHolder`. ASMJIT_API Error detach(BaseEmitter* emitter) noexcept; //! \} //! \name Allocators //! \{ //! Returns the allocator that the `CodeHolder` uses. //! //! \note This should be only used for AsmJit's purposes. Code holder uses //! arena allocator to allocate everything, so anything allocated through //! this allocator will be invalidated by \ref CodeHolder::reset() or by //! CodeHolder's destructor. inline ZoneAllocator* allocator() const noexcept { return const_cast(&_allocator); } //! \} //! \name Code & Architecture //! \{ //! Returns the target environment information, see \ref Environment. inline const Environment& environment() const noexcept { return _environment; } //! Returns the target architecture. inline uint32_t arch() const noexcept { return environment().arch(); } //! Returns the target sub-architecture. inline uint32_t subArch() const noexcept { return environment().subArch(); } //! Tests whether a static base-address is set. inline bool hasBaseAddress() const noexcept { return _baseAddress != Globals::kNoBaseAddress; } //! Returns a static base-address or \ref Globals::kNoBaseAddress, if not set. inline uint64_t baseAddress() const noexcept { return _baseAddress; } //! \} //! \name Emitters //! \{ //! Returns a vector of attached emitters. inline const ZoneVector& emitters() const noexcept { return _emitters; } //! \} //! \name Logging //! \{ //! Returns the attached logger, see \ref Logger. inline Logger* logger() const noexcept { return _logger; } //! Attaches a `logger` to CodeHolder and propagates it to all attached emitters. ASMJIT_API void setLogger(Logger* logger) noexcept; //! Resets the logger to none. inline void resetLogger() noexcept { setLogger(nullptr); } //! \name Error Handling //! \{ //! Tests whether the CodeHolder has an attached error handler, see \ref ErrorHandler. inline bool hasErrorHandler() const noexcept { return _errorHandler != nullptr; } //! Returns the attached error handler. inline ErrorHandler* errorHandler() const noexcept { return _errorHandler; } //! Attach an error handler to this `CodeHolder`. ASMJIT_API void setErrorHandler(ErrorHandler* errorHandler) noexcept; //! Resets the error handler to none. inline void resetErrorHandler() noexcept { setErrorHandler(nullptr); } //! \} //! \name Code Buffer //! \{ //! Makes sure that at least `n` bytes can be added to CodeHolder's buffer `cb`. //! //! \note The buffer `cb` must be managed by `CodeHolder` - otherwise the //! behavior of the function is undefined. ASMJIT_API Error growBuffer(CodeBuffer* cb, size_t n) noexcept; //! Reserves the size of `cb` to at least `n` bytes. //! //! \note The buffer `cb` must be managed by `CodeHolder` - otherwise the //! behavior of the function is undefined. ASMJIT_API Error reserveBuffer(CodeBuffer* cb, size_t n) noexcept; //! \} //! \name Sections //! \{ //! Returns an array of `Section*` records. inline const ZoneVector& sections() const noexcept { return _sections; } //! Returns an array of `Section*` records sorted according to section order first, then section id. inline const ZoneVector& sectionsByOrder() const noexcept { return _sectionsByOrder; } //! Returns the number of sections. inline uint32_t sectionCount() const noexcept { return _sections.size(); } //! Tests whether the given `sectionId` is valid. inline bool isSectionValid(uint32_t sectionId) const noexcept { return sectionId < _sections.size(); } //! Creates a new section and return its pointer in `sectionOut`. //! //! Returns `Error`, does not report a possible error to `ErrorHandler`. ASMJIT_API Error newSection(Section** sectionOut, const char* name, size_t nameSize = SIZE_MAX, uint32_t flags = 0, uint32_t alignment = 1, int32_t order = 0) noexcept; //! Returns a section entry of the given index. inline Section* sectionById(uint32_t sectionId) const noexcept { return _sections[sectionId]; } //! Returns section-id that matches the given `name`. //! //! If there is no such section `Section::kInvalidId` is returned. ASMJIT_API Section* sectionByName(const char* name, size_t nameSize = SIZE_MAX) const noexcept; //! Returns '.text' section (section that commonly represents code). //! //! \note Text section is always the first section in \ref CodeHolder::sections() array. inline Section* textSection() const noexcept { return _sections[0]; } //! Tests whether '.addrtab' section exists. inline bool hasAddressTable() const noexcept { return _addressTableSection != nullptr; } //! Returns '.addrtab' section. //! //! This section is used exclusively by AsmJit to store absolute 64-bit //! addresses that cannot be encoded in instructions like 'jmp' or 'call'. //! //! \note This section is created on demand, the returned pointer can be null. inline Section* addressTableSection() const noexcept { return _addressTableSection; } //! Ensures that '.addrtab' section exists (creates it if it doesn't) and //! returns it. Can return `nullptr` on out of memory condition. ASMJIT_API Section* ensureAddressTableSection() noexcept; //! Used to add an address to an address table. //! //! This implicitly calls `ensureAddressTableSection()` and then creates //! `AddressTableEntry` that is inserted to `_addressTableEntries`. If the //! address already exists this operation does nothing as the same addresses //! use the same slot. //! //! This function should be considered internal as it's used by assemblers to //! insert an absolute address into the address table. Inserting address into //! address table without creating a particula relocation entry makes no sense. ASMJIT_API Error addAddressToAddressTable(uint64_t address) noexcept; //! \} //! \name Labels & Symbols //! \{ //! Returns array of `LabelEntry*` records. inline const ZoneVector& labelEntries() const noexcept { return _labelEntries; } //! Returns number of labels created. inline uint32_t labelCount() const noexcept { return _labelEntries.size(); } //! Tests whether the label having `id` is valid (i.e. created by `newLabelEntry()`). inline bool isLabelValid(uint32_t labelId) const noexcept { return labelId < _labelEntries.size(); } //! Tests whether the `label` is valid (i.e. created by `newLabelEntry()`). inline bool isLabelValid(const Label& label) const noexcept { return label.id() < _labelEntries.size(); } //! \overload inline bool isLabelBound(uint32_t labelId) const noexcept { return isLabelValid(labelId) && _labelEntries[labelId]->isBound(); } //! Tests whether the `label` is already bound. //! //! Returns `false` if the `label` is not valid. inline bool isLabelBound(const Label& label) const noexcept { return isLabelBound(label.id()); } //! Returns LabelEntry of the given label `id`. inline LabelEntry* labelEntry(uint32_t labelId) const noexcept { return isLabelValid(labelId) ? _labelEntries[labelId] : static_cast(nullptr); } //! Returns LabelEntry of the given `label`. inline LabelEntry* labelEntry(const Label& label) const noexcept { return labelEntry(label.id()); } //! Returns offset of a `Label` by its `labelId`. //! //! The offset returned is relative to the start of the section. Zero offset //! is returned for unbound labels, which is their initial offset value. inline uint64_t labelOffset(uint32_t labelId) const noexcept { ASMJIT_ASSERT(isLabelValid(labelId)); return _labelEntries[labelId]->offset(); } //! \overload inline uint64_t labelOffset(const Label& label) const noexcept { return labelOffset(label.id()); } //! Returns offset of a label by it's `labelId` relative to the base offset. //! //! \remarks The offset of the section where the label is bound must be valid //! in order to use this function, otherwise the value returned will not be //! reliable. inline uint64_t labelOffsetFromBase(uint32_t labelId) const noexcept { ASMJIT_ASSERT(isLabelValid(labelId)); const LabelEntry* le = _labelEntries[labelId]; return (le->isBound() ? le->section()->offset() : uint64_t(0)) + le->offset(); } //! \overload inline uint64_t labelOffsetFromBase(const Label& label) const noexcept { return labelOffsetFromBase(label.id()); } //! Creates a new anonymous label and return its id in `idOut`. //! //! Returns `Error`, does not report error to `ErrorHandler`. ASMJIT_API Error newLabelEntry(LabelEntry** entryOut) noexcept; //! Creates a new named \ref LabelEntry of the given label `type`. //! //! \param entryOut Where to store the created \ref LabelEntry. //! \param name The name of the label. //! \param nameSize The length of `name` argument, or `SIZE_MAX` if `name` is //! a null terminated string, which means that the `CodeHolder` will //! use `strlen()` to determine the length. //! \param type The type of the label to create, see \ref Label::LabelType. //! \param parentId Parent id of a local label, otherwise it must be //! \ref Globals::kInvalidId. //! //! \retval Always returns \ref Error, does not report a possible error to //! the attached \ref ErrorHandler. //! //! AsmJit has a support for local labels (\ref Label::kTypeLocal) which //! require a parent label id (parentId). The names of local labels can //! conflict with names of other local labels that have a different parent. ASMJIT_API Error newNamedLabelEntry(LabelEntry** entryOut, const char* name, size_t nameSize, uint32_t type, uint32_t parentId = Globals::kInvalidId) noexcept; //! Returns a label by name. //! //! If the named label doesn't a default constructed \ref Label is returned, //! which has its id set to \ref Globals::kInvalidId. inline Label labelByName(const char* name, size_t nameSize = SIZE_MAX, uint32_t parentId = Globals::kInvalidId) noexcept { return Label(labelIdByName(name, nameSize, parentId)); } //! Returns a label id by name. //! //! If the named label doesn't exist \ref Globals::kInvalidId is returned. ASMJIT_API uint32_t labelIdByName(const char* name, size_t nameSize = SIZE_MAX, uint32_t parentId = Globals::kInvalidId) noexcept; //! Tests whether there are any unresolved label links. inline bool hasUnresolvedLinks() const noexcept { return _unresolvedLinkCount != 0; } //! Returns the number of label links, which are unresolved. inline size_t unresolvedLinkCount() const noexcept { return _unresolvedLinkCount; } //! Creates a new label-link used to store information about yet unbound labels. //! //! Returns `null` if the allocation failed. ASMJIT_API LabelLink* newLabelLink(LabelEntry* le, uint32_t sectionId, size_t offset, intptr_t rel, const OffsetFormat& format) noexcept; //! Resolves cross-section links (`LabelLink`) associated with each label that //! was used as a destination in code of a different section. It's only useful //! to people that use multiple sections as it will do nothing if the code only //! contains a single section in which cross-section links are not possible. ASMJIT_API Error resolveUnresolvedLinks() noexcept; //! Binds a label to a given `sectionId` and `offset` (relative to start of the section). //! //! This function is generally used by `BaseAssembler::bind()` to do the heavy lifting. ASMJIT_API Error bindLabel(const Label& label, uint32_t sectionId, uint64_t offset) noexcept; //! \} //! \name Relocations //! \{ //! Tests whether the code contains relocation entries. inline bool hasRelocEntries() const noexcept { return !_relocations.empty(); } //! Returns array of `RelocEntry*` records. inline const ZoneVector& relocEntries() const noexcept { return _relocations; } //! Returns a RelocEntry of the given `id`. inline RelocEntry* relocEntry(uint32_t id) const noexcept { return _relocations[id]; } //! Creates a new relocation entry of type `relocType`. //! //! Additional fields can be set after the relocation entry was created. ASMJIT_API Error newRelocEntry(RelocEntry** dst, uint32_t relocType) noexcept; //! \} //! \name Utilities //! \{ //! Flattens all sections by recalculating their offsets, starting at 0. //! //! \note This should never be called more than once. ASMJIT_API Error flatten() noexcept; //! Returns computed the size of code & data of all sections. //! //! \note All sections will be iterated over and the code size returned //! would represent the minimum code size of all combined sections after //! applying minimum alignment. Code size may decrease after calling //! `flatten()` and `relocateToBase()`. ASMJIT_API size_t codeSize() const noexcept; //! Relocates the code to the given `baseAddress`. //! //! \param baseAddress Absolute base address where the code will be relocated //! to. Please note that nothing is copied to such base address, it's just an //! absolute value used by the relocator to resolve all stored relocations. //! //! \note This should never be called more than once. ASMJIT_API Error relocateToBase(uint64_t baseAddress) noexcept; //! Copies a single section into `dst`. ASMJIT_API Error copySectionData(void* dst, size_t dstSize, uint32_t sectionId, uint32_t copyOptions = 0) noexcept; //! Copies all sections into `dst`. //! //! This should only be used if the data was flattened and there are no gaps //! between the sections. The `dstSize` is always checked and the copy will //! never write anything outside the provided buffer. ASMJIT_API Error copyFlattenedData(void* dst, size_t dstSize, uint32_t copyOptions = 0) noexcept; //! \} #ifndef ASMJIT_NO_DEPRECATED ASMJIT_DEPRECATED("Use 'CodeHolder::init(const Environment& environment, uint64_t baseAddress)' instead") inline Error init(const CodeInfo& codeInfo) noexcept { return init(codeInfo._environment, codeInfo._baseAddress); } ASMJIT_DEPRECATED("Use nevironment() instead") inline CodeInfo codeInfo() const noexcept { return CodeInfo(_environment, _baseAddress); } ASMJIT_DEPRECATED("Use BaseEmitter::encodingOptions() - this function always returns zero") inline uint32_t emitterOptions() const noexcept { return 0; } ASMJIT_DEPRECATED("Use BaseEmitter::addEncodingOptions() - this function does nothing") inline void addEmitterOptions(uint32_t options) noexcept { DebugUtils::unused(options); } ASMJIT_DEPRECATED("Use BaseEmitter::clearEncodingOptions() - this function does nothing") inline void clearEmitterOptions(uint32_t options) noexcept { DebugUtils::unused(options); } #endif // !ASMJIT_NO_DEPRECATED }; //! \} ASMJIT_END_NAMESPACE #endif // ASMJIT_CORE_CODEHOLDER_H_INCLUDED