summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/asmjit/src/asmjit/core/zonevector.h
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/asmjit/src/asmjit/core/zonevector.h')
-rw-r--r--3rdparty/asmjit/src/asmjit/core/zonevector.h345
1 files changed, 182 insertions, 163 deletions
diff --git a/3rdparty/asmjit/src/asmjit/core/zonevector.h b/3rdparty/asmjit/src/asmjit/core/zonevector.h
index 770543baee1..13d28bbefa2 100644
--- a/3rdparty/asmjit/src/asmjit/core/zonevector.h
+++ b/3rdparty/asmjit/src/asmjit/core/zonevector.h
@@ -1,25 +1,7 @@
-// AsmJit - Machine code generation for C++
+// This file is part of AsmJit project <https://asmjit.com>
//
-// * Official AsmJit Home Page: https://asmjit.com
-// * Official Github Repository: https://github.com/asmjit/asmjit
-//
-// Copyright (c) 2008-2020 The AsmJit Authors
-//
-// This software is provided 'as-is', without any express or implied
-// warranty. In no event will the authors be held liable for any damages
-// arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it
-// freely, subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented; you must not
-// claim that you wrote the original software. If you use this software
-// in a product, an acknowledgment in the product documentation would be
-// appreciated but is not required.
-// 2. Altered source versions must be plainly marked as such, and must not be
-// misrepresented as being the original software.
-// 3. This notice may not be removed or altered from any source distribution.
+// See asmjit.h or LICENSE.md for license and copyright information
+// SPDX-License-Identifier: Zlib
#ifndef ASMJIT_CORE_ZONEVECTOR_H_INCLUDED
#define ASMJIT_CORE_ZONEVECTOR_H_INCLUDED
@@ -32,10 +14,6 @@ ASMJIT_BEGIN_NAMESPACE
//! \addtogroup asmjit_zone
//! \{
-// ============================================================================
-// [asmjit::ZoneVectorBase]
-// ============================================================================
-
//! Base class used by \ref ZoneVector template.
class ZoneVectorBase {
public:
@@ -46,21 +24,18 @@ public:
typedef ptrdiff_t difference_type;
//! Vector data (untyped).
- void* _data;
+ void* _data = nullptr;
//! Size of the vector.
- size_type _size;
+ size_type _size = 0;
//! Capacity of the vector.
- size_type _capacity;
+ size_type _capacity = 0;
protected:
//! \name Construction & Destruction
//! \{
//! Creates a new instance of `ZoneVectorBase`.
- inline ZoneVectorBase() noexcept
- : _data(nullptr),
- _size(0),
- _capacity(0) {}
+ inline ZoneVectorBase() noexcept {}
inline ZoneVectorBase(ZoneVectorBase&& other) noexcept
: _data(other._data),
@@ -98,11 +73,11 @@ public:
//! \{
//! Tests whether the vector is empty.
- inline bool empty() const noexcept { return _size == 0; }
+ ASMJIT_INLINE_NODEBUG bool empty() const noexcept { return _size == 0; }
//! Returns the vector size.
- inline size_type size() const noexcept { return _size; }
+ ASMJIT_INLINE_NODEBUG size_type size() const noexcept { return _size; }
//! Returns the vector capacity.
- inline size_type capacity() const noexcept { return _capacity; }
+ ASMJIT_INLINE_NODEBUG size_type capacity() const noexcept { return _capacity; }
//! \}
@@ -110,16 +85,16 @@ public:
//! \{
//! Makes the vector empty (won't change the capacity or data pointer).
- inline void clear() noexcept { _size = 0; }
+ ASMJIT_INLINE_NODEBUG void clear() noexcept { _size = 0; }
//! Resets the vector data and set its `size` to zero.
- inline void reset() noexcept {
+ ASMJIT_INLINE_NODEBUG void reset() noexcept {
_data = nullptr;
_size = 0;
_capacity = 0;
}
//! Truncates the vector to at most `n` items.
- inline void truncate(size_type n) noexcept {
+ ASMJIT_INLINE_NODEBUG void truncate(size_type n) noexcept {
_size = Support::min(_size, n);
}
@@ -132,10 +107,6 @@ public:
//! \}
};
-// ============================================================================
-// [asmjit::ZoneVector<T>]
-// ============================================================================
-
//! Template used to store and manage array of Zone allocated data.
//!
//! This template has these advantages over other std::vector<>:
@@ -146,7 +117,7 @@ public:
template <typename T>
class ZoneVector : public ZoneVectorBase {
public:
- ASMJIT_NONCOPYABLE(ZoneVector<T>)
+ ASMJIT_NONCOPYABLE(ZoneVector)
// STL compatibility;
typedef T value_type;
@@ -155,16 +126,16 @@ public:
typedef T& reference;
typedef const T& const_reference;
- typedef Support::Iterator<T> iterator;
- typedef Support::Iterator<const T> const_iterator;
- typedef Support::ReverseIterator<T> reverse_iterator;
- typedef Support::ReverseIterator<const T> const_reverse_iterator;
+ typedef T* iterator;
+ typedef const T* const_iterator;
+ typedef Support::ArrayReverseIterator<T> reverse_iterator;
+ typedef Support::ArrayReverseIterator<const T> const_reverse_iterator;
//! \name Construction & Destruction
//! \{
- inline ZoneVector() noexcept : ZoneVectorBase() {}
- inline ZoneVector(ZoneVector&& other) noexcept : ZoneVector(other) {}
+ ASMJIT_INLINE_NODEBUG ZoneVector() noexcept : ZoneVectorBase() {}
+ ASMJIT_INLINE_NODEBUG ZoneVector(ZoneVector&& other) noexcept : ZoneVector(other) {}
//! \}
@@ -172,9 +143,9 @@ public:
//! \{
//! Returns vector data.
- inline T* data() noexcept { return static_cast<T*>(_data); }
+ ASMJIT_INLINE_NODEBUG T* data() noexcept { return static_cast<T*>(_data); }
//! Returns vector data (const)
- inline const T* data() const noexcept { return static_cast<const T*>(_data); }
+ ASMJIT_INLINE_NODEBUG const T* data() const noexcept { return static_cast<const T*>(_data); }
//! Returns item at the given index `i` (const).
inline const T& at(size_t i) const noexcept {
@@ -192,23 +163,23 @@ public:
//! \name STL Compatibility (Iterators)
//! \{
- inline iterator begin() noexcept { return iterator(data()); };
- inline const_iterator begin() const noexcept { return const_iterator(data()); };
+ ASMJIT_INLINE_NODEBUG iterator begin() noexcept { return iterator(data()); };
+ ASMJIT_INLINE_NODEBUG const_iterator begin() const noexcept { return const_iterator(data()); };
- inline iterator end() noexcept { return iterator(data() + _size); };
- inline const_iterator end() const noexcept { return const_iterator(data() + _size); };
+ ASMJIT_INLINE_NODEBUG iterator end() noexcept { return iterator(data() + _size); };
+ ASMJIT_INLINE_NODEBUG const_iterator end() const noexcept { return const_iterator(data() + _size); };
- inline reverse_iterator rbegin() noexcept { return reverse_iterator(data()); };
- inline const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(data()); };
+ ASMJIT_INLINE_NODEBUG reverse_iterator rbegin() noexcept { return reverse_iterator(end()); };
+ ASMJIT_INLINE_NODEBUG const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); };
- inline reverse_iterator rend() noexcept { return reverse_iterator(data() + _size); };
- inline const_reverse_iterator rend() const noexcept { return const_reverse_iterator(data() + _size); };
+ ASMJIT_INLINE_NODEBUG reverse_iterator rend() noexcept { return reverse_iterator(begin()); };
+ ASMJIT_INLINE_NODEBUG const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); };
- inline const_iterator cbegin() const noexcept { return const_iterator(data()); };
- inline const_iterator cend() const noexcept { return const_iterator(data() + _size); };
+ ASMJIT_INLINE_NODEBUG const_iterator cbegin() const noexcept { return const_iterator(data()); };
+ ASMJIT_INLINE_NODEBUG const_iterator cend() const noexcept { return const_iterator(data() + _size); };
- inline const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(data()); };
- inline const_reverse_iterator crend() const noexcept { return const_reverse_iterator(data() + _size); };
+ ASMJIT_INLINE_NODEBUG const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(cend()); };
+ ASMJIT_INLINE_NODEBUG const_reverse_iterator crend() const noexcept { return const_reverse_iterator(cbegin()); };
//! \}
@@ -216,54 +187,68 @@ public:
//! \{
//! Swaps this vector with `other`.
- inline void swap(ZoneVector<T>& other) noexcept { _swap(other); }
+ ASMJIT_FORCE_INLINE void swap(ZoneVector<T>& other) noexcept { _swap(other); }
//! Prepends `item` to the vector.
- inline Error prepend(ZoneAllocator* allocator, const T& item) noexcept {
+ ASMJIT_FORCE_INLINE Error prepend(ZoneAllocator* allocator, const T& item) noexcept {
if (ASMJIT_UNLIKELY(_size == _capacity))
ASMJIT_PROPAGATE(grow(allocator, 1));
- ::memmove(static_cast<T*>(_data) + 1, _data, size_t(_size) * sizeof(T));
- memcpy(_data, &item, sizeof(T));
+ memmove(static_cast<void*>(static_cast<T*>(_data) + 1),
+ static_cast<const void*>(_data),
+ size_t(_size) * sizeof(T));
+
+ memcpy(static_cast<void*>(_data),
+ static_cast<const void*>(&item),
+ sizeof(T));
_size++;
return kErrorOk;
}
//! Inserts an `item` at the specified `index`.
- inline Error insert(ZoneAllocator* allocator, uint32_t index, const T& item) noexcept {
+ ASMJIT_FORCE_INLINE Error insert(ZoneAllocator* allocator, size_t index, const T& item) noexcept {
ASMJIT_ASSERT(index <= _size);
if (ASMJIT_UNLIKELY(_size == _capacity))
ASMJIT_PROPAGATE(grow(allocator, 1));
T* dst = static_cast<T*>(_data) + index;
- ::memmove(dst + 1, dst, size_t(_size - index) * sizeof(T));
- memcpy(dst, &item, sizeof(T));
- _size++;
+ memmove(static_cast<void*>(dst + 1),
+ static_cast<const void*>(dst),
+ size_t(_size - index) * sizeof(T));
+ memcpy(static_cast<void*>(dst),
+ static_cast<const void*>(&item),
+ sizeof(T));
+
+ _size++;
return kErrorOk;
}
//! Appends `item` to the vector.
- inline Error append(ZoneAllocator* allocator, const T& item) noexcept {
+ ASMJIT_FORCE_INLINE Error append(ZoneAllocator* allocator, const T& item) noexcept {
if (ASMJIT_UNLIKELY(_size == _capacity))
ASMJIT_PROPAGATE(grow(allocator, 1));
- memcpy(static_cast<T*>(_data) + _size, &item, sizeof(T));
- _size++;
+ memcpy(static_cast<void*>(static_cast<T*>(_data) + _size),
+ static_cast<const void*>(&item),
+ sizeof(T));
+ _size++;
return kErrorOk;
}
//! Appends `other` vector at the end of this vector.
- inline Error concat(ZoneAllocator* allocator, const ZoneVector<T>& other) noexcept {
+ ASMJIT_FORCE_INLINE Error concat(ZoneAllocator* allocator, const ZoneVector<T>& other) noexcept {
uint32_t size = other._size;
if (_capacity - _size < size)
ASMJIT_PROPAGATE(grow(allocator, size));
if (size) {
- memcpy(static_cast<T*>(_data) + _size, other._data, size_t(size) * sizeof(T));
+ memcpy(static_cast<void*>(static_cast<T*>(_data) + _size),
+ static_cast<const void*>(other._data),
+ size_t(size) * sizeof(T));
_size += size;
}
@@ -272,45 +257,69 @@ public:
//! Prepends `item` to the vector (unsafe case).
//!
- //! Can only be used together with `willGrow()`. If `willGrow(N)` returns
- //! `kErrorOk` then N elements can be added to the vector without checking
- //! if there is a place for them. Used mostly internally.
- inline void prependUnsafe(const T& item) noexcept {
+ //! Can only be used together with `willGrow()`. If `willGrow(N)` returns `kErrorOk` then N elements
+ //! can be added to the vector without checking if there is a place for them. Used mostly internally.
+ ASMJIT_FORCE_INLINE void prependUnsafe(const T& item) noexcept {
ASMJIT_ASSERT(_size < _capacity);
T* data = static_cast<T*>(_data);
- if (_size)
- ::memmove(data + 1, data, size_t(_size) * sizeof(T));
+ if (_size) {
+ memmove(static_cast<void*>(data + 1),
+ static_cast<const void*>(data),
+ size_t(_size) * sizeof(T));
+ }
- memcpy(data, &item, sizeof(T));
+ memcpy(static_cast<void*>(data),
+ static_cast<const void*>(&item),
+ sizeof(T));
_size++;
}
//! Append s`item` to the vector (unsafe case).
//!
- //! Can only be used together with `willGrow()`. If `willGrow(N)` returns
- //! `kErrorOk` then N elements can be added to the vector without checking
- //! if there is a place for them. Used mostly internally.
- inline void appendUnsafe(const T& item) noexcept {
+ //! Can only be used together with `willGrow()`. If `willGrow(N)` returns `kErrorOk` then N elements
+ //! can be added to the vector without checking if there is a place for them. Used mostly internally.
+ ASMJIT_FORCE_INLINE void appendUnsafe(const T& item) noexcept {
ASMJIT_ASSERT(_size < _capacity);
- memcpy(static_cast<T*>(_data) + _size, &item, sizeof(T));
+ memcpy(static_cast<void*>(static_cast<T*>(_data) + _size),
+ static_cast<const void*>(&item),
+ sizeof(T));
+ _size++;
+ }
+
+ //! Inserts an `item` at the specified `index` (unsafe case).
+ ASMJIT_FORCE_INLINE void insertUnsafe(size_t index, const T& item) noexcept {
+ ASMJIT_ASSERT(_size < _capacity);
+ ASMJIT_ASSERT(index <= _size);
+
+ T* dst = static_cast<T*>(_data) + index;
+ memmove(static_cast<void*>(dst + 1),
+ static_cast<const void*>(dst),
+ size_t(_size - index) * sizeof(T));
+
+ memcpy(static_cast<void*>(dst),
+ static_cast<const void*>(&item),
+ sizeof(T));
+
_size++;
}
//! Concatenates all items of `other` at the end of the vector.
- inline void concatUnsafe(const ZoneVector<T>& other) noexcept {
+ ASMJIT_FORCE_INLINE void concatUnsafe(const ZoneVector<T>& other) noexcept {
uint32_t size = other._size;
ASMJIT_ASSERT(_capacity - _size >= size);
if (size) {
- memcpy(static_cast<T*>(_data) + _size, other._data, size_t(size) * sizeof(T));
+ memcpy(static_cast<void*>(static_cast<T*>(_data) + _size),
+ static_cast<const void*>(other._data),
+ size_t(size) * sizeof(T));
_size += size;
}
}
//! Returns index of the given `val` or `Globals::kNotFound` if it doesn't exist.
- inline uint32_t indexOf(const T& val) const noexcept {
+ ASMJIT_FORCE_INLINE uint32_t indexOf(const T& val) const noexcept {
const T* data = static_cast<const T*>(_data);
uint32_t size = _size;
@@ -326,14 +335,17 @@ public:
}
//! Removes item at index `i`.
- inline void removeAt(uint32_t i) noexcept {
+ inline void removeAt(size_t i) noexcept {
ASMJIT_ASSERT(i < _size);
T* data = static_cast<T*>(_data) + i;
- uint32_t size = --_size - i;
+ size_t size = --_size - i;
- if (size)
- ::memmove(data, data + 1, size_t(size) * sizeof(T));
+ if (size) {
+ memmove(static_cast<void*>(data),
+ static_cast<const void*>(data + 1),
+ size_t(size) * sizeof(T));
+ }
}
//! Pops the last element from the vector and returns it.
@@ -344,7 +356,7 @@ public:
return data()[index];
}
- template<typename CompareT = Support::Compare<Support::kSortAscending>>
+ template<typename CompareT = Support::Compare<Support::SortOrder::kAscending>>
inline void sort(const CompareT& cmp = CompareT()) noexcept {
Support::qSort<T, CompareT>(data(), size(), cmp);
}
@@ -363,18 +375,16 @@ public:
//! Returns a reference to the first element of the vector.
//!
- //! \note The vector must have at least one element. Attempting to use
- //! `first()` on empty vector will trigger an assertion failure in debug
- //! builds.
- inline T& first() noexcept { return operator[](0); }
+ //! \note The vector must have at least one element. Attempting to use `first()` on empty vector will trigger
+ //! an assertion failure in debug builds.
+ ASMJIT_INLINE_NODEBUG T& first() noexcept { return operator[](0); }
//! \overload
- inline const T& first() const noexcept { return operator[](0); }
+ ASMJIT_INLINE_NODEBUG const T& first() const noexcept { return operator[](0); }
//! Returns a reference to the last element of the vector.
//!
- //! \note The vector must have at least one element. Attempting to use
- //! `last()` on empty vector will trigger an assertion failure in debug
- //! builds.
+ //! \note The vector must have at least one element. Attempting to use `last()` on empty vector will trigger
+ //! an assertion failure in debug builds.
inline T& last() noexcept { return operator[](_size - 1); }
//! \overload
inline const T& last() const noexcept { return operator[](_size - 1); }
@@ -396,9 +406,8 @@ public:
//! Resizes the vector to hold `n` elements.
//!
- //! If `n` is greater than the current size then the additional elements'
- //! content will be initialized to zero. If `n` is less than the current
- //! size then the vector will be truncated to exactly `n` elements.
+ //! If `n` is greater than the current size then the additional elements' content will be initialized to zero.
+ //! If `n` is less than the current size then the vector will be truncated to exactly `n` elements.
inline Error resize(ZoneAllocator* allocator, uint32_t n) noexcept {
return ZoneVectorBase::_resize(allocator, sizeof(T), n);
}
@@ -415,44 +424,53 @@ public:
//! \}
};
-// ============================================================================
-// [asmjit::ZoneBitVector]
-// ============================================================================
-
//! Zone-allocated bit vector.
class ZoneBitVector {
public:
typedef Support::BitWord BitWord;
- static constexpr uint32_t kBitWordSizeInBits = Support::kBitWordSizeInBits;
+
+ ASMJIT_NONCOPYABLE(ZoneBitVector)
+
+ //! \name Constants
+ //! \{
+
+ enum : uint32_t {
+ kBitWordSizeInBits = Support::kBitWordSizeInBits
+ };
+
+ //! \}
+
+ //! \name Members
+ //! \{
//! Bits.
- BitWord* _data;
+ BitWord* _data = nullptr;
//! Size of the bit-vector (in bits).
- uint32_t _size;
+ uint32_t _size = 0;
//! Capacity of the bit-vector (in bits).
- uint32_t _capacity;
+ uint32_t _capacity = 0;
- ASMJIT_NONCOPYABLE(ZoneBitVector)
+ //! \}
//! \cond INTERNAL
//! \name Internal
//! \{
- static inline uint32_t _wordsPerBits(uint32_t nBits) noexcept {
+ static ASMJIT_INLINE_NODEBUG uint32_t _wordsPerBits(uint32_t nBits) noexcept {
return ((nBits + kBitWordSizeInBits - 1) / kBitWordSizeInBits);
}
- static inline void _zeroBits(BitWord* dst, uint32_t nBitWords) noexcept {
+ static ASMJIT_INLINE_NODEBUG void _zeroBits(BitWord* dst, uint32_t nBitWords) noexcept {
for (uint32_t i = 0; i < nBitWords; i++)
dst[i] = 0;
}
- static inline void _fillBits(BitWord* dst, uint32_t nBitWords) noexcept {
+ static ASMJIT_INLINE_NODEBUG void _fillBits(BitWord* dst, uint32_t nBitWords) noexcept {
for (uint32_t i = 0; i < nBitWords; i++)
dst[i] = ~BitWord(0);
}
- static inline void _copyBits(BitWord* dst, const BitWord* src, uint32_t nBitWords) noexcept {
+ static ASMJIT_INLINE_NODEBUG void _copyBits(BitWord* dst, const BitWord* src, uint32_t nBitWords) noexcept {
for (uint32_t i = 0; i < nBitWords; i++)
dst[i] = src[i];
}
@@ -463,12 +481,9 @@ public:
//! \name Construction & Destruction
//! \{
- inline ZoneBitVector() noexcept
- : _data(nullptr),
- _size(0),
- _capacity(0) {}
+ ASMJIT_INLINE_NODEBUG ZoneBitVector() noexcept {}
- inline ZoneBitVector(ZoneBitVector&& other) noexcept
+ ASMJIT_INLINE_NODEBUG ZoneBitVector(ZoneBitVector&& other) noexcept
: _data(other._data),
_size(other._size),
_capacity(other._capacity) {}
@@ -478,8 +493,8 @@ public:
//! \name Overloaded Operators
//! \{
- inline bool operator==(const ZoneBitVector& other) const noexcept { return eq(other); }
- inline bool operator!=(const ZoneBitVector& other) const noexcept { return !eq(other); }
+ ASMJIT_INLINE_NODEBUG bool operator==(const ZoneBitVector& other) const noexcept { return equals(other); }
+ ASMJIT_INLINE_NODEBUG bool operator!=(const ZoneBitVector& other) const noexcept { return !equals(other); }
//! \}
@@ -487,44 +502,44 @@ public:
//! \{
//! Tests whether the bit-vector is empty (has no bits).
- inline bool empty() const noexcept { return _size == 0; }
+ ASMJIT_INLINE_NODEBUG bool empty() const noexcept { return _size == 0; }
//! Returns the size of this bit-vector (in bits).
- inline uint32_t size() const noexcept { return _size; }
+ ASMJIT_INLINE_NODEBUG uint32_t size() const noexcept { return _size; }
//! Returns the capacity of this bit-vector (in bits).
- inline uint32_t capacity() const noexcept { return _capacity; }
+ ASMJIT_INLINE_NODEBUG uint32_t capacity() const noexcept { return _capacity; }
//! Returns the size of the `BitWord[]` array in `BitWord` units.
- inline uint32_t sizeInBitWords() const noexcept { return _wordsPerBits(_size); }
+ ASMJIT_INLINE_NODEBUG uint32_t sizeInBitWords() const noexcept { return _wordsPerBits(_size); }
//! Returns the capacity of the `BitWord[]` array in `BitWord` units.
- inline uint32_t capacityInBitWords() const noexcept { return _wordsPerBits(_capacity); }
+ ASMJIT_INLINE_NODEBUG uint32_t capacityInBitWords() const noexcept { return _wordsPerBits(_capacity); }
- //! REturns bit-vector data as `BitWord[]`.
- inline BitWord* data() noexcept { return _data; }
+ //! Returns bit-vector data as `BitWord[]`.
+ ASMJIT_INLINE_NODEBUG BitWord* data() noexcept { return _data; }
//! \overload
- inline const BitWord* data() const noexcept { return _data; }
+ ASMJIT_INLINE_NODEBUG const BitWord* data() const noexcept { return _data; }
//! \}
//! \name Utilities
//! \{
- inline void swap(ZoneBitVector& other) noexcept {
+ ASMJIT_INLINE_NODEBUG void swap(ZoneBitVector& other) noexcept {
std::swap(_data, other._data);
std::swap(_size, other._size);
std::swap(_capacity, other._capacity);
}
- inline void clear() noexcept {
+ ASMJIT_INLINE_NODEBUG void clear() noexcept {
_size = 0;
}
- inline void reset() noexcept {
+ ASMJIT_INLINE_NODEBUG void reset() noexcept {
_data = nullptr;
_size = 0;
_capacity = 0;
}
- inline void truncate(uint32_t newSize) noexcept {
+ ASMJIT_INLINE_NODEBUG void truncate(uint32_t newSize) noexcept {
_size = Support::min(_size, newSize);
_clearUnusedBits();
}
@@ -544,7 +559,7 @@ public:
Support::bitVectorFlipBit(_data, index);
}
- ASMJIT_INLINE Error append(ZoneAllocator* allocator, bool value) noexcept {
+ ASMJIT_FORCE_INLINE Error append(ZoneAllocator* allocator, bool value) noexcept {
uint32_t index = _size;
if (ASMJIT_UNLIKELY(index >= _capacity))
return _append(allocator, value);
@@ -563,35 +578,34 @@ public:
ASMJIT_API Error copyFrom(ZoneAllocator* allocator, const ZoneBitVector& other) noexcept;
- inline void clearAll() noexcept {
+ ASMJIT_FORCE_INLINE void clearAll() noexcept {
_zeroBits(_data, _wordsPerBits(_size));
}
- inline void fillAll() noexcept {
+ ASMJIT_FORCE_INLINE void fillAll() noexcept {
_fillBits(_data, _wordsPerBits(_size));
_clearUnusedBits();
}
- inline void clearBits(uint32_t start, uint32_t count) noexcept {
+ ASMJIT_FORCE_INLINE void clearBits(uint32_t start, uint32_t count) noexcept {
ASMJIT_ASSERT(start <= _size);
ASMJIT_ASSERT(_size - start >= count);
Support::bitVectorClear(_data, start, count);
}
- inline void fillBits(uint32_t start, uint32_t count) noexcept {
+ ASMJIT_FORCE_INLINE void fillBits(uint32_t start, uint32_t count) noexcept {
ASMJIT_ASSERT(start <= _size);
ASMJIT_ASSERT(_size - start >= count);
Support::bitVectorFill(_data, start, count);
}
- //! Performs a logical bitwise AND between bits specified in this array and bits
- //! in `other`. If `other` has less bits than `this` then all remaining bits are
- //! set to zero.
+ //! Performs a logical bitwise AND between bits specified in this array and bits in `other`. If `other` has less
+ //! bits than `this` then all remaining bits are set to zero.
//!
//! \note The size of the BitVector is unaffected by this operation.
- inline void and_(const ZoneBitVector& other) noexcept {
+ ASMJIT_FORCE_INLINE void and_(const ZoneBitVector& other) noexcept {
BitWord* dst = _data;
const BitWord* src = other._data;
@@ -611,12 +625,11 @@ public:
}
}
- //! Performs a logical bitwise AND between bits specified in this array and
- //! negated bits in `other`. If `other` has less bits than `this` then all
- //! remaining bits are kept intact.
+ //! Performs a logical bitwise AND between bits specified in this array and negated bits in `other`. If `other`
+ //! has less bits than `this` then all remaining bits are kept intact.
//!
//! \note The size of the BitVector is unaffected by this operation.
- inline void andNot(const ZoneBitVector& other) noexcept {
+ ASMJIT_FORCE_INLINE void andNot(const ZoneBitVector& other) noexcept {
BitWord* dst = _data;
const BitWord* src = other._data;
@@ -625,12 +638,11 @@ public:
dst[i] = dst[i] & ~src[i];
}
- //! Performs a logical bitwise OP between bits specified in this array and bits
- //! in `other`. If `other` has less bits than `this` then all remaining bits
- //! are kept intact.
+ //! Performs a logical bitwise OP between bits specified in this array and bits in `other`. If `other` has less
+ //! bits than `this` then all remaining bits are kept intact.
//!
//! \note The size of the BitVector is unaffected by this operation.
- inline void or_(const ZoneBitVector& other) noexcept {
+ ASMJIT_FORCE_INLINE void or_(const ZoneBitVector& other) noexcept {
BitWord* dst = _data;
const BitWord* src = other._data;
@@ -640,15 +652,16 @@ public:
_clearUnusedBits();
}
- inline void _clearUnusedBits() noexcept {
+ ASMJIT_FORCE_INLINE void _clearUnusedBits() noexcept {
uint32_t idx = _size / kBitWordSizeInBits;
uint32_t bit = _size % kBitWordSizeInBits;
- if (!bit) return;
+ if (!bit)
+ return;
_data[idx] &= (BitWord(1) << bit) - 1u;
}
- inline bool eq(const ZoneBitVector& other) const noexcept {
+ ASMJIT_FORCE_INLINE bool equals(const ZoneBitVector& other) const noexcept {
if (_size != other._size)
return false;
@@ -662,18 +675,24 @@ public:
return true;
}
+#if !defined(ASMJIT_NO_DEPRECATED)
+ ASMJIT_DEPRECATED("Use ZoneVector::equals() instead")
+ ASMJIT_FORCE_INLINE bool eq(const ZoneBitVector& other) const noexcept { return equals(other); }
+#endif // !ASMJIT_NO_DEPRECATED
+
//! \}
//! \name Memory Management
//! \{
inline void release(ZoneAllocator* allocator) noexcept {
- if (!_data) return;
+ if (!_data)
+ return;
allocator->release(_data, _capacity / 8);
reset();
}
- inline Error resize(ZoneAllocator* allocator, uint32_t newSize, bool newBitsValue = false) noexcept {
+ ASMJIT_INLINE_NODEBUG Error resize(ZoneAllocator* allocator, uint32_t newSize, bool newBitsValue = false) noexcept {
return _resize(allocator, newSize, newSize, newBitsValue);
}
@@ -687,14 +706,14 @@ public:
class ForEachBitSet : public Support::BitVectorIterator<BitWord> {
public:
- ASMJIT_INLINE explicit ForEachBitSet(const ZoneBitVector& bitVector) noexcept
+ inline explicit ForEachBitSet(const ZoneBitVector& bitVector) noexcept
: Support::BitVectorIterator<BitWord>(bitVector.data(), bitVector.sizeInBitWords()) {}
};
template<class Operator>
class ForEachBitOp : public Support::BitVectorOpIterator<BitWord, Operator> {
public:
- ASMJIT_INLINE ForEachBitOp(const ZoneBitVector& a, const ZoneBitVector& b) noexcept
+ inline ForEachBitOp(const ZoneBitVector& a, const ZoneBitVector& b) noexcept
: Support::BitVectorOpIterator<BitWord, Operator>(a.data(), b.data(), a.sizeInBitWords()) {
ASMJIT_ASSERT(a.size() == b.size());
}