asmjit 0.2.0 → 0.2.2

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

@@ -0,0 +1,209 @@
+// 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_ZONELIST_H_INCLUDED
+#define ASMJIT_CORE_ZONELIST_H_INCLUDED
+
+#include "../core/support.h"
+
+ASMJIT_BEGIN_NAMESPACE
+
+//! \addtogroup asmjit_zone
+//! \{
+
+//! Node used by \ref ZoneList template.
+template<typename NodeT>
+class ZoneListNode {
+public:
+  ASMJIT_NONCOPYABLE(ZoneListNode)
+
+  //! \name Constants
+  //! \{
+
+  enum : size_t {
+    kNodeIndexPrev = 0,
+    kNodeIndexNext = 1
+  };
+
+  //! \}
+
+  //! \name Members
+  //! \{
+
+  NodeT* _listNodes[2];
+
+  //! \}
+
+  //! \name Construction & Destruction
+  //! \{
+
+  inline ZoneListNode() noexcept
+    : _listNodes { nullptr, nullptr } {}
+
+  inline ZoneListNode(ZoneListNode&& other) noexcept
+    : _listNodes { other._listNodes[0], other._listNodes[1] } {}
+
+  //! \}
+
+  //! \name Accessors
+  //! \{
+
+  inline bool hasPrev() const noexcept { return _listNodes[kNodeIndexPrev] != nullptr; }
+  inline bool hasNext() const noexcept { return _listNodes[kNodeIndexNext] != nullptr; }
+
+  inline NodeT* prev() const noexcept { return _listNodes[kNodeIndexPrev]; }
+  inline NodeT* next() const noexcept { return _listNodes[kNodeIndexNext]; }
+
+  //! \}
+};
+
+//! Zone allocated list container that uses nodes of `NodeT` type.
+template <typename NodeT>
+class ZoneList {
+public:
+  ASMJIT_NONCOPYABLE(ZoneList)
+
+  //! \name Constants
+  //! \{
+
+  enum : size_t {
+    kNodeIndexFirst = 0,
+    kNodeIndexLast = 1
+  };
+
+  //! \}
+
+  //! \name Members
+  //! \{
+
+  NodeT* _nodes[2];
+
+  //! \}
+
+  //! \name Construction & Destruction
+  //! \{
+
+  inline ZoneList() noexcept
+    : _nodes { nullptr, nullptr } {}
+
+  inline ZoneList(ZoneList&& other) noexcept
+    : _nodes { other._nodes[0], other._nodes[1] } {}
+
+  inline void reset() noexcept {
+    _nodes[0] = nullptr;
+    _nodes[1] = nullptr;
+  }
+
+  //! \}
+
+  //! \name Accessors
+  //! \{
+
+  inline bool empty() const noexcept { return _nodes[0] == nullptr; }
+  inline NodeT* first() const noexcept { return _nodes[kNodeIndexFirst]; }
+  inline NodeT* last() const noexcept { return _nodes[kNodeIndexLast]; }
+
+  //! \}
+
+  //! \name Utilities
+  //! \{
+
+  inline void swap(ZoneList& other) noexcept {
+    std::swap(_nodes[0], other._nodes[0]);
+    std::swap(_nodes[1], other._nodes[1]);
+  }
+
+  // Can be used to both append and prepend.
+  inline void _addNode(NodeT* node, size_t dir) noexcept {
+    NodeT* prev = _nodes[dir];
+
+    node->_listNodes[!dir] = prev;
+    _nodes[dir] = node;
+    if (prev)
+      prev->_listNodes[dir] = node;
+    else
+      _nodes[!dir] = node;
+  }
+
+  // Can be used to both append and prepend.
+  inline void _insertNode(NodeT* ref, NodeT* node, size_t dir) noexcept {
+    ASMJIT_ASSERT(ref != nullptr);
+
+    NodeT* prev = ref;
+    NodeT* next = ref->_listNodes[dir];
+
+    prev->_listNodes[dir] = node;
+    if (next)
+      next->_listNodes[!dir] = node;
+    else
+      _nodes[dir] = node;
+
+    node->_listNodes[!dir] = prev;
+    node->_listNodes[ dir] = next;
+  }
+
+  inline void append(NodeT* node) noexcept { _addNode(node, kNodeIndexLast); }
+  inline void prepend(NodeT* node) noexcept { _addNode(node, kNodeIndexFirst); }
+
+  inline void insertAfter(NodeT* ref, NodeT* node) noexcept { _insertNode(ref, node, NodeT::kNodeIndexNext); }
+  inline void insertBefore(NodeT* ref, NodeT* node) noexcept { _insertNode(ref, node, NodeT::kNodeIndexPrev); }
+
+  inline NodeT* unlink(NodeT* node) noexcept {
+    NodeT* prev = node->prev();
+    NodeT* next = node->next();
+
+    if (prev) { prev->_listNodes[1] = next; node->_listNodes[0] = nullptr; } else { _nodes[0] = next; }
+    if (next) { next->_listNodes[0] = prev; node->_listNodes[1] = nullptr; } else { _nodes[1] = prev; }
+
+    node->_listNodes[0] = nullptr;
+    node->_listNodes[1] = nullptr;
+
+    return node;
+  }
+
+  inline NodeT* popFirst() noexcept {
+    NodeT* node = _nodes[0];
+    ASMJIT_ASSERT(node != nullptr);
+
+    NodeT* next = node->next();
+    _nodes[0] = next;
+
+    if (next) {
+      next->_listNodes[0] = nullptr;
+      node->_listNodes[1] = nullptr;
+    }
+    else {
+      _nodes[1] = nullptr;
+    }
+
+    return node;
+  }
+
+  inline NodeT* pop() noexcept {
+    NodeT* node = _nodes[1];
+    ASMJIT_ASSERT(node != nullptr);
+
+    NodeT* prev = node->prev();
+    _nodes[1] = prev;
+
+    if (prev) {
+      prev->_listNodes[1] = nullptr;
+      node->_listNodes[0] = nullptr;
+    }
+    else {
+      _nodes[0] = nullptr;
+    }
+
+    return node;
+  }
+
+  //! \}
+};
+
+//! \}
+
+ASMJIT_END_NAMESPACE
+
+#endif // ASMJIT_CORE_ZONELIST_H_INCLUDED

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

