src/asmjit/codeholder.h

/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Copyright (c) 2008-2017, Petr Kobalicek

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 __PLUMED_asmjit_codeholder_h
#define __PLUMED_asmjit_codeholder_h
#ifdef __PLUMED_HAS_ASMJIT
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
// [AsmJit]
// Complete x86/x64 JIT and Remote Assembler for C++.
//
// [License]
// Zlib - See LICENSE.md file in the package.

// [Guard]
#ifndef _ASMJIT_BASE_CODEHOLDER_H
#define _ASMJIT_BASE_CODEHOLDER_H

// [Dependencies]
#include "./arch.h"
#include "./func.h"
#include "./logging.h"
#include "./operand.h"
#include "./simdtypes.h"
#include "./utils.h"
#include "./zone.h"

// [Api-Begin]
#include "./asmjit_apibegin.h"

namespace PLMD {
namespace asmjit {

//! \addtogroup asmjit_base
//! \{

// ============================================================================
// [Forward Declarations]
// ============================================================================

class Assembler;
class CodeEmitter;
class CodeHolder;

// ============================================================================
// [asmjit::AlignMode]
// ============================================================================

//! Align mode.
ASMJIT_ENUM(AlignMode) {
  kAlignCode = 0,                        //!< Align executable code.
  kAlignData = 1,                        //!< Align non-executable code.
  kAlignZero = 2,                        //!< Align by a sequence of zeros.
  kAlignCount                            //!< Count of alignment modes.
};

// ============================================================================
// [asmjit::ErrorHandler]
// ============================================================================

//! Error handler can be used to override the default behavior of error handling
//! available to all classes that inherit \ref CodeEmitter. See \ref handleError().
class ASMJIT_VIRTAPI ErrorHandler {
public:
  // --------------------------------------------------------------------------
  // [Construction / Destruction]
  // --------------------------------------------------------------------------

  //! Create a new `ErrorHandler` instance.
  ASMJIT_API ErrorHandler() noexcept;
  //! Destroy the `ErrorHandler` instance.
  ASMJIT_API virtual ~ErrorHandler() noexcept;

  // --------------------------------------------------------------------------
  // [Handle Error]
  // --------------------------------------------------------------------------

  //! Error handler (abstract).
  //!
  //! Error handler is called after an error happened and before it's propagated
  //! to the caller. There are multiple ways how the error handler can be used:
  //!
  //! 1. Returning `true` or `false` from `handleError()`. If `true` is returned
  //!    it means that the error was reported and AsmJit can continue execution.
  //!    The reported error still be propagated to the caller, but won't put the
  //!    CodeEmitter into an error state (it won't set last-error). However,
  //!    returning `false` means that the error cannot be handled - in such case
  //!    it stores the error, which can be then retrieved by using `getLastError()`.
  //!    Returning `false` is the default behavior when no error handler is present.
  //!    To put the assembler into a non-error state again a `resetLastError()` must
  //!    be called.
  //!
  //! 2. Throwing an exception. AsmJit doesn't use exceptions and is completely
  //!    exception-safe, but you can throw exception from your error handler if
  //!    this way is the preferred way of handling errors in your project. Throwing
  //!    an exception acts virtually as returning `true` as AsmJit won't be able
  //!    to store the error because the exception changes execution path.
  //!
  //! 3. Using plain old C's `setjmp()` and `longjmp()`. Asmjit always puts
  //!    `CodeEmitter` to a consistent state before calling the `handleError()`
  //!    so `longjmp()` can be used without any issues to cancel the code
  //!    generation if an error occurred. There is no difference between
  //!    exceptions and longjmp() from AsmJit's perspective.
  virtual bool handleError(Error err, const char* message, CodeEmitter* origin) = 0;
};

// ============================================================================
// [asmjit::CodeInfo]
// ============================================================================

//! Basic information about a code (or target). It describes its architecture,
//! code generation mode (or optimization level), and base address.
class CodeInfo {
public:
  // --------------------------------------------------------------------------
  // [Construction / Destruction]
  // --------------------------------------------------------------------------

