asmjit 0.2.0 → 0.2.2

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

@@ -0,0 +1,242 @@
+// 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_VIRTMEM_H_INCLUDED
+#define ASMJIT_CORE_VIRTMEM_H_INCLUDED
+
+#include "../core/api-config.h"
+#ifndef ASMJIT_NO_JIT
+
+#include "../core/globals.h"
+
+ASMJIT_BEGIN_NAMESPACE
+
+//! \addtogroup asmjit_virtual_memory
+//! \{
+
+//! Virtual memory management.
+namespace VirtMem {
+
+//! Flushes instruction cache in the given region.
+//!
+//! Only useful on non-x86 architectures, however, it's a good practice to call it on any platform to make your
+//! code more portable.
+ASMJIT_API void flushInstructionCache(void* p, size_t size) noexcept;
+
+//! Virtual memory information.
+struct Info {
+  //! Virtual memory page size.
+  uint32_t pageSize;
+  //! Virtual memory page granularity.
+  uint32_t pageGranularity;
+};
+
+//! Returns virtual memory information, see `VirtMem::Info` for more details.
+ASMJIT_API Info info() noexcept;
+
+//! Virtual memory access and mmap-specific flags.
+enum class MemoryFlags : uint32_t {
+  //! No flags.
+  kNone = 0,
+
+  //! Memory is readable.
+  kAccessRead = 0x00000001u,
+
+  //! Memory is writable.
+  kAccessWrite = 0x00000002u,
+
+  //! Memory is executable.
+  kAccessExecute = 0x00000004u,
+
+  //! A combination of \ref MemoryFlags::kAccessRead and \ref MemoryFlags::kAccessWrite.
+  kAccessReadWrite = kAccessRead | kAccessWrite,
+
+  //! A combination of \ref MemoryFlags::kAccessRead, \ref MemoryFlags::kAccessWrite.
+  kAccessRW = kAccessRead | kAccessWrite,
+
+  //! A combination of \ref MemoryFlags::kAccessRead and \ref MemoryFlags::kAccessExecute.
+  kAccessRX = kAccessRead | kAccessExecute,
+
+  //! A combination of \ref MemoryFlags::kAccessRead, \ref MemoryFlags::kAccessWrite, and
+  //! \ref MemoryFlags::kAccessExecute.
+  kAccessRWX = kAccessRead | kAccessWrite | kAccessExecute,
+
+  //! Use a `MAP_JIT` flag available on Apple platforms (introduced by Mojave), which allows JIT code to be executed
+  //! in MAC bundles. This flag is not turned on by default, because when a process uses `fork()` the child process
+  //! has no access to the pages mapped with `MAP_JIT`, which could break code that doesn't expect this behavior.
+  //!
+  //! \note This flag can only be used with \ref VirtMem::alloc().
+  kMMapEnableMapJit = 0x00000010u,
+
+  //! Pass `PROT_MAX(PROT_READ)` to mmap() on platforms that support `PROT_MAX`.
+  //!
+  //! \note This flag can only be used with \ref VirtMem::alloc().
+  kMMapMaxAccessRead = 0x00000020u,
+  //! Pass `PROT_MAX(PROT_WRITE)` to mmap() on platforms that support `PROT_MAX`.
+  //!
+  //! \note This flag can only be used with \ref VirtMem::alloc().
+  kMMapMaxAccessWrite = 0x00000040u,
+  //! Pass `PROT_MAX(PROT_EXEC)` to mmap() on platforms that support `PROT_MAX`.
+  //!
+  //! \note This flag can only be used with \ref VirtMem::alloc().
+  kMMapMaxAccessExecute = 0x00000080u,
+
+  //! A combination of \ref MemoryFlags::kMMapMaxAccessRead and \ref MemoryFlags::kMMapMaxAccessWrite.
+  kMMapMaxAccessReadWrite = kMMapMaxAccessRead | kMMapMaxAccessWrite,
+
+  //! A combination of \ref MemoryFlags::kMMapMaxAccessRead and \ref MemoryFlags::kMMapMaxAccessWrite.
+  kMMapMaxAccessRW = kMMapMaxAccessRead | kMMapMaxAccessWrite,
+
+  //! A combination of \ref MemoryFlags::kMMapMaxAccessRead and \ref MemoryFlags::kMMapMaxAccessExecute.
+  kMMapMaxAccessRX = kMMapMaxAccessRead | kMMapMaxAccessExecute,
+
+  //! A combination of \ref MemoryFlags::kMMapMaxAccessRead, \ref MemoryFlags::kMMapMaxAccessWrite, \ref
+  //! MemoryFlags::kMMapMaxAccessExecute.
+  kMMapMaxAccessRWX = kMMapMaxAccessRead | kMMapMaxAccessWrite | kMMapMaxAccessExecute,
+
+  //! Not an access flag, only used by `allocDualMapping()` to override the default allocation strategy to always use
+  //! a 'tmp' directory instead of "/dev/shm" (on POSIX platforms). Please note that this flag will be ignored if the
+  //! operating system allows to allocate an executable memory by a different API than `open()` or `shm_open()`. For
+  //! example on Linux `memfd_create()` is preferred and on BSDs `shm_open(SHM_ANON, ...)` is used if SHM_ANON is
+  //! defined.
+  //!
+  //! \note This flag can only be used with \ref VirtMem::alloc().
+  kMappingPreferTmp = 0x80000000u
+};
+ASMJIT_DEFINE_ENUM_FLAGS(MemoryFlags)
+
+//! Allocates virtual memory by either using `mmap()` (POSIX) or `VirtualAlloc()` (Windows).
+//!
+//! \note `size` should be aligned to page size, use \ref VirtMem::info() to obtain it. Invalid size will not be
+//! corrected by the implementation and the allocation would not succeed in such case.
+ASMJIT_API Error alloc(void** p, size_t size, MemoryFlags flags) noexcept;
+
+//! Releases virtual memory previously allocated by \ref VirtMem::alloc().
+//!
+//! \note The size must be the same as used by \ref VirtMem::alloc(). If the size is not the same value the call
+//! will fail on any POSIX system, but pass on Windows, because it's implemented differently.
+ASMJIT_API Error release(void* p, size_t size) noexcept;
+
+//! A cross-platform wrapper around `mprotect()` (POSIX) and `VirtualProtect()` (Windows).
+ASMJIT_API Error protect(void* p, size_t size, MemoryFlags flags) noexcept;
+
+//! Dual memory mapping used to map an anonymous memory into two memory regions where one region is read-only, but
+//! executable, and the second region is read+write, but not executable. See \ref VirtMem::allocDualMapping() for
+//! more details.
+struct DualMapping {
+  //! Pointer to data with 'Read+Execute' access (this memory is not writable).
+  void* rx;
+  //! Pointer to data with 'Read+Write' access (this memory is not executable).
+  void* rw;
+};
+
+//! Allocates virtual memory and creates two views of it where the first view has no write access. This is an addition
+//! to the API that should be used in cases in which the operating system either enforces W^X security policy or the
+//! application wants to use this policy by default to improve security and prevent an accidental (or purposed)
+//! self-modifying code.
+//!
+//! The memory returned in the `dm` are two independent mappings of the same shared memory region. You must use
+//! \ref VirtMem::releaseDualMapping() to release it when it's no longer needed. Never use `VirtMem::release()` to
+//! release the memory returned by `allocDualMapping()` as that would fail on Windows.
+//!
+//! \remarks Both pointers in `dm` would be set to `nullptr` if the function fails.
+ASMJIT_API Error allocDualMapping(DualMapping* dm, size_t size, MemoryFlags flags) noexcept;
+
+//! Releases virtual memory mapping previously allocated by \ref VirtMem::allocDualMapping().
+//!
+//! \remarks Both pointers in `dm` would be set to `nullptr` if the function succeeds.
+ASMJIT_API Error releaseDualMapping(DualMapping* dm, size_t size) noexcept;
+
+//! Hardened runtime flags.
+enum class HardenedRuntimeFlags : uint32_t {
+  //! No flags.
+  kNone = 0,
+
+  //! Hardened runtime is enabled - it's not possible to have "Write & Execute" memory protection. The runtime
+  //! enforces W^X (either write or execute).
+  //!
+  //! \note If the runtime is hardened it means that an operating system specific protection is used. For example on
+  //! MacOS platform it's possible to allocate memory with MAP_JIT flag and then use `pthread_jit_write_protect_np()`
+  //! to temporarily swap access permissions for the current thread. Dual mapping is also a possibility on X86/X64
+  //! architecture.
+  kEnabled = 0x00000001u,
+
+  //! Read+Write+Execute can only be allocated with MAP_JIT flag (Apple specific).
+  kMapJit = 0x00000002u
+};
+ASMJIT_DEFINE_ENUM_FLAGS(HardenedRuntimeFlags)
+
+//! Hardened runtime information.
+struct HardenedRuntimeInfo {
+  //! Hardened runtime flags.
+  HardenedRuntimeFlags flags;
+};
+
+//! Returns runtime features provided by the OS.
+ASMJIT_API HardenedRuntimeInfo hardenedRuntimeInfo() noexcept;
+
+//! Values that can be used with `protectJitMemory()` function.
+enum class ProtectJitAccess : uint32_t {
+  //! Protect JIT memory with Read+Write permissions.
+  kReadWrite = 0,
+  //! Protect JIT memory with Read+Execute permissions.
+  kReadExecute = 1
+};
+
+//! Protects access of memory mapped with MAP_JIT flag for the current thread.
+//!
+//! \note This feature is only available on Apple hardware (AArch64) at the moment and and uses a non-portable
+//! `pthread_jit_write_protect_np()` call when available.
+//!
+//! This function must be called before and after a memory mapped with MAP_JIT flag is modified. Example:
+//!
+//! ```
+//! void* codePtr = ...;
+//! size_t codeSize = ...;
+//!
+//! VirtMem::protectJitMemory(VirtMem::ProtectJitAccess::kReadWrite);
+//! memcpy(codePtr, source, codeSize);
+//! VirtMem::protectJitMemory(VirtMem::ProtectJitAccess::kReadExecute);
+//! VirtMem::flushInstructionCache(codePtr, codeSize);
+//! ```
+//!
+//! See \ref ProtectJitReadWriteScope, which makes it simpler than the code above.
+ASMJIT_API void protectJitMemory(ProtectJitAccess access) noexcept;
+
+//! JIT protection scope that prepares the given memory block to be written to in the current thread.
+//!
+//! It calls `VirtMem::protectJitMemory(VirtMem::ProtectJitAccess::kReadWrite)` at construction time and
+//! `VirtMem::protectJitMemory(VirtMem::ProtectJitAccess::kReadExecute)` combined with `flushInstructionCache()`
+//! in destructor. The purpose of this class is to make writing to JIT memory easier.
+class ProtectJitReadWriteScope {
+public:
+  void* _rxPtr;
+  size_t _size;
+
+  //! Makes the given memory block RW protected.
+  ASMJIT_FORCE_INLINE ProtectJitReadWriteScope(void* rxPtr, size_t size) noexcept
+    : _rxPtr(rxPtr),
+      _size(size) {
+    protectJitMemory(ProtectJitAccess::kReadWrite);
+  }
+
+  // Not copyable.
+  ProtectJitReadWriteScope(const ProtectJitReadWriteScope& other) = delete;
+
+  //! Makes the memory block RX protected again and flushes instruction cache.
+  ASMJIT_FORCE_INLINE  ~ProtectJitReadWriteScope() noexcept {
+    protectJitMemory(ProtectJitAccess::kReadExecute);
+    flushInstructionCache(_rxPtr, _size);
+  }
+};
+
+} // VirtMem
+
+//! \}
+
+ASMJIT_END_NAMESPACE
+
+#endif
+#endif // ASMJIT_CORE_VIRTMEM_H_INCLUDED

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

