asmjit 0.2.0 → 0.2.1

data/ext/asmjit/asmjit/src/asmjit/core/jitallocator.h

@@ -0,0 +1,261 @@
+// This file is part of AsmJit project <https://asmjit.com>
+//
+// See asmjit.h or LICENSE.md for license and copyright information
+// SPDX-License-Identifier: Zlib
+
+#ifndef ASMJIT_CORE_JITALLOCATOR_H_INCLUDED
+#define ASMJIT_CORE_JITALLOCATOR_H_INCLUDED
+
+#include "../core/api-config.h"
+#ifndef ASMJIT_NO_JIT
+
+#include "../core/globals.h"
+#include "../core/virtmem.h"
+
+ASMJIT_BEGIN_NAMESPACE
+
+//! \addtogroup asmjit_virtual_memory
+//! \{
+
+//! Options used by \ref JitAllocator.
+enum class JitAllocatorOptions : uint32_t {
+  //! No options.
+  kNone = 0,
+
+  //! Enables the use of an anonymous memory-mapped memory that is mapped into two buffers having a different pointer.
+  //! The first buffer has read and execute permissions and the second buffer has read+write permissions.
+  //!
+  //! See \ref VirtMem::allocDualMapping() for more details about this feature.
+  kUseDualMapping = 0x00000001u,
+
+  //! Enables the use of multiple pools with increasing granularity instead of a single pool. This flag would enable
+  //! 3 internal pools in total having 64, 128, and 256 bytes granularity.
+  //!
+  //! This feature is only recommended for users that generate a lot of code and would like to minimize the overhead
+  //! of `JitAllocator` itself by having blocks of different allocation granularities. Using this feature only for
+  //! few allocations won't pay off as the allocator may need to create more blocks initially before it can take the
+  //! advantage of variable block granularity.
+  kUseMultiplePools = 0x00000002u,
+
+  //! Always fill reserved memory by a fill-pattern.
+  //!
+  //! Causes a new block to be cleared by the fill pattern and freshly released memory to be cleared before making
+  //! it ready for another use.
+  kFillUnusedMemory = 0x00000004u,
+
+  //! When this flag is set the allocator would immediately release unused blocks during `release()` or `reset()`.
+  //! When this flag is not set the allocator would keep one empty block in each pool to prevent excessive virtual
+  //! memory allocations and deallocations in border cases, which involve constantly allocating and deallocating a
+  //! single block caused by repetitive calling `alloc()` and `release()` when the allocator has either no blocks
+  //! or have all blocks fully occupied.
+  kImmediateRelease = 0x00000008u,
+
+  //! Use a custom fill pattern, must be combined with `kFlagFillUnusedMemory`.
+  kCustomFillPattern = 0x10000000u
+};
+ASMJIT_DEFINE_ENUM_FLAGS(JitAllocatorOptions)
+
+//! A simple implementation of memory manager that uses `asmjit::VirtMem`
+//! functions to manage virtual memory for JIT compiled code.
+//!
+//! Implementation notes:
+//!
+//! - Granularity of allocated blocks is different than granularity for a typical C malloc. In addition, the allocator
+//!   can use several memory pools having a different granularity to minimize the maintenance overhead. Multiple pools
+//!   feature requires `kFlagUseMultiplePools` flag to be set.
+//!
+//! - The allocator doesn't store any information in executable memory, instead, the implementation uses two
+//!   bit-vectors to manage allocated memory of each allocator-block. The first bit-vector called 'used' is used to
+//!   track used memory (where each bit represents memory size defined by granularity) and the second bit vector called
+//!   'stop' is used as a sentinel to mark where the allocated area ends.
+//!
+//! - Internally, the allocator also uses RB tree to keep track of all blocks across all pools. Each inserted block is
+//!   added to the tree so it can be matched fast during `release()` and `shrink()`.
+class JitAllocator {
+public:
+  ASMJIT_NONCOPYABLE(JitAllocator)
+
+  struct Impl {
+    //! Allocator options.
+    JitAllocatorOptions options;
+    //! Base block size (0 if the allocator is not initialized).
+    uint32_t blockSize;
+    //! Base granularity (0 if the allocator is not initialized).
+    uint32_t granularity;
+    //! A pattern that is used to fill unused memory if secure mode is enabled.
+    uint32_t fillPattern;
+  };
+
+  //! Allocator implementation (private).
+  Impl* _impl;
+
+  //! \name Construction & Destruction
+  //! \{
+
+  //! Parameters that can be passed to `JitAllocator` constructor.
+  //!
+  //! Use it like this:
+  //!
+  //! ```
+  //! // Zero initialize (zero means the default value) and change what you need.
+  //! JitAllocator::CreateParams params {};
+  //! params.blockSize = 1024 * 1024;
+  //!
+  //! // Create the allocator.
+  //! JitAllocator allocator(&params);
+  //! ```
+  struct CreateParams {
+    //! Allocator options.
+    //!
+    //! No options are used by default.
+    JitAllocatorOptions options = JitAllocatorOptions::kNone;
+
+    //! Base size of a single block in bytes (default 64kB).
+    //!
+    //! \remarks Block size must be equal to or greater than page size and must be power of 2. If the input is not
+    //! valid then the default block size will be used instead.
+    uint32_t blockSize = 0;
+
+    //! Base granularity (and also natural alignment) of allocations in bytes (default 64).
+    //!
+    //! Since the `JitAllocator` uses bit-arrays to mark used memory the granularity also specifies how many bytes
+    //! correspond to a single bit in such bit-array. Higher granularity means more waste of virtual memory (as it
+    //! increases the natural alignment), but smaller bit-arrays as less bits would be required per a single block.
+    uint32_t granularity = 0;
+
+    //! Patter to use to fill unused memory.
+    //!
+    //! Only used if \ref JitAllocatorOptions::kCustomFillPattern is set.
+    uint32_t fillPattern = 0;
+
+    // Reset the content of `CreateParams`.
+    inline void reset() noexcept { memset(this, 0, sizeof(*this)); }
+  };
+
+  //! Creates a `JitAllocator` instance.
+  ASMJIT_API explicit JitAllocator(const CreateParams* params = nullptr) noexcept;
+  //! Destroys the `JitAllocator` instance and release all blocks held.
+  ASMJIT_API ~JitAllocator() noexcept;
+
+  inline bool isInitialized() const noexcept { return _impl->blockSize == 0; }
+
+  //! Free all allocated memory - makes all pointers returned by `alloc()` invalid.
+  //!
+  //! \remarks This function is not thread-safe as it's designed to be used when nobody else is using allocator.
+  //! The reason is that there is no point of calling `reset()` when the allocator is still in use.
+  ASMJIT_API void reset(ResetPolicy resetPolicy = ResetPolicy::kSoft) noexcept;
+
+  //! \}
+
+  //! \name Accessors
+  //! \{
+
+  //! Returns allocator options, see `Flags`.
+  inline JitAllocatorOptions options() const noexcept { return _impl->options; }
+  //! Tests whether the allocator has the given `option` set.
+  inline bool hasOption(JitAllocatorOptions option) const noexcept { return uint32_t(_impl->options & option) != 0; }
+
+  //! Returns a base block size (a minimum size of block that the allocator would allocate).
+  inline uint32_t blockSize() const noexcept { return _impl->blockSize; }
+  //! Returns granularity of the allocator.
+  inline uint32_t granularity() const noexcept { return _impl->granularity; }
+  //! Returns pattern that is used to fill unused memory if `kFlagUseFillPattern` is set.
+  inline uint32_t fillPattern() const noexcept { return _impl->fillPattern; }
+
+  //! \}
+
+  //! \name Alloc & Release
+  //! \{
+
+  //! Allocates a new memory block of the requested `size`.
+  //!
+  //! When the function is successful it stores two pointers in `rxPtrOut` and `rwPtrOut`. The pointers will be
+  //! different only if `kOptionUseDualMapping` was used to setup the allocator (in that case the `rxPtrOut` would
+  //! point to a Read+Execute region and `rwPtrOut` would point to a Read+Write region of the same memory-mapped block.
+  ASMJIT_API Error alloc(void** rxPtrOut, void** rwPtrOut, size_t size) noexcept;
+
+  //! Releases a memory block returned by `alloc()`.
+  //!
+  //! \remarks This function is thread-safe.
+  ASMJIT_API Error release(void* rxPtr) noexcept;
+
+  //! Frees extra memory allocated with `rxPtr` by shrinking it to the given `newSize`.
+  //!
+  //! \remarks This function is thread-safe.
+  ASMJIT_API Error shrink(void* rxPtr, size_t newSize) noexcept;
+
+  //! Queries information about an allocated memory block that contains the given `rxPtr`.
+  //!
+  //! The function returns `kErrorOk` when `rxPtr` is matched and fills `rxPtrOut`, `rwPtrOut`, and `sizeOut` output
+  //! arguments. The returned `rxPtrOut` and `rwPtrOut` pointers point to the beginning of the block, and `sizeOut`
+  //! describes the total amount of bytes this allocation uses - `sizeOut` will always be aligned to the allocation
+  //! granularity, so for example if an allocation was 1 byte and the size granularity is 64, the returned `sizeOut`
+  //! will be 64 bytes, because that's what the allocator sees.
+  ASMJIT_API Error query(void* rxPtr, void** rxPtrOut, void** rwPtrOut, size_t* sizeOut) const noexcept;
+
+  //! \}
+
+  //! \name Statistics
+  //! \{
+
+  //! Statistics about `JitAllocator`.
+  struct Statistics {
+    //! Number of blocks `JitAllocator` maintains.
+    size_t _blockCount;
+    //! Number of active allocations.
+    size_t _allocationCount;
+    //! How many bytes are currently used / allocated.
+    size_t _usedSize;
+    //! How many bytes are currently reserved by the allocator.
+    size_t _reservedSize;
+    //! Allocation overhead (in bytes) required to maintain all blocks.
+    size_t _overheadSize;
+
+    inline void reset() noexcept {
+      _blockCount = 0;
+      _usedSize = 0;
+      _reservedSize = 0;
+      _overheadSize = 0;
+    }
+
+    //! Returns count of blocks managed by `JitAllocator` at the moment.
+    inline size_t blockCount() const noexcept { return _blockCount; }
+    //! Returns the number of active allocations.
+    inline size_t allocationCount() const noexcept { return _allocationCount; }
+
+    //! Returns how many bytes are currently used.
+    inline size_t usedSize() const noexcept { return _usedSize; }
+    //! Returns the number of bytes unused by the allocator at the moment.
+    inline size_t unusedSize() const noexcept { return _reservedSize - _usedSize; }
+    //! Returns the total number of bytes bytes reserved by the allocator (sum of sizes of all blocks).
+    inline size_t reservedSize() const noexcept { return _reservedSize; }
+    //! Returns the number of bytes the allocator needs to manage the allocated memory.
+    inline size_t overheadSize() const noexcept { return _overheadSize; }
+
+    inline double usedSizeAsPercent() const noexcept {
+      return (double(usedSize()) / (double(reservedSize()) + 1e-16)) * 100.0;
+    }
+
+    inline double unusedSizeAsPercent() const noexcept {
+      return (double(unusedSize()) / (double(reservedSize()) + 1e-16)) * 100.0;
+    }
+
+    inline double overheadSizeAsPercent() const noexcept {
+      return (double(overheadSize()) / (double(reservedSize()) + 1e-16)) * 100.0;
+    }
+  };
+
+  //! Returns JIT allocator statistics.
+  //!
+  //! \remarks This function is thread-safe.
+  ASMJIT_API Statistics statistics() const noexcept;
+
+  //! \}
+};
+
+//! \}
+
+ASMJIT_END_NAMESPACE
+
+#endif
+#endif