  ASMJIT_INLINE CodeInfo() noexcept
    : _archInfo(),
      _stackAlignment(0),
      _cdeclCallConv(CallConv::kIdNone),
      _stdCallConv(CallConv::kIdNone),
      _fastCallConv(CallConv::kIdNone),
      _baseAddress(Globals::kNoBaseAddress) {}
  ASMJIT_INLINE CodeInfo(const CodeInfo& other) noexcept { init(other); }

  explicit ASMJIT_INLINE CodeInfo(uint32_t archType, uint32_t archMode = 0, uint64_t baseAddress = Globals::kNoBaseAddress) noexcept
    : _archInfo(archType, archMode),
      _packedMiscInfo(0),
      _baseAddress(baseAddress) {}

  // --------------------------------------------------------------------------
  // [Init / Reset]
  // --------------------------------------------------------------------------

  ASMJIT_INLINE bool isInitialized() const noexcept {
    return _archInfo._type != ArchInfo::kTypeNone;
  }

  ASMJIT_INLINE void init(const CodeInfo& other) noexcept {
    _archInfo = other._archInfo;
    _packedMiscInfo = other._packedMiscInfo;
    _baseAddress = other._baseAddress;
  }

  ASMJIT_INLINE void init(uint32_t archType, uint32_t archMode = 0, uint64_t baseAddress = Globals::kNoBaseAddress) noexcept {
    _archInfo.init(archType, archMode);
    _packedMiscInfo = 0;
    _baseAddress = baseAddress;
  }

  ASMJIT_INLINE void reset() noexcept {
    _archInfo.reset();
    _stackAlignment = 0;
    _cdeclCallConv = CallConv::kIdNone;
    _stdCallConv = CallConv::kIdNone;
    _fastCallConv = CallConv::kIdNone;
    _baseAddress = Globals::kNoBaseAddress;
  }

  // --------------------------------------------------------------------------
  // [Architecture Information]
  // --------------------------------------------------------------------------

  //! Get architecture information, see \ref ArchInfo.
  ASMJIT_INLINE const ArchInfo& getArchInfo() const noexcept { return _archInfo; }

  //! Get architecture type, see \ref ArchInfo::Type.
  ASMJIT_INLINE uint32_t getArchType() const noexcept { return _archInfo.getType(); }
  //! Get architecture sub-type, see \ref ArchInfo::SubType.
  ASMJIT_INLINE uint32_t getArchSubType() const noexcept { return _archInfo.getSubType(); }
  //! Get a size of a GP register of the architecture the code is using.
  ASMJIT_INLINE uint32_t getGpSize() const noexcept { return _archInfo.getGpSize(); }
  //! Get number of GP registers available of the architecture the code is using.
  ASMJIT_INLINE uint32_t getGpCount() const noexcept { return _archInfo.getGpCount(); }

  // --------------------------------------------------------------------------
  // [High-Level Information]
  // --------------------------------------------------------------------------

  //! Get a natural stack alignment that must be honored (or 0 if not known).
  ASMJIT_INLINE uint32_t getStackAlignment() const noexcept { return _stackAlignment; }
  //! Set a natural stack alignment that must be honored.
  ASMJIT_INLINE void setStackAlignment(uint8_t sa) noexcept { _stackAlignment = static_cast<uint8_t>(sa); }

  ASMJIT_INLINE uint32_t getCdeclCallConv() const noexcept { return _cdeclCallConv; }
  ASMJIT_INLINE void setCdeclCallConv(uint32_t cc) noexcept { _cdeclCallConv = static_cast<uint8_t>(cc); }

  ASMJIT_INLINE uint32_t getStdCallConv() const noexcept { return _stdCallConv; }
  ASMJIT_INLINE void setStdCallConv(uint32_t cc) noexcept { _stdCallConv = static_cast<uint8_t>(cc); }

  ASMJIT_INLINE uint32_t getFastCallConv() const noexcept { return _fastCallConv; }
  ASMJIT_INLINE void setFastCallConv(uint32_t cc) noexcept { _fastCallConv = static_cast<uint8_t>(cc); }

  // --------------------------------------------------------------------------
  // [Addressing Information]
  // --------------------------------------------------------------------------

