Mirrors/asmjit
1
0
Fork 0
mirror of https://github.com/asmjit/asmjit.git synced 2025-12-17 04:24:37 +03:00
Code Issues Packages Projects Releases Wiki Activity

Attempt to fix remaining issues (maintenance mode)

Browse Source
This commit is contained in:
kobalicek
2018-11-17 13:45:39 +01:00
parent c2f50e6fc5
commit 868f8d2e27
4 changed files with 5 additions and 331 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/asmjit/asmjit_apibegin.h
View File

@@ -54,6 +54,9 @@
#if ASMJIT_CC_GCC
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wbool-operation"
# if ASMJIT_CC_GCC_GE(8, 0, 0)
# pragma GCC diagnostic ignored "-Wclass-memaccess"
# endif
#endif // ASMJIT_CC_GCC
// [MSC]

129
src/asmjit/base/zone.cpp
View File

@@ -627,89 +627,6 @@ Error ZoneBitVector::fill(size_t from, size_t to, bool value) noexcept {
return kErrorOk;
}
// ============================================================================
// [asmjit::ZoneStackBase - Init / Reset]
// ============================================================================
Error ZoneStackBase::_init(ZoneHeap* heap, size_t middleIndex) noexcept {
ZoneHeap* oldHeap = _heap;
if (oldHeap) {
Block* block = _block[kSideLeft];
while (block) {
Block* next = block->getNext();
oldHeap->release(block, kBlockSize);
block = next;
}
_heap = nullptr;
_block[kSideLeft] = nullptr;
_block[kSideRight] = nullptr;
}
if (heap) {
Block* block = static_cast<Block*>(heap->alloc(kBlockSize));
if (ASMJIT_UNLIKELY(!block))
return DebugUtils::errored(kErrorNoHeapMemory);
block->_link[kSideLeft] = nullptr;
block->_link[kSideRight] = nullptr;
block->_start = (uint8_t*)block + middleIndex;
block->_end = (uint8_t*)block + middleIndex;
_heap = heap;
_block[kSideLeft] = block;
_block[kSideRight] = block;
}
return kErrorOk;
}
// ============================================================================
// [asmjit::ZoneStackBase - Ops]
// ============================================================================
Error ZoneStackBase::_prepareBlock(uint32_t side, size_t initialIndex) noexcept {
ASMJIT_ASSERT(isInitialized());
Block* prev = _block[side];
ASMJIT_ASSERT(!prev->isEmpty());
Block* block = _heap->allocT<Block>(kBlockSize);
if (ASMJIT_UNLIKELY(!block))
return DebugUtils::errored(kErrorNoHeapMemory);
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->isEmpty());
Block* prev = block->_link[!side];
if (prev) {
ASMJIT_ASSERT(prev->_link[side] == block);
_heap->release(block, kBlockSize);
prev->_link[side] = nullptr;
_block[side] = prev;
}
else if (_block[!side] == prev && prev->isEmpty()) {
// If the container becomes empty center both pointers in the remaining block.
prev->_start = (uint8_t*)prev + middleIndex;
prev->_end = (uint8_t*)prev + middleIndex;
}
}
// ============================================================================
// [asmjit::ZoneHashBase - Utilities]
// ============================================================================
@@ -908,52 +825,6 @@ UNIT(base_ZoneBitVector) {
}
}
UNIT(base_zonestack) {
Zone zone(8096 - Zone::kZoneOverhead);
ZoneHeap heap(&zone);
ZoneStack<int> stack;
INFO("ZoneStack<int> contains %d elements per one Block", ZoneStack<int>::kNumBlockItems);
EXPECT(stack.init(&heap) == kErrorOk);
EXPECT(stack.isEmpty(), "Stack must be empty after `init()`");
EXPECT(stack.append(42) == kErrorOk);
EXPECT(!stack.isEmpty() , "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.isEmpty() , "Stack must be empty after the last element has been removed");
EXPECT(stack.prepend(43) == kErrorOk);
EXPECT(!stack.isEmpty() , "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.isEmpty() , "Stack must be empty after the last element has been removed");
int i;
int iMin =-100;
int iMax = 100000;
INFO("Adding items from %d to %d to the stack", iMin, iMax);
for (i = 1; i <= iMax; i++) stack.append(i);
for (i = 0; i >= iMin; i--) stack.prepend(i);
INFO("Validating popFirst()");
for (i = iMin; i <= iMax; i++) {
int item = stack.popFirst();
EXPECT(i == item, "Item '%d' didn't match the item '%d' popped", i, item);
}
EXPECT(stack.isEmpty());
INFO("Adding items from %d to %d to the stack", iMin, iMax);
for (i = 0; i >= iMin; i--) stack.prepend(i);
for (i = 1; i <= iMax; i++) stack.append(i);
INFO("Validating pop()");
for (i = iMax; i >= iMin; i--) {
int item = stack.pop();
EXPECT(i == item, "Item '%d' didn't match the item '%d' popped", i, item);
}
EXPECT(stack.isEmpty());
}
#endif // ASMJIT_TEST
} // asmjit namespace

201
src/asmjit/base/zone.h
View File

@@ -1005,207 +1005,6 @@ public:
size_t _capacity; //!< Capacity of the bit-vector (in bits).
};
// ============================================================================
// [asmjit::ZoneStackBase]
// ============================================================================
class ZoneStackBase {
public:
enum Side {
kSideLeft = 0,
kSideRight = 1
};
enum {
kBlockSize = ZoneHeap::kHiMaxSize
};
struct Block {
ASMJIT_INLINE Block* getPrev() const noexcept { return _link[kSideLeft]; }
ASMJIT_INLINE void setPrev(Block* block) noexcept { _link[kSideLeft] = block; }
ASMJIT_INLINE Block* getNext() const noexcept { return _link[kSideRight]; }
ASMJIT_INLINE void setNext(Block* block) noexcept { _link[kSideRight] = block; }
template<typename T>
ASMJIT_INLINE T* getStart() const noexcept { return static_cast<T*>(_start); }
template<typename T>
ASMJIT_INLINE void setStart(T* start) noexcept { _start = static_cast<void*>(start); }
template<typename T>
ASMJIT_INLINE T* getEnd() const noexcept { return static_cast<T*>(_end); }
template<typename T>
ASMJIT_INLINE void setEnd(T* end) noexcept { _end = static_cast<void*>(end); }
ASMJIT_INLINE bool isEmpty() const noexcept { return _start == _end; }
template<typename T>
ASMJIT_INLINE T* getData() const noexcept {
return static_cast<T*>(static_cast<void*>((uint8_t*)this + sizeof(Block)));
}
template<typename T>
ASMJIT_INLINE bool canPrepend() const noexcept {
return _start > getData<void>();
}
template<typename T>
ASMJIT_INLINE bool canAppend() const noexcept {
size_t kNumBlockItems = (kBlockSize - sizeof(Block)) / sizeof(T);
size_t kBlockEnd = sizeof(Block) + kNumBlockItems * sizeof(T);
return (uintptr_t)_end - (uintptr_t)this < kBlockEnd;
}
Block* _link[2]; //!< Next and previous blocks.
void* _start; //!< Pointer to the start of the array.
void* _end; //!< Pointer to the end of the array.
};
// --------------------------------------------------------------------------
// [Construction / Destruction]
// --------------------------------------------------------------------------
ASMJIT_INLINE ZoneStackBase() noexcept {
_heap = nullptr;
_block[0] = nullptr;
_block[1] = nullptr;
}
ASMJIT_INLINE ~ZoneStackBase() noexcept { reset(); }
// --------------------------------------------------------------------------
// [Init / Reset]
// --------------------------------------------------------------------------
ASMJIT_INLINE bool isInitialized() const noexcept { return _heap != nullptr; }
ASMJIT_API Error _init(ZoneHeap* heap, size_t middleIndex) noexcept;
ASMJIT_INLINE Error reset() noexcept { return _init(nullptr, 0); }
// --------------------------------------------------------------------------
// [Accessors]
// --------------------------------------------------------------------------
//! Get a `ZoneHeap` attached to this container.
ASMJIT_INLINE ZoneHeap* getHeap() const noexcept { return _heap; }
ASMJIT_INLINE bool isEmpty() const noexcept {
ASMJIT_ASSERT(isInitialized());
return _block[0] == _block[1] && _block[0]->isEmpty();
}
// --------------------------------------------------------------------------
// [Ops]
// --------------------------------------------------------------------------
ASMJIT_API Error _prepareBlock(uint32_t side, size_t initialIndex) noexcept;
ASMJIT_API void _cleanupBlock(uint32_t side, size_t middleIndex) noexcept;
// --------------------------------------------------------------------------
// [Members]
// --------------------------------------------------------------------------
ZoneHeap* _heap; //!< ZoneHeap used to allocate data.
Block* _block[2]; //!< First and last blocks.
};
// ============================================================================
// [asmjit::ZoneStack<T>]
// ============================================================================
template<typename T>
class ZoneStack : public ZoneStackBase {
public:
enum {
kNumBlockItems = static_cast<int>((kBlockSize - sizeof(Block)) / sizeof(T)),
kStartBlockIndex = static_cast<int>(sizeof(Block)),
kMidBlockIndex = static_cast<int>(kStartBlockIndex + (kNumBlockItems / 2) * sizeof(T)),
kEndBlockIndex = static_cast<int>(kStartBlockIndex + kNumBlockItems * sizeof(T))
};
// --------------------------------------------------------------------------
// [Construction / Destruction]
// --------------------------------------------------------------------------
ASMJIT_INLINE ZoneStack() noexcept {}
ASMJIT_INLINE ~ZoneStack() noexcept {}
// --------------------------------------------------------------------------
// [Init / Reset]
// --------------------------------------------------------------------------
ASMJIT_INLINE Error init(ZoneHeap* heap) noexcept { return _init(heap, kMidBlockIndex); }
// --------------------------------------------------------------------------
// [Ops]
// --------------------------------------------------------------------------
ASMJIT_INLINE Error prepend(T item) noexcept {
ASMJIT_ASSERT(isInitialized());
Block* block = _block[kSideLeft];
if (!block->canPrepend<T>()) {
ASMJIT_PROPAGATE(_prepareBlock(kSideLeft, kEndBlockIndex));
block = _block[kSideLeft];
}
T* ptr = block->getStart<T>() - 1;
ASMJIT_ASSERT(ptr >= block->getData<T>() && ptr < block->getData<T>() + kNumBlockItems);
*ptr = item;
block->setStart<T>(ptr);
return kErrorOk;
}
ASMJIT_INLINE Error append(T item) noexcept {
ASMJIT_ASSERT(isInitialized());
Block* block = _block[kSideRight];
if (!block->canAppend<T>()) {
ASMJIT_PROPAGATE(_prepareBlock(kSideRight, kStartBlockIndex));
block = _block[kSideRight];
}
T* ptr = block->getEnd<T>();
ASMJIT_ASSERT(ptr >= block->getData<T>() && ptr < block->getData<T>() + kNumBlockItems);
*ptr++ = item;
block->setEnd(ptr);
return kErrorOk;
}
ASMJIT_INLINE T popFirst() noexcept {
ASMJIT_ASSERT(isInitialized());
ASMJIT_ASSERT(!isEmpty());
Block* block = _block[kSideLeft];
ASMJIT_ASSERT(!block->isEmpty());
T* ptr = block->getStart<T>();
T item = *ptr++;
block->setStart(ptr);
if (block->isEmpty())
_cleanupBlock(kSideLeft, kMidBlockIndex);
return item;
}
ASMJIT_INLINE T pop() noexcept {
ASMJIT_ASSERT(isInitialized());
ASMJIT_ASSERT(!isEmpty());
Block* block = _block[kSideRight];
ASMJIT_ASSERT(!block->isEmpty());
T* ptr = block->getEnd<T>();
T item = *--ptr;
block->setEnd(ptr);
if (block->isEmpty())
_cleanupBlock(kSideRight, kMidBlockIndex);
return item;
}
};
// ============================================================================
// [asmjit::ZoneHashNode]
// ============================================================================

3
src/asmjit/x86/x86assembler.cpp
View File

@@ -3870,7 +3870,8 @@ EmitModSib_LabelRip_X86:
else if (!(rmInfo & kX86MemInfo_67H_X86)) {
// ESP|RSP can't be used as INDEX in pure SIB mode, however, VSIB mode
// allows XMM4|YMM4|ZMM4 (that's why the check is before the label).
if (ASMJIT_UNLIKELY(rxReg == X86Gp::kIdSp)) goto InvalidAddressIndex;
if (ASMJIT_UNLIKELY(rxReg == X86Gp::kIdSp))
goto InvalidAddressIndex;
EmitModVSib:
rxReg &= 0x7;