data/ext/asmjit/asmjit/src/asmjit/core/jitruntime.cpp

@@ -0,0 +1,80 @@
+// This file is part of AsmJit project <https://asmjit.com>
+//
+// See asmjit.h or LICENSE.md for license and copyright information
+// SPDX-License-Identifier: Zlib
+
+#include "../core/api-build_p.h"
+#ifndef ASMJIT_NO_JIT
+
+#include "../core/cpuinfo.h"
+#include "../core/jitruntime.h"
+
+ASMJIT_BEGIN_NAMESPACE
+
+JitRuntime::JitRuntime(const JitAllocator::CreateParams* params) noexcept
+  : _allocator(params) {
+  _environment = Environment::host();
+  _environment.setObjectFormat(ObjectFormat::kJIT);
+}
+
+JitRuntime::~JitRuntime() noexcept {}
+
+Error JitRuntime::_add(void** dst, CodeHolder* code) noexcept {
+  *dst = nullptr;
+
+  ASMJIT_PROPAGATE(code->flatten());
+  ASMJIT_PROPAGATE(code->resolveUnresolvedLinks());
+
+  size_t estimatedCodeSize = code->codeSize();
+  if (ASMJIT_UNLIKELY(estimatedCodeSize == 0))
+    return DebugUtils::errored(kErrorNoCodeGenerated);
+
+  uint8_t* rx;
+  uint8_t* rw;
+  ASMJIT_PROPAGATE(_allocator.alloc((void**)&rx, (void**)&rw, estimatedCodeSize));
+
+  // Relocate the code.
+  Error err = code->relocateToBase(uintptr_t((void*)rx));
+  if (ASMJIT_UNLIKELY(err)) {
+    _allocator.release(rx);
+    return err;
+  }
+
+  // Recalculate the final code size and shrink the memory we allocated for it
+  // in case that some relocations didn't require records in an address table.
+  size_t codeSize = code->codeSize();
+  if (codeSize < estimatedCodeSize)
+    _allocator.shrink(rx, codeSize);
+
+  if (codeSize < estimatedCodeSize)
+    _allocator.shrink(rx, codeSize);
+
+  {
+    VirtMem::ProtectJitReadWriteScope rwScope(rx, codeSize);
+
+    for (Section* section : code->_sections) {
+      size_t offset = size_t(section->offset());
+      size_t bufferSize = size_t(section->bufferSize());
+      size_t virtualSize = size_t(section->virtualSize());
+
+      ASMJIT_ASSERT(offset + bufferSize <= codeSize);
+      memcpy(rw + offset, section->data(), bufferSize);
+
+      if (virtualSize > bufferSize) {
+        ASMJIT_ASSERT(offset + virtualSize <= codeSize);
+        memset(rw + offset + bufferSize, 0, virtualSize - bufferSize);
+      }
+    }
+  }
+
+  *dst = rx;
+  return kErrorOk;
+}
+
+Error JitRuntime::_release(void* p) noexcept {
+  return _allocator.release(p);
+}
+
+ASMJIT_END_NAMESPACE
+
+#endif