  ASMJIT_INLINE bool hasBaseAddress() const noexcept { return _baseAddress != Globals::kNoBaseAddress; }
  ASMJIT_INLINE uint64_t getBaseAddress() const noexcept { return _baseAddress; }
  ASMJIT_INLINE void setBaseAddress(uint64_t p) noexcept { _baseAddress = p; }
  ASMJIT_INLINE void resetBaseAddress() noexcept { _baseAddress = Globals::kNoBaseAddress; }

  // --------------------------------------------------------------------------
  // [Operator Overload]
  // --------------------------------------------------------------------------

  ASMJIT_INLINE CodeInfo& operator=(const CodeInfo& other) noexcept { init(other); return *this; }
  ASMJIT_INLINE bool operator==(const CodeInfo& other) const noexcept { return ::memcmp(this, &other, sizeof(*this)) == 0; }
  ASMJIT_INLINE bool operator!=(const CodeInfo& other) const noexcept { return ::memcmp(this, &other, sizeof(*this)) != 0; }

  // --------------------------------------------------------------------------
  // [Members]
  // --------------------------------------------------------------------------

  ArchInfo _archInfo;                    //!< Architecture information.

  union {
    struct {
      uint8_t _stackAlignment;           //!< Natural stack alignment (ARCH+OS).
      uint8_t _cdeclCallConv;            //!< Default CDECL calling convention.
      uint8_t _stdCallConv;              //!< Default STDCALL calling convention.
      uint8_t _fastCallConv;             //!< Default FASTCALL calling convention.
    };
    uint32_t _packedMiscInfo;            //!< \internal
  };

  uint64_t _baseAddress;                 //!< Base address.
};

// ============================================================================
// [asmjit::CodeBuffer]
// ============================================================================

//! Code or data buffer.
struct CodeBuffer {
  // --------------------------------------------------------------------------
  // [Accessors]
  // --------------------------------------------------------------------------

  ASMJIT_INLINE bool hasData() const noexcept { return _data != nullptr; }
  ASMJIT_INLINE uint8_t* getData() noexcept { return _data; }
  ASMJIT_INLINE const uint8_t* getData() const noexcept { return _data; }

  ASMJIT_INLINE size_t getLength() const noexcept { return _length; }
  ASMJIT_INLINE size_t getCapacity() const noexcept { return _capacity; }

  ASMJIT_INLINE bool isExternal() const noexcept { return _isExternal; }
  ASMJIT_INLINE bool isFixedSize() const noexcept { return _isFixedSize; }

  // --------------------------------------------------------------------------
  // [Members]
  // --------------------------------------------------------------------------

  uint8_t* _data;                        //!< The content of the buffer (data).
  size_t _length;                        //!< Number of bytes of `data` used.
  size_t _capacity;                      //!< Buffer capacity (in bytes).
  bool _isExternal;                      //!< True if this is external buffer.
  bool _isFixedSize;                     //!< True if this buffer cannot grow.
};

// ============================================================================
// [asmjit::SectionEntry]
// ============================================================================

//! Section entry.
class SectionEntry {
public:
  ASMJIT_ENUM(Id) {
    kInvalidId       = 0xFFFFFFFFU       //!< Invalid section id.
  };

  //! Section flags.
  ASMJIT_ENUM(Flags) {
    kFlagExec        = 0x00000001U,      //!< Executable (.text sections).
    kFlagConst       = 0x00000002U,      //!< Read-only (.text and .data sections).
    kFlagZero        = 0x00000004U,      //!< Zero initialized by the loader (BSS).
    kFlagInfo        = 0x00000008U,      //!< Info / comment flag.
    kFlagImplicit    = 0x80000000U       //!< Section created implicitly (can be deleted by the Runtime).
  };

  // --------------------------------------------------------------------------
  // [Accessors]
  // --------------------------------------------------------------------------

  ASMJIT_INLINE uint32_t getId() const noexcept { return _id; }
  ASMJIT_INLINE const char* getName() const noexcept { return _name; }

  ASMJIT_INLINE void _setDefaultName(
      char c0 = 0, char c1 = 0, char c2 = 0, char c3 = 0,
      char c4 = 0, char c5 = 0, char c6 = 0, char c7 = 0) noexcept {
    _nameAsU32[0] = Utils::pack32_4x8(c0, c1, c2, c3);
    _nameAsU32[1] = Utils::pack32_4x8(c4, c5, c6, c7);
  }