@@ -0,0 +1,353 @@
+// 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"
+#include "../core/support.h"
+#include "../core/zone.h"
+
+ASMJIT_BEGIN_NAMESPACE
+
+// Zone - Globals
+// ==============
+
+// Zero size block used by `Zone` that doesn't have any memory allocated. Should be allocated in read-only memory
+// and should never be modified.
+const Zone::Block Zone::_zeroBlock = { nullptr, nullptr, 0 };
+
+// Zone - Init & Reset
+// ===================
+
+void Zone::_init(size_t blockSize, size_t blockAlignment, const Support::Temporary* temporary) noexcept {
+  ASMJIT_ASSERT(blockSize >= kMinBlockSize);
+  ASMJIT_ASSERT(blockSize <= kMaxBlockSize);
+  ASMJIT_ASSERT(blockAlignment <= 64);
+
+  // Just to make the compiler happy...
+  constexpr size_t kBlockSizeMask = (Support::allOnes<size_t>() >> 4);
+  constexpr size_t kBlockAlignmentShiftMask = 0x7u;
+
+  _assignZeroBlock();
+  _blockSize = blockSize & kBlockSizeMask;
+  _isTemporary = temporary != nullptr;
+  _blockAlignmentShift = Support::ctz(blockAlignment) & kBlockAlignmentShiftMask;
+
+  // Setup the first [temporary] block, if necessary.
+  if (temporary) {
+    Block* block = temporary->data<Block>();
+    block->prev = nullptr;
+    block->next = nullptr;
+
+    ASMJIT_ASSERT(temporary->size() >= kBlockSize);
+    block->size = temporary->size() - kBlockSize;
+
+    _assignBlock(block);
+  }
+}
+
+void Zone::reset(ResetPolicy resetPolicy) noexcept {
+  Block* cur = _block;
+
+  // Can't be altered.
+  if (cur == &_zeroBlock)
+    return;
+
+  if (resetPolicy == ResetPolicy::kHard) {
+    Block* initial = const_cast<Zone::Block*>(&_zeroBlock);
+    _ptr = initial->data();
+    _end = initial->data();
+    _block = initial;
+
+    // Since cur can be in the middle of the double-linked list, we have to traverse both directions (`prev` and
+    // `next`) separately to visit all.
+    Block* next = cur->next;
+    do {
+      Block* prev = cur->prev;
+
+      // If this is the first block and this ZoneTmp is temporary then the first block is statically allocated.
+      // We cannot free it and it makes sense to keep it even when this is hard reset.
+      if (prev == nullptr && _isTemporary) {
+        cur->prev = nullptr;
+        cur->next = nullptr;
+        _assignBlock(cur);
+        break;
+      }
+
+      ::free(cur);
+      cur = prev;
+    } while (cur);
+
+    cur = next;
+    while (cur) {
+      next = cur->next;
+      ::free(cur);
+      cur = next;
+    }
+  }
+  else {
+    while (cur->prev)
+      cur = cur->prev;
+    _assignBlock(cur);
+  }
+}
+
+// Zone - Alloc
+// ============
+
+void* Zone::_alloc(size_t size, size_t alignment) noexcept {
+  Block* curBlock = _block;
+  Block* next = curBlock->next;
+
+  size_t rawBlockAlignment = blockAlignment();
+  size_t minimumAlignment = Support::max<size_t>(alignment, rawBlockAlignment);
+
+  // If the `Zone` has been cleared the current block doesn't have to be the last one. Check if there is a block
+  // that can be used instead of allocating a new one. If there is a `next` block it's completely unused, we don't
+  // have to check for remaining bytes in that case.
+  if (next) {
+    uint8_t* ptr = Support::alignUp(next->data(), minimumAlignment);
+    uint8_t* end = Support::alignDown(next->data() + next->size, rawBlockAlignment);
+
+    if (size <= (size_t)(end - ptr)) {
+      _block = next;
+      _ptr = ptr + size;
+      _end = Support::alignDown(next->data() + next->size, rawBlockAlignment);
+      return static_cast<void*>(ptr);
+    }
+  }
+
+  size_t blockAlignmentOverhead = alignment - Support::min<size_t>(alignment, Globals::kAllocAlignment);
+  size_t newSize = Support::max(blockSize(), size);
+
+  // Prevent arithmetic overflow.
+  if (ASMJIT_UNLIKELY(newSize > SIZE_MAX - kBlockSize - blockAlignmentOverhead))
+    return nullptr;
+
+  // Allocate new block - we add alignment overhead to `newSize`, which becomes the new block size, and we also add
+  // `kBlockOverhead` to the allocator as it includes members of `Zone::Block` structure.
+  newSize += blockAlignmentOverhead;
+  Block* newBlock = static_cast<Block*>(::malloc(newSize + kBlockSize));
+
+  if (ASMJIT_UNLIKELY(!newBlock))
+    return nullptr;
+
+  // Align the pointer to `minimumAlignment` and adjust the size of this block accordingly. It's the same as using
+  // `minimumAlignment - Support::alignUpDiff()`, just written differently.
+  {
+    newBlock->prev = nullptr;
+    newBlock->next = nullptr;
+    newBlock->size = newSize;
+
+    if (curBlock != &_zeroBlock) {
+      newBlock->prev = curBlock;
+      curBlock->next = newBlock;
+
+      // Does only happen if there is a next block, but the requested memory can't fit into it. In this case a new
+      // buffer is allocated and inserted between the current block and the next one.
+      if (next) {
+        newBlock->next = next;
+        next->prev = newBlock;
+      }
+    }
+
+    uint8_t* ptr = Support::alignUp(newBlock->data(), minimumAlignment);
+    uint8_t* end = Support::alignDown(newBlock->data() + newSize, rawBlockAlignment);
+
+    _ptr = ptr + size;
+    _end = end;
+    _block = newBlock;
+
+    ASMJIT_ASSERT(_ptr <= _end);
+    return static_cast<void*>(ptr);
+  }
+}
+
+void* Zone::allocZeroed(size_t size, size_t alignment) noexcept {
+  void* p = alloc(size, alignment);
+  if (ASMJIT_UNLIKELY(!p))
+    return p;
+  return memset(p, 0, size);
+}
+
+void* Zone::dup(const void* data, size_t size, bool nullTerminate) noexcept {
+  if (ASMJIT_UNLIKELY(!data || !size))
+    return nullptr;
+
+  ASMJIT_ASSERT(size != SIZE_MAX);
+  uint8_t* m = allocT<uint8_t>(size + nullTerminate);
+  if (ASMJIT_UNLIKELY(!m)) return nullptr;
+
+  memcpy(m, data, size);
+  if (nullTerminate) m[size] = '\0';
+
+  return static_cast<void*>(m);
+}
+
+char* Zone::sformat(const char* fmt, ...) noexcept {
+  if (ASMJIT_UNLIKELY(!fmt))
+    return nullptr;
+
+  char buf[512];
+  size_t size;
+  va_list ap;
+
+  va_start(ap, fmt);
+  size = unsigned(vsnprintf(buf, ASMJIT_ARRAY_SIZE(buf) - 1, fmt, ap));
+  va_end(ap);
+
+  buf[size++] = 0;
+  return static_cast<char*>(dup(buf, size));
+}
+
+// ZoneAllocator - Utilities
+// =========================
+
+#if defined(ASMJIT_BUILD_DEBUG)
+static bool ZoneAllocator_hasDynamicBlock(ZoneAllocator* self, ZoneAllocator::DynamicBlock* block) noexcept {
+  ZoneAllocator::DynamicBlock* cur = self->_dynamicBlocks;
+  while (cur) {
+    if (cur == block)
+      return true;
+    cur = cur->next;
+  }
+  return false;
+}
+#endif
+
+// ZoneAllocator - Init & Reset
+// ============================
+
+void ZoneAllocator::reset(Zone* zone) noexcept {
+  // Free dynamic blocks.
+  DynamicBlock* block = _dynamicBlocks;
+  while (block) {
+    DynamicBlock* next = block->next;
+    ::free(block);
+    block = next;
+  }
+
+  // Zero the entire class and initialize to the given `zone`.
+  memset(this, 0, sizeof(*this));
+  _zone = zone;
+}
+
+// asmjit::ZoneAllocator - Alloc & Release
+// =======================================
+
+void* ZoneAllocator::_alloc(size_t size, size_t& allocatedSize) noexcept {
+  ASMJIT_ASSERT(isInitialized());
+
+  // Use the memory pool only if the requested block has a reasonable size.
+  uint32_t slot;
+  if (_getSlotIndex(size, slot, allocatedSize)) {
+    // Slot reuse.
+    uint8_t* p = reinterpret_cast<uint8_t*>(_slots[slot]);
+    size = allocatedSize;
+
+    if (p) {
+      _slots[slot] = reinterpret_cast<Slot*>(p)->next;
+      return p;
+    }
+
+    _zone->align(kBlockAlignment);
+    p = _zone->ptr();
+    size_t remain = (size_t)(_zone->end() - p);
+
+    if (ASMJIT_LIKELY(remain >= size)) {
+      _zone->setPtr(p + size);
+      return p;
+    }
+    else {
+      // Distribute the remaining memory to suitable slots, if possible.
+      if (remain >= kLoGranularity) {
+        do {
+          size_t distSize = Support::min<size_t>(remain, kLoMaxSize);
+          uint32_t distSlot = uint32_t((distSize - kLoGranularity) / kLoGranularity);
+          ASMJIT_ASSERT(distSlot < kLoCount);
+
+          reinterpret_cast<Slot*>(p)->next = _slots[distSlot];
+          _slots[distSlot] = reinterpret_cast<Slot*>(p);
+
+          p += distSize;
+          remain -= distSize;
+        } while (remain >= kLoGranularity);
+        _zone->setPtr(p);
+      }
+
+      p = static_cast<uint8_t*>(_zone->_alloc(size, kBlockAlignment));
+      if (ASMJIT_UNLIKELY(!p)) {
+        allocatedSize = 0;
+        return nullptr;
+      }
+
+      return p;
+    }
+  }
+  else {
+    // Allocate a dynamic block.
+    size_t kBlockOverhead = sizeof(DynamicBlock) + sizeof(DynamicBlock*) + kBlockAlignment;
+
+    // Handle a possible overflow.
+    if (ASMJIT_UNLIKELY(kBlockOverhead >= SIZE_MAX - size))
+      return nullptr;
+
+    void* p = ::malloc(size + kBlockOverhead);
+    if (ASMJIT_UNLIKELY(!p)) {
+      allocatedSize = 0;
+      return nullptr;
+    }
+
+    // Link as first in `_dynamicBlocks` double-linked list.
+    DynamicBlock* block = static_cast<DynamicBlock*>(p);
+    DynamicBlock* next = _dynamicBlocks;
+
+    if (next)
+      next->prev = block;
+
+    block->prev = nullptr;
+    block->next = next;
+    _dynamicBlocks = block;
+
+    // Align the pointer to the guaranteed alignment and store `DynamicBlock`
+    // at the beginning of the memory block, so `_releaseDynamic()` can find it.
+    p = Support::alignUp(static_cast<uint8_t*>(p) + sizeof(DynamicBlock) + sizeof(DynamicBlock*), kBlockAlignment);
+    reinterpret_cast<DynamicBlock**>(p)[-1] = block;
+
+    allocatedSize = size;
+    return p;
+  }
+}
+
+void* ZoneAllocator::_allocZeroed(size_t size, size_t& allocatedSize) noexcept {
+  ASMJIT_ASSERT(isInitialized());
+
+  void* p = _alloc(size, allocatedSize);
+  if (ASMJIT_UNLIKELY(!p)) return p;
+  return memset(p, 0, allocatedSize);
+}
+
+void ZoneAllocator::_releaseDynamic(void* p, size_t size) noexcept {
+  DebugUtils::unused(size);
+  ASMJIT_ASSERT(isInitialized());
+
+  // Pointer to `DynamicBlock` is stored at [-1].
+  DynamicBlock* block = reinterpret_cast<DynamicBlock**>(p)[-1];
+  ASMJIT_ASSERT(ZoneAllocator_hasDynamicBlock(this, block));
+
+  // Unlink and free.
+  DynamicBlock* prev = block->prev;
+  DynamicBlock* next = block->next;
+
+  if (prev)
+    prev->next = next;
+  else
+    _dynamicBlocks = next;
+
+  if (next)
+    next->prev = prev;
+
+  ::free(block);
+}
+
+ASMJIT_END_NAMESPACE