data/ext/asmjit/asmjit/src/asmjit/core/jitruntime.h

@@ -0,0 +1,89 @@
+// This file is part of AsmJit project <https://asmjit.com>
+//
+// See asmjit.h or LICENSE.md for license and copyright information
+// SPDX-License-Identifier: Zlib
+
+#ifndef ASMJIT_CORE_JITRUNTIME_H_INCLUDED
+#define ASMJIT_CORE_JITRUNTIME_H_INCLUDED
+
+#include "../core/api-config.h"
+#ifndef ASMJIT_NO_JIT
+
+#include "../core/codeholder.h"
+#include "../core/jitallocator.h"
+#include "../core/target.h"
+
+ASMJIT_BEGIN_NAMESPACE
+
+class CodeHolder;
+
+//! \addtogroup asmjit_virtual_memory
+//! \{
+
+//! JIT execution runtime is a special `Target` that is designed to store and
+//! execute the generated code.
+class ASMJIT_VIRTAPI JitRuntime : public Target {
+public:
+  ASMJIT_NONCOPYABLE(JitRuntime)
+
+  //! Virtual memory allocator.
+  JitAllocator _allocator;
+
+  //! \name Construction & Destruction
+  //! \{
+
+  //! Creates a `JitRuntime` instance.
+  ASMJIT_API explicit JitRuntime(const JitAllocator::CreateParams* params = nullptr) noexcept;
+  //! Destroys the `JitRuntime` instance.
+  ASMJIT_API virtual ~JitRuntime() noexcept;
+
+  inline void reset(ResetPolicy resetPolicy = ResetPolicy::kSoft) noexcept {
+    _allocator.reset(resetPolicy);
+  }
+
+  //! \}
+
+  //! \name Accessors
+  //! \{
+
+  //! Returns the associated `JitAllocator`.
+  inline JitAllocator* allocator() const noexcept { return const_cast<JitAllocator*>(&_allocator); }
+
+  //! \}
+
+  //! \name Utilities
+  //! \{
+
+  // NOTE: To allow passing function pointers to `add()` and `release()` the
+  // virtual methods are prefixed with `_` and called from templates instead.
+
+  //! Allocates memory needed for a code stored in the `CodeHolder` and relocates the code to the pointer allocated.
+  //!
+  //! The beginning of the memory allocated for the function is returned in `dst`. If failed `Error` code is returned
+  //! and `dst` is explicitly set to `nullptr`  (this means that you don't have to set it to null before calling `add()`).
+  template<typename Func>
+  inline Error add(Func* dst, CodeHolder* code) noexcept {
+    return _add(Support::ptr_cast_impl<void**, Func*>(dst), code);
+  }
+
+  //! Releases `p` which was obtained by calling `add()`.
+  template<typename Func>
+  inline Error release(Func p) noexcept {
+    return _release(Support::ptr_cast_impl<void*, Func>(p));
+  }
+
+  //! Type-unsafe version of `add()`.
+  ASMJIT_API virtual Error _add(void** dst, CodeHolder* code) noexcept;
+
+  //! Type-unsafe version of `release()`.
+  ASMJIT_API virtual Error _release(void* p) noexcept;
+
+  //! \}
+};
+
+//! \}
+
+ASMJIT_END_NAMESPACE
+
+#endif
+#endif