  ASMJIT_INLINE uint32_t getFlags() const noexcept { return _flags; }
  ASMJIT_INLINE bool hasFlag(uint32_t flag) const noexcept { return (_flags & flag) != 0; }
  ASMJIT_INLINE void addFlags(uint32_t flags) noexcept { _flags |= flags; }
  ASMJIT_INLINE void clearFlags(uint32_t flags) noexcept { _flags &= ~flags; }

  ASMJIT_INLINE uint32_t getAlignment() const noexcept { return _alignment; }
  ASMJIT_INLINE void setAlignment(uint32_t alignment) noexcept { _alignment = alignment; }

  ASMJIT_INLINE size_t getPhysicalSize() const noexcept { return _buffer.getLength(); }

  ASMJIT_INLINE size_t getVirtualSize() const noexcept { return _virtualSize; }
  ASMJIT_INLINE void setVirtualSize(uint32_t size) noexcept { _virtualSize = size; }

  ASMJIT_INLINE CodeBuffer& getBuffer() noexcept { return _buffer; }
  ASMJIT_INLINE const CodeBuffer& getBuffer() const noexcept { return _buffer; }

  // --------------------------------------------------------------------------
  // [Members]
  // --------------------------------------------------------------------------

  uint32_t _id;                          //!< Section id.
  uint32_t _flags;                       //!< Section flags.
  uint32_t _alignment;                   //!< Section alignment requirements (0 if no requirements).
  uint32_t _virtualSize;                 //!< Virtual size of the section (zero initialized mostly).
  union {
    char _name[36];                      //!< Section name (max 35 characters, PE allows max 8).
    uint32_t _nameAsU32[36 / 4];         //!< Section name as `uint32_t[]` (only optimization).
  };
  CodeBuffer _buffer;                    //!< Code or data buffer.
};

// ============================================================================
// [asmjit::LabelLink]
// ============================================================================

//! Data structure used to link labels.
struct LabelLink {
  LabelLink* prev;                       //!< Previous link (single-linked list).
  uint32_t sectionId;                    //!< Section id.
  uint32_t relocId;                      //!< Relocation id or RelocEntry::kInvalidId.
  size_t offset;                         //!< Label offset relative to the start of the section.
  intptr_t rel;                          //!< Inlined rel8/rel32.
};

// ============================================================================
// [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:
  // 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.

  //! Get label id.
  ASMJIT_INLINE uint32_t getId() const noexcept { return _customData; }
  //! Set label id (internal, used only by \ref CodeHolder).
  ASMJIT_INLINE void _setId(uint32_t id) noexcept { _customData = id; }

  //! Get label type, see \ref Label::Type.
  ASMJIT_INLINE uint32_t getType() const noexcept { return _type; }
  //! Get label flags, returns 0 at the moment.
  ASMJIT_INLINE uint32_t getFlags() const noexcept { return _flags; }

  ASMJIT_INLINE bool hasParent() const noexcept { return _parentId != 0; }
  //! Get label's parent id.
  ASMJIT_INLINE uint32_t getParentId() const noexcept { return _parentId; }

  //! Get label's section id where it's bound to (or `SectionEntry::kInvalidId` if it's not bound yet).
  ASMJIT_INLINE uint32_t getSectionId() const noexcept { return _sectionId; }

  //! Get if the label has name.
  ASMJIT_INLINE bool hasName() const noexcept { return !_name.isEmpty(); }

  //! Get the label's name.
  //!
  //! NOTE: Local labels will return their local name without their parent
  //! part, for example ".L1".
  ASMJIT_INLINE const char* getName() const noexcept { return _name.getData(); }

  //! Get length 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`, so if you want to know
  //! the length the easiest way is to use `LabelEntry::getNameLength()`.
  ASMJIT_INLINE size_t getNameLength() const noexcept { return _name.getLength(); }

  //! Get if the label is bound.
  ASMJIT_INLINE bool isBound() const noexcept { return _sectionId != SectionEntry::kInvalidId; }
  //! Get the label offset (only useful if the label is bound).
  ASMJIT_INLINE intptr_t getOffset() const noexcept { return _offset; }