@@ -0,0 +1,176 @@
+// 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/zone.h"
+#include "../core/zonestack.h"
+
+ASMJIT_BEGIN_NAMESPACE
+
+// ZoneStackBase - Init & Reset
+// ============================
+
+Error ZoneStackBase::_init(ZoneAllocator* allocator, size_t middleIndex) noexcept {
+  ZoneAllocator* oldAllocator = _allocator;
+
+  if (oldAllocator) {
+    Block* block = _block[kBlockIndexFirst];
+    while (block) {
+      Block* next = block->next();
+      oldAllocator->release(block, kBlockSize);
+      block = next;
+    }
+
+    _allocator = nullptr;
+    _block[kBlockIndexFirst] = nullptr;
+    _block[kBlockIndexLast] = nullptr;
+  }
+
+  if (allocator) {
+    Block* block = static_cast<Block*>(allocator->alloc(kBlockSize));
+    if (ASMJIT_UNLIKELY(!block))
+      return DebugUtils::errored(kErrorOutOfMemory);
+
+    block->_link[kBlockIndexPrev] = nullptr;
+    block->_link[kBlockIndexNext] = nullptr;
+    block->_start = (uint8_t*)block + middleIndex;
+    block->_end = (uint8_t*)block + middleIndex;
+
+    _allocator = allocator;
+    _block[kBlockIndexFirst] = block;
+    _block[kBlockIndexLast] = block;
+  }
+
+  return kErrorOk;
+}
+
+// ZoneStackBase - Operations
+// ==========================
+
+Error ZoneStackBase::_prepareBlock(uint32_t side, size_t initialIndex) noexcept {
+  ASMJIT_ASSERT(isInitialized());
+
+  Block* prev = _block[side];
+  ASMJIT_ASSERT(!prev->empty());
+
+  Block* block = _allocator->allocT<Block>(kBlockSize);
+  if (ASMJIT_UNLIKELY(!block))
+    return DebugUtils::errored(kErrorOutOfMemory);
+
+  block->_link[ side] = nullptr;
+  block->_link[!side] = prev;
+  block->_start = (uint8_t*)block + initialIndex;
+  block->_end = (uint8_t*)block + initialIndex;
+
+  prev->_link[side] = block;
+  _block[side] = block;
+
+  return kErrorOk;
+}
+
+void ZoneStackBase::_cleanupBlock(uint32_t side, size_t middleIndex) noexcept {
+  Block* block = _block[side];
+  ASMJIT_ASSERT(block->empty());
+
+  Block* prev = block->_link[!side];
+  if (prev) {
+    ASMJIT_ASSERT(prev->_link[side] == block);
+    _allocator->release(block, kBlockSize);
+
+    prev->_link[side] = nullptr;
+    _block[side] = prev;
+  }
+  else if (_block[!side] == block) {
+    // If the container becomes empty center both pointers in the remaining block.
+    block->_start = (uint8_t*)block + middleIndex;
+    block->_end = (uint8_t*)block + middleIndex;
+  }
+}
+
+// ZoneStack - Tests
+// =================
+
+#if defined(ASMJIT_TEST)
+template<typename T>
+static void test_zone_stack(ZoneAllocator* allocator, const char* typeName) {
+  ZoneStack<T> stack;
+
+  INFO("Testing ZoneStack<%s>", typeName);
+  INFO("  (%d items per one Block)", ZoneStack<T>::kNumBlockItems);
+
+  EXPECT(stack.init(allocator) == kErrorOk);
+  EXPECT(stack.empty(), "Stack must be empty after `init()`");
+
+  EXPECT(stack.append(42) == kErrorOk);
+  EXPECT(!stack.empty()        , "Stack must not be empty after an item has been appended");
+  EXPECT(stack.pop() == 42     , "Stack.pop() must return the item that has been appended last");
+  EXPECT(stack.empty()         , "Stack must be empty after the last item has been removed");
+
+  EXPECT(stack.prepend(43) == kErrorOk);
+  EXPECT(!stack.empty()        , "Stack must not be empty after an item has been prepended");
+  EXPECT(stack.popFirst() == 43, "Stack.popFirst() must return the item that has been prepended last");
+  EXPECT(stack.empty()         , "Stack must be empty after the last item has been removed");
+
+  int i;
+  int iMin =-100000;
+  int iMax = 100000;
+
+  INFO("Validating prepend() & popFirst()");
+  for (i = iMax; i >= 0; i--) stack.prepend(T(i));
+  for (i = 0; i <= iMax; i++) {
+    T item = stack.popFirst();
+    EXPECT(i == item, "Item '%d' didn't match the item '%lld' popped", i, (long long)item);
+    if (!stack.empty()) {
+      item = stack.popFirst();
+      EXPECT(i + 1 == item, "Item '%d' didn't match the item '%lld' popped", i + 1, (long long)item);
+      stack.prepend(item);
+    }
+  }
+  EXPECT(stack.empty());
+
+  INFO("Validating append() & pop()");
+  for (i = 0; i <= iMax; i++) stack.append(T(i));
+  for (i = iMax; i >= 0; i--) {
+    T item = stack.pop();
+    EXPECT(i == item, "Item '%d' didn't match the item '%lld' popped", i, (long long)item);
+    if (!stack.empty()) {
+      item = stack.pop();
+      EXPECT(i - 1 == item, "Item '%d' didn't match the item '%lld' popped", i - 1, (long long)item);
+      stack.append(item);
+    }
+  }
+  EXPECT(stack.empty());
+
+  INFO("Validating append()/prepend() & popFirst()");
+  for (i = 1; i <= iMax; i++) stack.append(T(i));
+  for (i = 0; i >= iMin; i--) stack.prepend(T(i));
+
+  for (i = iMin; i <= iMax; i++) {
+    T item = stack.popFirst();
+    EXPECT(i == item, "Item '%d' didn't match the item '%lld' popped", i, (long long)item);
+  }
+  EXPECT(stack.empty());
+
+  INFO("Validating append()/prepend() & pop()");
+  for (i = 0; i >= iMin; i--) stack.prepend(T(i));
+  for (i = 1; i <= iMax; i++) stack.append(T(i));
+
+  for (i = iMax; i >= iMin; i--) {
+    T item = stack.pop();
+    EXPECT(i == item, "Item '%d' didn't match the item '%lld' popped", i, (long long)item);
+  }
+  EXPECT(stack.empty());
+}
+
+UNIT(zone_stack) {
+  Zone zone(8096 - Zone::kBlockOverhead);
+  ZoneAllocator allocator(&zone);
+
+  test_zone_stack<int>(&allocator, "int");
+  test_zone_stack<int64_t>(&allocator, "int64_t");
+}
+#endif
+
+ASMJIT_END_NAMESPACE

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