data/ext/asmjit/asmjit/src/asmjit/core/logger.cpp

@@ -0,0 +1,69 @@
+// This file is part of AsmJit project <https://asmjit.com>
+//
+// See asmjit.h or LICENSE.md for license and copyright information
+// SPDX-License-Identifier: Zlib
+
+#include "../core/api-build_p.h"
+#ifndef ASMJIT_NO_LOGGING
+
+#include "../core/logger.h"
+#include "../core/string.h"
+#include "../core/support.h"
+
+ASMJIT_BEGIN_NAMESPACE
+
+// Logger - Implementation
+// =======================
+
+Logger::Logger() noexcept
+  : _options() {}
+Logger::~Logger() noexcept {}
+
+Error Logger::logf(const char* fmt, ...) noexcept {
+  Error err;
+  va_list ap;
+
+  va_start(ap, fmt);
+  err = logv(fmt, ap);
+  va_end(ap);
+
+  return err;
+}
+
+Error Logger::logv(const char* fmt, va_list ap) noexcept {
+  StringTmp<2048> sb;
+  ASMJIT_PROPAGATE(sb.appendVFormat(fmt, ap));
+  return log(sb);
+}
+
+// FileLogger - Implementation
+// ===========================
+
+FileLogger::FileLogger(FILE* file) noexcept
+  : _file(file) {}
+FileLogger::~FileLogger() noexcept {}
+
+Error FileLogger::_log(const char* data, size_t size) noexcept {
+  if (!_file)
+    return kErrorOk;
+
+  if (size == SIZE_MAX)
+    size = strlen(data);
+
+  fwrite(data, 1, size, _file);
+  return kErrorOk;
+}
+
+// StringLogger - Implementation
+// =============================
+
+StringLogger::StringLogger() noexcept {}
+StringLogger::~StringLogger() noexcept {}
+
+Error StringLogger::_log(const char* data, size_t size) noexcept {
+  return _content.append(data, size);
+}
+
+ASMJIT_END_NAMESPACE
+
+#endif