  //! Get 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 `Utils::hashString()` and `Utils::hashRound()`.
  ASMJIT_INLINE uint32_t getHVal() const noexcept { return _hVal; }

  // ------------------------------------------------------------------------
  // [Members]
  // ------------------------------------------------------------------------

  // Let's round the size of `LabelEntry` to 64 bytes (as ZoneHeap has 32
  // bytes granularity anyway). This gives `_name` the remaining space, which
  // is roughly 16 bytes on 64-bit and 28 bytes on 32-bit architectures.
  enum { kNameBytes = 64 - (sizeof(ZoneHashNode) + 16 + sizeof(intptr_t) + sizeof(LabelLink*)) };

  uint8_t _type;                         //!< Label type, see Label::Type.
  uint8_t _flags;                        //!< Must be zero.
  uint16_t _reserved16;                  //!< Reserved.
  uint32_t _parentId;                    //!< Label parent id or zero.
  uint32_t _sectionId;                   //!< Section id or `SectionEntry::kInvalidId`.
  uint32_t _reserved32;                  //!< Reserved.
  intptr_t _offset;                      //!< Label offset.
  LabelLink* _links;                     //!< Label links.
  SmallString<kNameBytes> _name;         //!< Label name.
};

// ============================================================================
// [asmjit::RelocEntry]
// ============================================================================

//! Relocation entry.
struct RelocEntry {
  ASMJIT_ENUM(Id) {
    kInvalidId       = 0xFFFFFFFFU       //!< Invalid relocation id.
  };

  //! Relocation type.
  ASMJIT_ENUM(Type) {
    kTypeNone        = 0,                //!< Deleted entry (no relocation).
    kTypeAbsToAbs    = 1,                //!< Relocate absolute to absolute.
    kTypeRelToAbs    = 2,                //!< Relocate relative to absolute.
    kTypeAbsToRel    = 3,                //!< Relocate absolute to relative.
    kTypeTrampoline  = 4                 //!< Relocate absolute to relative or use trampoline.
  };

  // ------------------------------------------------------------------------
  // [Accessors]
  // ------------------------------------------------------------------------

  ASMJIT_INLINE uint32_t getId() const noexcept { return _id; }

  ASMJIT_INLINE uint32_t getType() const noexcept { return _type; }
  ASMJIT_INLINE uint32_t getSize() const noexcept { return _size; }

  ASMJIT_INLINE uint32_t getSourceSectionId() const noexcept { return _sourceSectionId; }
  ASMJIT_INLINE uint32_t getTargetSectionId() const noexcept { return _targetSectionId; }

  ASMJIT_INLINE uint64_t getSourceOffset() const noexcept { return _sourceOffset; }
  ASMJIT_INLINE uint64_t getData() const noexcept { return _data; }

  // ------------------------------------------------------------------------
  // [Members]
  // ------------------------------------------------------------------------

  uint32_t _id;                          //!< Relocation id.
  uint8_t _type;                         //!< Type of the relocation.
  uint8_t _size;                         //!< Size of the relocation (1, 2, 4 or 8 bytes).
  uint8_t _reserved[2];                  //!< Reserved.
  uint32_t _sourceSectionId;             //!< Source section id.
  uint32_t _targetSectionId;             //!< Destination section id.
  uint64_t _sourceOffset;                //!< Source offset (relative to start of the section).
  uint64_t _data;                        //!< Relocation data (target offset, target address, etc).
};

// ============================================================================
// [asmjit::CodeHolder]
// ============================================================================

//! Contains basic information about the target architecture plus its settings,
//! and holds code & data (including sections, labels, and relocation information).
//! CodeHolder can store both binary and intermediate representation of assembly,
//! which can be generated by \ref Assembler and/or \ref CodeBuilder.
//!
//! NOTE: CodeHolder has ability to attach an \ref ErrorHandler, however, this
//! error handler is not triggered by CodeHolder itself, it's only used by the
//! attached code generators.
class CodeHolder {
public:
  ASMJIT_NONCOPYABLE(CodeHolder)

  // --------------------------------------------------------------------------
  // [Construction / Destruction]
  // --------------------------------------------------------------------------