@@ -0,0 +1,239 @@
+// 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_ZONESTACK_H_INCLUDED
+#define ASMJIT_CORE_ZONESTACK_H_INCLUDED
+
+#include "../core/zone.h"
+
+ASMJIT_BEGIN_NAMESPACE
+
+//! \addtogroup asmjit_zone
+//! \{
+
+//! Base class used by \ref ZoneStack.
+class ZoneStackBase {
+public:
+  ASMJIT_NONCOPYABLE(ZoneStackBase)
+
+  //! \name Constants
+  //! \{
+
+  enum : size_t {
+    kBlockIndexPrev = 0,
+    kBlockIndexNext = 1,
+
+    kBlockIndexFirst = 0,
+    kBlockIndexLast = 1,
+
+    kBlockSize = ZoneAllocator::kHiMaxSize
+  };
+
+  //! \}
+
+  //! \name Types
+  //! \{
+
+  struct Block {
+    //! Next and previous blocks.
+    Block* _link[2];
+    //! Pointer to the start of the array.
+    void* _start;
+    //! Pointer to the end of the array.
+    void* _end;
+
+    inline bool empty() const noexcept { return _start == _end; }
+    inline Block* prev() const noexcept { return _link[kBlockIndexPrev]; }
+    inline Block* next() const noexcept { return _link[kBlockIndexNext]; }
+
+    inline void setPrev(Block* block) noexcept { _link[kBlockIndexPrev] = block; }
+    inline void setNext(Block* block) noexcept { _link[kBlockIndexNext] = block; }
+
+    template<typename T>
+    inline T* start() const noexcept { return static_cast<T*>(_start); }
+    template<typename T>
+    inline void setStart(T* start) noexcept { _start = static_cast<void*>(start); }
+
+    template<typename T>
+    inline T* end() const noexcept { return (T*)_end; }
+    template<typename T>
+    inline void setEnd(T* end) noexcept { _end = (void*)end; }
+
+    template<typename T>
+    inline T* data() const noexcept { return (T*)((uint8_t*)(this) + sizeof(Block)); }
+
+    template<typename T>
+    inline bool canPrepend() const noexcept { return _start > data<void>(); }
+
+    template<typename T>
+    inline bool canAppend() const noexcept {
+      size_t kNumBlockItems = (kBlockSize - sizeof(Block)) / sizeof(T);
+      size_t kStartBlockIndex = sizeof(Block);
+      size_t kEndBlockIndex = kStartBlockIndex + kNumBlockItems * sizeof(T);
+
+      return (uintptr_t)_end <= ((uintptr_t)this + kEndBlockIndex - sizeof(T));
+    }
+  };
+
+  //! \}
+
+  //! \name Members
+  //! \{
+
+  //! Allocator used to allocate data.
+  ZoneAllocator* _allocator;
+  //! First and last blocks.
+  Block* _block[2];
+
+  //! \}
+
+  //! \name Construction & Destruction
+  //! \{
+
+  inline ZoneStackBase() noexcept {
+    _allocator = nullptr;
+    _block[0] = nullptr;
+    _block[1] = nullptr;
+  }
+  inline ~ZoneStackBase() noexcept { reset(); }
+
+  inline bool isInitialized() const noexcept { return _allocator != nullptr; }
+  ASMJIT_API Error _init(ZoneAllocator* allocator, size_t middleIndex) noexcept;
+  inline Error reset() noexcept { return _init(nullptr, 0); }
+
+  //! \}
+
+  //! \name Accessors
+  //! \{
+
+  //! Returns `ZoneAllocator` attached to this container.
+  inline ZoneAllocator* allocator() const noexcept { return _allocator; }
+
+  inline bool empty() const noexcept {
+    ASMJIT_ASSERT(isInitialized());
+    return _block[0]->start<void>() == _block[1]->end<void>();
+  }
+
+  //! \}
+
+  //! \cond INTERNAL
+  //! \name Internal
+  //! \{
+
+  ASMJIT_API Error _prepareBlock(uint32_t side, size_t initialIndex) noexcept;
+  ASMJIT_API void _cleanupBlock(uint32_t side, size_t middleIndex) noexcept;
+
+  //! \}
+  //! \endcond
+};
+
+//! Zone allocated stack container.
+template<typename T>
+class ZoneStack : public ZoneStackBase {
+public:
+  ASMJIT_NONCOPYABLE(ZoneStack)
+
+  //! \name Constants
+  //! \{
+
+  enum : uint32_t {
+    kNumBlockItems   = uint32_t((kBlockSize - sizeof(Block)) / sizeof(T)),
+    kStartBlockIndex = uint32_t(sizeof(Block)),
+    kMidBlockIndex   = uint32_t(kStartBlockIndex + (kNumBlockItems / 2) * sizeof(T)),
+    kEndBlockIndex   = uint32_t(kStartBlockIndex + (kNumBlockItems    ) * sizeof(T))
+  };
+
+  //! \}
+
+  //! \name Construction & Destruction
+  //! \{
+
+  inline ZoneStack() noexcept {}
+  inline ~ZoneStack() noexcept {}
+
+  inline Error init(ZoneAllocator* allocator) noexcept { return _init(allocator, kMidBlockIndex); }
+
+  //! \}
+
+  //! \name Utilities
+  //! \{
+
+  inline Error prepend(T item) noexcept {
+    ASMJIT_ASSERT(isInitialized());
+    Block* block = _block[kBlockIndexFirst];
+
+    if (!block->canPrepend<T>()) {
+      ASMJIT_PROPAGATE(_prepareBlock(kBlockIndexFirst, kEndBlockIndex));
+      block = _block[kBlockIndexFirst];
+    }
+
+    T* ptr = block->start<T>() - 1;
+    ASMJIT_ASSERT(ptr >= block->data<T>() && ptr <= block->data<T>() + (kNumBlockItems - 1));
+    *ptr = item;
+    block->setStart<T>(ptr);
+    return kErrorOk;
+  }
+
+  inline Error append(T item) noexcept {
+    ASMJIT_ASSERT(isInitialized());
+    Block* block = _block[kBlockIndexLast];
+
+    if (!block->canAppend<T>()) {
+      ASMJIT_PROPAGATE(_prepareBlock(kBlockIndexLast, kStartBlockIndex));
+      block = _block[kBlockIndexLast];
+    }
+
+    T* ptr = block->end<T>();
+    ASMJIT_ASSERT(ptr >= block->data<T>() && ptr <= block->data<T>() + (kNumBlockItems - 1));
+
+    *ptr++ = item;
+    block->setEnd(ptr);
+    return kErrorOk;
+  }
+
+  inline T popFirst() noexcept {
+    ASMJIT_ASSERT(isInitialized());
+    ASMJIT_ASSERT(!empty());
+
+    Block* block = _block[kBlockIndexFirst];
+    ASMJIT_ASSERT(!block->empty());
+
+    T* ptr = block->start<T>();
+    T item = *ptr++;
+
+    block->setStart(ptr);
+    if (block->empty())
+      _cleanupBlock(kBlockIndexFirst, kMidBlockIndex);
+
+    return item;
+  }
+
+  inline T pop() noexcept {
+    ASMJIT_ASSERT(isInitialized());
+    ASMJIT_ASSERT(!empty());
+
+    Block* block = _block[kBlockIndexLast];
+    ASMJIT_ASSERT(!block->empty());
+
+    T* ptr = block->end<T>();
+    T item = *--ptr;
+    ASMJIT_ASSERT(ptr >= block->data<T>());
+    ASMJIT_ASSERT(ptr >= block->start<T>());
+
+    block->setEnd(ptr);
+    if (block->empty())
+      _cleanupBlock(kBlockIndexLast, kMidBlockIndex);
+
+    return item;
+  }
+
+  //! \}
+};
+
+//! \}
+
+ASMJIT_END_NAMESPACE
+
+#endif // ASMJIT_CORE_ZONESTACK_H_INCLUDED