data/ext/asmjit/asmjit/src/asmjit/core/logger.h

@@ -0,0 +1,198 @@
+// This file is part of AsmJit project <https://asmjit.com>
+//
+// See asmjit.h or LICENSE.md for license and copyright information
+// SPDX-License-Identifier: Zlib
+
+#ifndef ASMJIT_CORE_LOGGING_H_INCLUDED
+#define ASMJIT_CORE_LOGGING_H_INCLUDED
+
+#include "../core/inst.h"
+#include "../core/string.h"
+#include "../core/formatter.h"
+
+#ifndef ASMJIT_NO_LOGGING
+
+ASMJIT_BEGIN_NAMESPACE
+
+//! \addtogroup asmjit_logging
+//! \{
+
+//! Logging interface.
+//!
+//! This class can be inherited and reimplemented to fit into your own logging needs. When reimplementing a logger
+//! use \ref Logger::_log() method to log customize the output.
+//!
+//! There are two `Logger` implementations offered by AsmJit:
+//!   - \ref FileLogger - logs into a `FILE*`.
+//!   - \ref StringLogger - concatenates all logs into a \ref String.
+class ASMJIT_VIRTAPI Logger {
+public:
+  ASMJIT_BASE_CLASS(Logger)
+  ASMJIT_NONCOPYABLE(Logger)
+
+  //! Format options.
+  FormatOptions _options;
+
+  //! \name Construction & Destruction
+  //! \{
+
+  //! Creates a `Logger` instance.
+  ASMJIT_API Logger() noexcept;
+  //! Destroys the `Logger` instance.
+  ASMJIT_API virtual ~Logger() noexcept;
+
+  //! \}
+
+  //! \name Format Options
+  //! \{
+
+  //! Returns \ref FormatOptions of this logger.
+  inline FormatOptions& options() noexcept { return _options; }
+  //! \overload
+  inline const FormatOptions& options() const noexcept { return _options; }
+  //! Sets formatting options of this Logger to `options`.
+  inline void setOptions(const FormatOptions& options) noexcept { _options = options; }
+  //! Resets formatting options of this Logger to defaults.
+  inline void resetOptions() noexcept { _options.reset(); }
+
+  //! Returns formatting flags.
+  inline FormatFlags flags() const noexcept { return _options.flags(); }
+  //! Tests whether the logger has the given `flag` enabled.
+  inline bool hasFlag(FormatFlags flag) const noexcept { return _options.hasFlag(flag); }
+  //! Sets formatting flags to `flags`.
+  inline void setFlags(FormatFlags flags) noexcept { _options.setFlags(flags); }
+  //! Enables the given formatting `flags`.
+  inline void addFlags(FormatFlags flags) noexcept { _options.addFlags(flags); }
+  //! Disables the given formatting `flags`.
+  inline void clearFlags(FormatFlags flags) noexcept { _options.clearFlags(flags); }
+
+  //! Returns indentation of a given indentation `group`.
+  inline uint32_t indentation(FormatIndentationGroup type) const noexcept { return _options.indentation(type); }
+  //! Sets indentation of the given indentation `group` to `n` spaces.
+  inline void setIndentation(FormatIndentationGroup type, uint32_t n) noexcept { _options.setIndentation(type, n); }
+  //! Resets indentation of the given indentation `group` to 0 spaces.
+  inline void resetIndentation(FormatIndentationGroup type) noexcept { _options.resetIndentation(type); }
+
+  //! Returns padding of a given padding `group`.
+  inline size_t padding(FormatPaddingGroup type) const noexcept { return _options.padding(type); }
+  //! Sets padding of a given padding `group` to `n`.
+  inline void setPadding(FormatPaddingGroup type, uint32_t n) noexcept { _options.setPadding(type, n); }
+  //! Resets padding of a given padding `group` to 0, which means that a default will be used.
+  inline void resetPadding(FormatPaddingGroup type) noexcept { _options.resetPadding(type); }
+
+  //! \}
+
+  //! \name Logging Interface
+  //! \{
+
+  //! Logs `str` - must be reimplemented.
+  //!
+  //! The function can accept either a null terminated string if `size` is `SIZE_MAX` or a non-null terminated
+  //! string of the given `size`. The function cannot assume that the data is null terminated and must handle
+  //! non-null terminated inputs.
+  virtual Error _log(const char* data, size_t size) noexcept = 0;
+
+  //! Logs string `str`, which is either null terminated or having size `size`.
+  inline Error log(const char* data, size_t size = SIZE_MAX) noexcept { return _log(data, size); }
+  //! Logs content of a string `str`.
+  inline Error log(const String& str) noexcept { return _log(str.data(), str.size()); }
+
+  //! Formats the message by using `snprintf()` and then passes the formatted string to \ref _log().
+  ASMJIT_API Error logf(const char* fmt, ...) noexcept;
+
+  //! Formats the message by using `vsnprintf()` and then passes the formatted string to \ref _log().
+  ASMJIT_API Error logv(const char* fmt, va_list ap) noexcept;
+
+  //! \}
+};
+
+//! Logger that can log to a `FILE*`.
+class ASMJIT_VIRTAPI FileLogger : public Logger {
+public:
+  ASMJIT_NONCOPYABLE(FileLogger)
+
+  FILE* _file;
+
+  //! \name Construction & Destruction
+  //! \{
+
+  //! Creates a new `FileLogger` that logs to `FILE*`.
+  ASMJIT_API FileLogger(FILE* file = nullptr) noexcept;
+  //! Destroys the `FileLogger`.
+  ASMJIT_API virtual ~FileLogger() noexcept;
+
+  //! \}
+
+  //! \name Accessors
+  //! \{
+
+  //! Returns the logging output stream or null if the logger has no output stream.
+  inline FILE* file() const noexcept { return _file; }
+
+  //! Sets the logging output stream to `stream` or null.
+  //!
+  //! \note If the `file` is null the logging will be disabled. When a logger is attached to `CodeHolder` or any
+  //! emitter the logging API will always be called regardless of the output file. This means that if you really
+  //! want to disable logging at emitter level you must not attach a logger to it.
+  inline void setFile(FILE* file) noexcept { _file = file; }
+
+  //! \}
+
+  ASMJIT_API Error _log(const char* data, size_t size = SIZE_MAX) noexcept override;
+};
+
+//! Logger that stores everything in an internal string buffer.
+class ASMJIT_VIRTAPI StringLogger : public Logger {
+public:
+  ASMJIT_NONCOPYABLE(StringLogger)
+
+  //! Logger data as string.
+  String _content;
+
+  //! \name Construction & Destruction
+  //! \{
+
+  //! Create new `StringLogger`.
+  ASMJIT_API StringLogger() noexcept;
+  //! Destroys the `StringLogger`.
+  ASMJIT_API virtual ~StringLogger() noexcept;
+
+  //! \}
+
+  //! \name Logger Data Accessors
+  //! \{
+
+  //! Returns the content of the logger as \ref String.
+  //!
+  //! It can be moved, if desired.
+  inline String& content() noexcept { return _content; }
+  //! \overload
+  inline const String& content() const noexcept { return _content; }
+
+  //! Returns aggregated logger data as `char*` pointer.
+  //!
+  //! The pointer is owned by `StringLogger`, it can't be modified or freed.
+  inline const char* data() const noexcept { return _content.data(); }
+  //! Returns size of the data returned by `data()`.
+  inline size_t dataSize() const noexcept { return _content.size(); }
+
+  //! \}
+
+  //! \name Logger Data Manipulation
+  //! \{
+
+  //! Clears the accumulated logger data.
+  inline void clear() noexcept { _content.clear(); }
+
+  //! \}
+
+  ASMJIT_API Error _log(const char* data, size_t size = SIZE_MAX) noexcept override;
+};
+
+//! \}
+
+ASMJIT_END_NAMESPACE
+
+#endif
+
+#endif // ASMJIT_CORE_LOGGER_H_INCLUDED