  //! Create an uninitialized CodeHolder (you must init() it before it can be used).
  ASMJIT_API CodeHolder() noexcept;
  //! Destroy the CodeHolder.
  ASMJIT_API ~CodeHolder() noexcept;

  // --------------------------------------------------------------------------
  // [Init / Reset]
  // --------------------------------------------------------------------------

  ASMJIT_INLINE bool isInitialized() const noexcept { return _codeInfo.isInitialized(); }

  //! Initialize to CodeHolder to hold code described by `codeInfo`.
  ASMJIT_API Error init(const CodeInfo& info) noexcept;
  //! Detach all code-generators attached and reset the \ref CodeHolder.
  ASMJIT_API void reset(bool releaseMemory = false) noexcept;

  // --------------------------------------------------------------------------
  // [Attach / Detach]
  // --------------------------------------------------------------------------

  //! Attach a \ref CodeEmitter to this \ref CodeHolder.
  ASMJIT_API Error attach(CodeEmitter* emitter) noexcept;
  //! Detach a \ref CodeEmitter from this \ref CodeHolder.
  ASMJIT_API Error detach(CodeEmitter* emitter) noexcept;

  // --------------------------------------------------------------------------
  // [Sync]
  // --------------------------------------------------------------------------

  //! Synchronize all states of all `CodeEmitter`s associated with the CodeHolder.
  //! This is required as some code generators don't sync every time they do
  //! something - for example \ref Assembler generally syncs when it needs to
  //! reallocate the \ref CodeBuffer, but not each time it encodes instruction
  //! or directive.
  ASMJIT_API void sync() noexcept;

  // --------------------------------------------------------------------------
  // [Code-Information]
  // --------------------------------------------------------------------------

  //! Get code/target information, see \ref CodeInfo.
  ASMJIT_INLINE const CodeInfo& getCodeInfo() const noexcept { return _codeInfo; }
  //! Get architecture information, see \ref ArchInfo.
  ASMJIT_INLINE const ArchInfo& getArchInfo() const noexcept { return _codeInfo.getArchInfo(); }

  //! Get the target's architecture type.
  ASMJIT_INLINE uint32_t getArchType() const noexcept { return getArchInfo().getType(); }
  //! Get the target's architecture sub-type.
  ASMJIT_INLINE uint32_t getArchSubType() const noexcept { return getArchInfo().getSubType(); }

  //! Get if a static base-address is set.
  ASMJIT_INLINE bool hasBaseAddress() const noexcept { return _codeInfo.hasBaseAddress(); }
  //! Get a static base-address (uint64_t).
  ASMJIT_INLINE uint64_t getBaseAddress() const noexcept { return _codeInfo.getBaseAddress(); }

  // --------------------------------------------------------------------------
  // [Global Information]
  // --------------------------------------------------------------------------

  //! Get global hints, internally propagated to all `CodeEmitter`s attached.
  ASMJIT_INLINE uint32_t getGlobalHints() const noexcept { return _globalHints; }
  //! Get global options, internally propagated to all `CodeEmitter`s attached.
  ASMJIT_INLINE uint32_t getGlobalOptions() const noexcept { return _globalOptions; }

  // --------------------------------------------------------------------------
  // [Result Information]
  // --------------------------------------------------------------------------

  //! Get the size code & data of all sections.
  ASMJIT_API size_t getCodeSize() const noexcept;

  //! Get size of all possible trampolines.
  //!
  //! Trampolines are needed to successfully generate relative jumps to absolute
  //! addresses. This value is only non-zero if jmp of call instructions were
  //! used with immediate operand (this means jumping or calling an absolute
  //! address directly).
  ASMJIT_INLINE size_t getTrampolinesSize() const noexcept { return _trampolinesSize; }

  // --------------------------------------------------------------------------
  // [Logging & Error Handling]
  // --------------------------------------------------------------------------

#if !defined(ASMJIT_DISABLE_LOGGING)
  //! Get if a logger attached.
  ASMJIT_INLINE bool hasLogger() const noexcept { return _logger != nullptr; }
  //! Get the attached logger.
  ASMJIT_INLINE Logger* getLogger() const noexcept { return _logger; }
  //! Attach a `logger` to CodeHolder and propagate it to all attached `CodeEmitter`s.
  ASMJIT_API void setLogger(Logger* logger) noexcept;
  //! Reset the logger (does nothing if not attached).
  ASMJIT_INLINE void resetLogger() noexcept { setLogger(nullptr); }
#endif // !ASMJIT_DISABLE_LOGGING

  //! Get if error-handler is attached.
  ASMJIT_INLINE bool hasErrorHandler() const noexcept { return _errorHandler != nullptr; }
  //! Get the error-handler.
  ASMJIT_INLINE ErrorHandler* getErrorHandler() const noexcept { return _errorHandler; }
  //! Set the error handler, will affect all attached `CodeEmitter`s.
  ASMJIT_API Error setErrorHandler(ErrorHandler* handler) noexcept;
  //! Reset the error handler (does nothing if not attached).
  ASMJIT_INLINE void resetErrorHandler() noexcept { setErrorHandler(nullptr); }

  // --------------------------------------------------------------------------
  // [Sections]
  // --------------------------------------------------------------------------

  //! Get array of `SectionEntry*` records.
  ASMJIT_INLINE const ZoneVector<SectionEntry*>& getSections() const noexcept { return _sections; }

  //! Get a section entry of the given index.
  ASMJIT_INLINE SectionEntry* getSectionEntry(size_t index) const noexcept { return _sections[index]; }

  ASMJIT_API Error growBuffer(CodeBuffer* cb, size_t n) noexcept;
  ASMJIT_API Error reserveBuffer(CodeBuffer* cb, size_t n) noexcept;

  // --------------------------------------------------------------------------
  // [Labels & Symbols]
  // --------------------------------------------------------------------------

  //! Create a new anonymous label and return its id in `idOut`.
  //!
  //! Returns `Error`, does not report error to \ref ErrorHandler.
  ASMJIT_API Error newLabelId(uint32_t& idOut) noexcept;

  //! Create a new named label label-type `type`.
  //!
  //! Returns `Error`, does not report error to \ref ErrorHandler.
  ASMJIT_API Error newNamedLabelId(uint32_t& idOut, const char* name, size_t nameLength, uint32_t type, uint32_t parentId) noexcept;

  //! Get a label id by name.
  ASMJIT_API uint32_t getLabelIdByName(const char* name, size_t nameLength = Globals::kInvalidIndex, uint32_t parentId = 0) noexcept;

  //! Create 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) noexcept;

  //! Get array of `LabelEntry*` records.
  ASMJIT_INLINE const ZoneVector<LabelEntry*>& getLabelEntries() const noexcept { return _labels; }

  //! Get number of labels created.
  ASMJIT_INLINE size_t getLabelsCount() const noexcept { return _labels.getLength(); }

  //! Get number of label references, which are unresolved at the moment.
  ASMJIT_INLINE size_t getUnresolvedLabelsCount() const noexcept { return _unresolvedLabelsCount; }

  //! Get if the `label` is valid (i.e. created by `newLabelId()`).
  ASMJIT_INLINE bool isLabelValid(const Label& label) const noexcept {
    return isLabelValid(label.getId());
  }
  //! Get if the label having `id` is valid (i.e. created by `newLabelId()`).
  ASMJIT_INLINE bool isLabelValid(uint32_t labelId) const noexcept {
    size_t index = Operand::unpackId(labelId);
    return index < _labels.getLength();
  }

  //! Get if the `label` is already bound.
  //!
  //! Returns `false` if the `label` is not valid.
  ASMJIT_INLINE bool isLabelBound(const Label& label) const noexcept {
    return isLabelBound(label.getId());
  }
  //! \overload
  ASMJIT_INLINE bool isLabelBound(uint32_t id) const noexcept {
    size_t index = Operand::unpackId(id);
    return index < _labels.getLength() && _labels[index]->isBound();
  }

  //! Get a `label` offset or -1 if the label is not yet bound.
  ASMJIT_INLINE intptr_t getLabelOffset(const Label& label) const noexcept {
    return getLabelOffset(label.getId());
  }
  //! \overload
  ASMJIT_INLINE intptr_t getLabelOffset(uint32_t id) const noexcept {
    ASMJIT_ASSERT(isLabelValid(id));
    return _labels[Operand::unpackId(id)]->getOffset();
  }

  //! Get information about the given `label`.
  ASMJIT_INLINE LabelEntry* getLabelEntry(const Label& label) const noexcept {
    return getLabelEntry(label.getId());
  }
  //! Get information about a label having the given `id`.
  ASMJIT_INLINE LabelEntry* getLabelEntry(uint32_t id) const noexcept {
    size_t index = static_cast<size_t>(Operand::unpackId(id));
    return index < _labels.getLength() ? _labels[index] : static_cast<LabelEntry*>(nullptr);
  }

  // --------------------------------------------------------------------------
  // [Relocations]
  // --------------------------------------------------------------------------

  //! Create a new relocation entry of type `type` and size `size`.
  //!
  //! Additional fields can be set after the relocation entry was created.
  ASMJIT_API Error newRelocEntry(RelocEntry** dst, uint32_t type, uint32_t size) noexcept;

  //! Get if the code contains relocations.
  ASMJIT_INLINE bool hasRelocations() const noexcept { return !_relocations.isEmpty(); }
  //! Get array of `RelocEntry*` records.
  ASMJIT_INLINE const ZoneVector<RelocEntry*>& getRelocEntries() const noexcept { return _relocations; }

  ASMJIT_INLINE RelocEntry* getRelocEntry(uint32_t id) const noexcept { return _relocations[id]; }

  //! Relocate the code to `baseAddress` and copy it to `dst`.
  //!
  //! \param dst Contains the location where the relocated code should be
  //! copied. The pointer can be address returned by virtual memory allocator
  //! or any other address that has sufficient space.
  //!
  //! \param baseAddress Base address used for relocation. `JitRuntime` always
  //! sets the `baseAddress` to be the same as `dst`.
  //!
  //! \return The number bytes actually used. If the code emitter reserved
  //! space for possible trampolines, but didn't use it, the number of bytes
  //! used can actually be less than the expected worst case. Virtual memory
  //! allocator can shrink the memory it allocated initially.
  //!
  //! A given buffer will be overwritten, to get the number of bytes required,
  //! use `getCodeSize()`.
  ASMJIT_API size_t relocate(void* dst, uint64_t baseAddress = Globals::kNoBaseAddress) const noexcept;

  // --------------------------------------------------------------------------
  // [Members]
  // --------------------------------------------------------------------------

  CodeInfo _codeInfo;                    //!< Basic information about the code (architecture and other info).

  uint32_t _globalHints;                 //!< Global hints, propagated to all `CodeEmitter`s.
  uint32_t _globalOptions;               //!< Global options, propagated to all `CodeEmitter`s.

  CodeEmitter* _emitters;                //!< Linked-list of all attached `CodeEmitter`s.
  Assembler* _cgAsm;                     //!< Attached \ref Assembler (only one at a time).

  Logger* _logger;                       //!< Attached \ref Logger, used by all consumers.
  ErrorHandler* _errorHandler;           //!< Attached \ref ErrorHandler.

  uint32_t _unresolvedLabelsCount;       //!< Count of label references which were not resolved.
  uint32_t _trampolinesSize;             //!< Size of all possible trampolines.

  Zone _baseZone;                        //!< Base zone (used to allocate core structures).
  Zone _dataZone;                        //!< Data zone (used to allocate extra data like label names).
  ZoneHeap _baseHeap;                    //!< Zone allocator, used to manage internal containers.

  ZoneVector<SectionEntry*> _sections;   //!< Section entries.
  ZoneVector<LabelEntry*> _labels;       //!< Label entries (each label is stored here).
  ZoneVector<RelocEntry*> _relocations;  //!< Relocation entries.
  ZoneHash<LabelEntry> _namedLabels;     //!< Label name -> LabelEntry (only named labels).
};

//! \}

} // asmjit namespace
} // namespace PLMD

// [Api-End]
#include "./asmjit_apiend.h"

// [Guard]
#endif // _ASMJIT_BASE_CODEHOLDER_H
#pragma GCC diagnostic pop
#endif // __PLUMED_HAS_ASMJIT
#endif