From d38b12a2b588e08b87a42029b7f20a76c3e03676 Mon Sep 17 00:00:00 2001 From: kobalicek Date: Sun, 5 Mar 2023 15:27:51 +0100 Subject: [PATCH] Switched to a newer testing framework, fixed warnings on AArch64 --- src/asmjit/arm/a64operand.cpp | 96 +++---- src/asmjit/core/codeholder.cpp | 28 +- src/asmjit/core/constpool.cpp | 70 ++--- src/asmjit/core/jitallocator.cpp | 49 ++-- src/asmjit/core/operand.cpp | 136 +++++----- src/asmjit/core/string.cpp | 100 +++---- src/asmjit/core/support.cpp | 452 ++++++++++++++++--------------- src/asmjit/core/zonehash.cpp | 8 +- src/asmjit/core/zonelist.cpp | 176 ++++++------ src/asmjit/core/zonestack.cpp | 50 ++-- src/asmjit/core/zonetree.cpp | 17 +- src/asmjit/core/zonevector.cpp | 50 ++-- src/asmjit/x86/x86assembler.cpp | 2 +- src/asmjit/x86/x86instapi.cpp | 37 ++- src/asmjit/x86/x86instdb.cpp | 29 +- src/asmjit/x86/x86operand.cpp | 320 +++++++++++----------- test/asmjit_test_perf_x86.cpp | 40 +-- test/broken.cpp | 16 +- test/broken.h | 190 ++++++++----- 19 files changed, 971 insertions(+), 895 deletions(-) diff --git a/src/asmjit/arm/a64operand.cpp b/src/asmjit/arm/a64operand.cpp index 40a4a79..3dba96d 100644 --- a/src/asmjit/arm/a64operand.cpp +++ b/src/asmjit/arm/a64operand.cpp @@ -17,66 +17,66 @@ ASMJIT_BEGIN_SUB_NAMESPACE(a64) #if defined(ASMJIT_TEST) UNIT(a64_operand) { INFO("Checking if a64::reg(...) matches built-in IDs"); - EXPECT(w(5) == w5); - EXPECT(x(5) == x5); + EXPECT_EQ(w(5), w5); + EXPECT_EQ(x(5), x5); INFO("Checking Gp register properties"); - EXPECT(Gp().isReg() == true); - EXPECT(w0.isReg() == true); - EXPECT(x0.isReg() == true); - EXPECT(w0.id() == 0); - EXPECT(x0.id() == 0); - EXPECT(wzr.id() == Gp::kIdZr); - EXPECT(xzr.id() == Gp::kIdZr); - EXPECT(wsp.id() == Gp::kIdSp); - EXPECT(sp.id() == Gp::kIdSp); - EXPECT(w0.size() == 4); - EXPECT(x0.size() == 8); - EXPECT(w0.type() == RegType::kARM_GpW); - EXPECT(x0.type() == RegType::kARM_GpX); - EXPECT(w0.group() == RegGroup::kGp); - EXPECT(x0.group() == RegGroup::kGp); + EXPECT_TRUE(Gp().isReg()); + EXPECT_TRUE(w0.isReg()); + EXPECT_TRUE(x0.isReg()); + EXPECT_EQ(w0.id(), 0u); + EXPECT_EQ(x0.id(), 0u); + EXPECT_EQ(wzr.id(), Gp::kIdZr); + EXPECT_EQ(xzr.id(), Gp::kIdZr); + EXPECT_EQ(wsp.id(), Gp::kIdSp); + EXPECT_EQ(sp.id(), Gp::kIdSp); + EXPECT_EQ(w0.size(), 4u); + EXPECT_EQ(x0.size(), 8u); + EXPECT_EQ(w0.type(), RegType::kARM_GpW); + EXPECT_EQ(x0.type(), RegType::kARM_GpX); + EXPECT_EQ(w0.group(), RegGroup::kGp); + EXPECT_EQ(x0.group(), RegGroup::kGp); INFO("Checking Vec register properties"); - EXPECT(v0.type() == RegType::kARM_VecV); - EXPECT(d0.type() == RegType::kARM_VecD); - EXPECT(s0.type() == RegType::kARM_VecS); - EXPECT(h0.type() == RegType::kARM_VecH); - EXPECT(b0.type() == RegType::kARM_VecB); + EXPECT_EQ(v0.type(), RegType::kARM_VecV); + EXPECT_EQ(d0.type(), RegType::kARM_VecD); + EXPECT_EQ(s0.type(), RegType::kARM_VecS); + EXPECT_EQ(h0.type(), RegType::kARM_VecH); + EXPECT_EQ(b0.type(), RegType::kARM_VecB); - EXPECT(v0.group() == RegGroup::kVec); - EXPECT(d0.group() == RegGroup::kVec); - EXPECT(s0.group() == RegGroup::kVec); - EXPECT(h0.group() == RegGroup::kVec); - EXPECT(b0.group() == RegGroup::kVec); + EXPECT_EQ(v0.group(), RegGroup::kVec); + EXPECT_EQ(d0.group(), RegGroup::kVec); + EXPECT_EQ(s0.group(), RegGroup::kVec); + EXPECT_EQ(h0.group(), RegGroup::kVec); + EXPECT_EQ(b0.group(), RegGroup::kVec); INFO("Checking Vec register element[] access"); Vec vd_1 = v15.d(1); - EXPECT(vd_1.type() == RegType::kARM_VecV); - EXPECT(vd_1.group() == RegGroup::kVec); - EXPECT(vd_1.id() == 15); - EXPECT(vd_1.isVecD2()); - EXPECT(vd_1.elementType() == Vec::kElementTypeD); - EXPECT(vd_1.hasElementIndex()); - EXPECT(vd_1.elementIndex() == 1); + EXPECT_EQ(vd_1.type(), RegType::kARM_VecV); + EXPECT_EQ(vd_1.group(), RegGroup::kVec); + EXPECT_EQ(vd_1.id(), 15u); + EXPECT_TRUE(vd_1.isVecD2()); + EXPECT_EQ(vd_1.elementType(), Vec::kElementTypeD); + EXPECT_TRUE(vd_1.hasElementIndex()); + EXPECT_EQ(vd_1.elementIndex(), 1u); Vec vs_3 = v15.s(3); - EXPECT(vs_3.type() == RegType::kARM_VecV); - EXPECT(vs_3.group() == RegGroup::kVec); - EXPECT(vs_3.id() == 15); - EXPECT(vs_3.isVecS4()); - EXPECT(vs_3.elementType() == Vec::kElementTypeS); - EXPECT(vs_3.hasElementIndex()); - EXPECT(vs_3.elementIndex() == 3); + EXPECT_EQ(vs_3.type(), RegType::kARM_VecV); + EXPECT_EQ(vs_3.group(), RegGroup::kVec); + EXPECT_EQ(vs_3.id(), 15u); + EXPECT_TRUE(vs_3.isVecS4()); + EXPECT_EQ(vs_3.elementType(), Vec::kElementTypeS); + EXPECT_TRUE(vs_3.hasElementIndex()); + EXPECT_EQ(vs_3.elementIndex(), 3u); Vec vb_4 = v15.b4(3); - EXPECT(vb_4.type() == RegType::kARM_VecV); - EXPECT(vb_4.group() == RegGroup::kVec); - EXPECT(vb_4.id() == 15); - EXPECT(vb_4.isVecB4x4()); - EXPECT(vb_4.elementType() == Vec::kElementTypeB4); - EXPECT(vb_4.hasElementIndex()); - EXPECT(vb_4.elementIndex() == 3); + EXPECT_EQ(vb_4.type(), RegType::kARM_VecV); + EXPECT_EQ(vb_4.group(), RegGroup::kVec); + EXPECT_EQ(vb_4.id(), 15u); + EXPECT_TRUE(vb_4.isVecB4x4()); + EXPECT_EQ(vb_4.elementType(), Vec::kElementTypeB4); + EXPECT_TRUE(vb_4.hasElementIndex()); + EXPECT_EQ(vb_4.elementIndex(), 3u); } #endif diff --git a/src/asmjit/core/codeholder.cpp b/src/asmjit/core/codeholder.cpp index 3f7f5f5..6c2b762 100644 --- a/src/asmjit/core/codeholder.cpp +++ b/src/asmjit/core/codeholder.cpp @@ -1126,30 +1126,30 @@ UNIT(code_holder) { env.init(Arch::kX86); code.init(env); - EXPECT(code.arch() == Arch::kX86); + EXPECT_EQ(code.arch(), Arch::kX86); INFO("Verifying named labels"); LabelEntry* le; - EXPECT(code.newNamedLabelEntry(&le, "NamedLabel", SIZE_MAX, LabelType::kGlobal) == kErrorOk); - EXPECT(strcmp(le->name(), "NamedLabel") == 0); - EXPECT(code.labelIdByName("NamedLabel") == le->id()); + EXPECT_EQ(code.newNamedLabelEntry(&le, "NamedLabel", SIZE_MAX, LabelType::kGlobal), kErrorOk); + EXPECT_EQ(strcmp(le->name(), "NamedLabel"), 0); + EXPECT_EQ(code.labelIdByName("NamedLabel"), le->id()); INFO("Verifying section ordering"); Section* section1; - EXPECT(code.newSection(§ion1, "high-priority", SIZE_MAX, SectionFlags::kNone, 1, -1) == kErrorOk); - EXPECT(code.sections()[1] == section1); - EXPECT(code.sectionsByOrder()[0] == section1); + EXPECT_EQ(code.newSection(§ion1, "high-priority", SIZE_MAX, SectionFlags::kNone, 1, -1), kErrorOk); + EXPECT_EQ(code.sections()[1], section1); + EXPECT_EQ(code.sectionsByOrder()[0], section1); Section* section0; - EXPECT(code.newSection(§ion0, "higher-priority", SIZE_MAX, SectionFlags::kNone, 1, -2) == kErrorOk); - EXPECT(code.sections()[2] == section0); - EXPECT(code.sectionsByOrder()[0] == section0); - EXPECT(code.sectionsByOrder()[1] == section1); + EXPECT_EQ(code.newSection(§ion0, "higher-priority", SIZE_MAX, SectionFlags::kNone, 1, -2), kErrorOk); + EXPECT_EQ(code.sections()[2], section0); + EXPECT_EQ(code.sectionsByOrder()[0], section0); + EXPECT_EQ(code.sectionsByOrder()[1], section1); Section* section3; - EXPECT(code.newSection(§ion3, "low-priority", SIZE_MAX, SectionFlags::kNone, 1, 2) == kErrorOk); - EXPECT(code.sections()[3] == section3); - EXPECT(code.sectionsByOrder()[3] == section3); + EXPECT_EQ(code.newSection(§ion3, "low-priority", SIZE_MAX, SectionFlags::kNone, 1, 2), kErrorOk); + EXPECT_EQ(code.sections()[3], section3); + EXPECT_EQ(code.sectionsByOrder()[3], section3); } #endif diff --git a/src/asmjit/core/constpool.cpp b/src/asmjit/core/constpool.cpp index ad5fe4f..ad0e436 100644 --- a/src/asmjit/core/constpool.cpp +++ b/src/asmjit/core/constpool.cpp @@ -252,18 +252,18 @@ UNIT(const_pool) { size_t curOffset; uint64_t c = 0x0101010101010101u; - EXPECT(pool.add(&c, 8, prevOffset) == kErrorOk); - EXPECT(prevOffset == 0); + EXPECT_EQ(pool.add(&c, 8, prevOffset), kErrorOk); + EXPECT_EQ(prevOffset, 0u); for (i = 1; i < kCount; i++) { c++; - EXPECT(pool.add(&c, 8, curOffset) == kErrorOk); - EXPECT(prevOffset + 8 == curOffset); - EXPECT(pool.size() == (i + 1) * 8); + EXPECT_EQ(pool.add(&c, 8, curOffset), kErrorOk); + EXPECT_EQ(prevOffset + 8, curOffset); + EXPECT_EQ(pool.size(), (i + 1) * 8); prevOffset = curOffset; } - EXPECT(pool.alignment() == 8); + EXPECT_EQ(pool.alignment(), 8u); } INFO("Retrieving %u constants from the pool", kCount); @@ -272,8 +272,8 @@ UNIT(const_pool) { for (i = 0; i < kCount; i++) { size_t offset; - EXPECT(pool.add(&c, 8, offset) == kErrorOk); - EXPECT(offset == i * 8); + EXPECT_EQ(pool.add(&c, 8, offset), kErrorOk); + EXPECT_EQ(offset, i * 8); c++; } } @@ -283,8 +283,8 @@ UNIT(const_pool) { uint32_t c = 0x01010101; for (i = 0; i < kCount; i++) { size_t offset; - EXPECT(pool.add(&c, 4, offset) == kErrorOk); - EXPECT(offset == i * 8); + EXPECT_EQ(pool.add(&c, 4, offset), kErrorOk); + EXPECT_EQ(offset, i * 8); c++; } } @@ -294,9 +294,9 @@ UNIT(const_pool) { uint16_t c = 0xFFFF; size_t offset; - EXPECT(pool.add(&c, 2, offset) == kErrorOk); - EXPECT(offset == kCount * 8); - EXPECT(pool.alignment() == 8); + EXPECT_EQ(pool.add(&c, 2, offset), kErrorOk); + EXPECT_EQ(offset, kCount * 8); + EXPECT_EQ(pool.alignment(), 8u); } INFO("Adding 8 byte constant to check if pool gets aligned again"); @@ -304,8 +304,8 @@ UNIT(const_pool) { uint64_t c = 0xFFFFFFFFFFFFFFFFu; size_t offset; - EXPECT(pool.add(&c, 8, offset) == kErrorOk); - EXPECT(offset == kCount * 8 + 8); + EXPECT_EQ(pool.add(&c, 8, offset), kErrorOk); + EXPECT_EQ(offset, kCount * 8 + 8u); } INFO("Adding 2 byte constant to verify the gap is filled"); @@ -313,9 +313,9 @@ UNIT(const_pool) { uint16_t c = 0xFFFE; size_t offset; - EXPECT(pool.add(&c, 2, offset) == kErrorOk); - EXPECT(offset == kCount * 8 + 2); - EXPECT(pool.alignment() == 8); + EXPECT_EQ(pool.add(&c, 2, offset), kErrorOk); + EXPECT_EQ(offset, kCount * 8 + 2); + EXPECT_EQ(pool.alignment(), 8u); } INFO("Checking reset functionality"); @@ -323,8 +323,8 @@ UNIT(const_pool) { pool.reset(&zone); zone.reset(); - EXPECT(pool.size() == 0); - EXPECT(pool.alignment() == 0); + EXPECT_EQ(pool.size(), 0u); + EXPECT_EQ(pool.alignment(), 0u); } INFO("Checking pool alignment when combined constants are added"); @@ -333,29 +333,29 @@ UNIT(const_pool) { size_t offset; pool.add(bytes, 1, offset); - EXPECT(pool.size() == 1); - EXPECT(pool.alignment() == 1); - EXPECT(offset == 0); + EXPECT_EQ(pool.size(), 1u); + EXPECT_EQ(pool.alignment(), 1u); + EXPECT_EQ(offset, 0u); pool.add(bytes, 2, offset); - EXPECT(pool.size() == 4); - EXPECT(pool.alignment() == 2); - EXPECT(offset == 2); + EXPECT_EQ(pool.size(), 4u); + EXPECT_EQ(pool.alignment(), 2u); + EXPECT_EQ(offset, 2u); pool.add(bytes, 4, offset); - EXPECT(pool.size() == 8); - EXPECT(pool.alignment() == 4); - EXPECT(offset == 4); + EXPECT_EQ(pool.size(), 8u); + EXPECT_EQ(pool.alignment(), 4u); + EXPECT_EQ(offset, 4u); pool.add(bytes, 4, offset); - EXPECT(pool.size() == 8); - EXPECT(pool.alignment() == 4); - EXPECT(offset == 4); + EXPECT_EQ(pool.size(), 8u); + EXPECT_EQ(pool.alignment(), 4u); + EXPECT_EQ(offset, 4u); pool.add(bytes, 32, offset); - EXPECT(pool.size() == 64); - EXPECT(pool.alignment() == 32); - EXPECT(offset == 32); + EXPECT_EQ(pool.size(), 64u); + EXPECT_EQ(pool.alignment(), 32u); + EXPECT_EQ(offset, 32u); } } #endif diff --git a/src/asmjit/core/jitallocator.cpp b/src/asmjit/core/jitallocator.cpp index 5b24b58..1dbc671 100644 --- a/src/asmjit/core/jitallocator.cpp +++ b/src/asmjit/core/jitallocator.cpp @@ -1104,16 +1104,16 @@ public: Record* record; record = _records.get(p); - if (record) - EXPECT(record == nullptr, "Address [%p:%p] collides with a newly allocated [%p:%p]\n", record->addr, record->addr + record->size, p, p + size); + EXPECT_NULL(record) + .message("Address [%p:%p] collides with a newly allocated [%p:%p]\n", record->addr, record->addr + record->size, p, p + size); record = _records.get(pEnd); - if (record) - EXPECT(record == nullptr, "Address [%p:%p] collides with a newly allocated [%p:%p]\n", record->addr, record->addr + record->size, p, p + size); + EXPECT_NULL(record) + .message("Address [%p:%p] collides with a newly allocated [%p:%p]\n", record->addr, record->addr + record->size, p, p + size); uint64_t pattern = _rng.nextUInt64(); record = _heap.newT(pRX, pRW, size, pattern); - EXPECT(record != nullptr, "Out of memory, cannot allocate 'Record'"); + EXPECT_NOT_NULL(record); { VirtMem::ProtectJitReadWriteScope scope(pRW, size); @@ -1121,17 +1121,17 @@ public: } VirtMem::flushInstructionCache(pRX, size); - EXPECT(JitAllocatorUtils::verifyPattern64(pRX, pattern, size) == true); + EXPECT_TRUE(JitAllocatorUtils::verifyPattern64(pRX, pattern, size)); _records.insert(record); } void _remove(void* p) noexcept { Record* record = _records.get(static_cast(p)); - EXPECT(record != nullptr, "Address [%p] doesn't exist\n", p); + EXPECT_NOT_NULL(record); - EXPECT(JitAllocatorUtils::verifyPattern64(record->rx(), record->pattern, record->size) == true); - EXPECT(JitAllocatorUtils::verifyPattern64(record->rw(), record->pattern, record->size) == true); + EXPECT_TRUE(JitAllocatorUtils::verifyPattern64(record->rx(), record->pattern, record->size)); + EXPECT_TRUE(JitAllocatorUtils::verifyPattern64(record->rw(), record->pattern, record->size)); _records.remove(record); _heap.release(record, sizeof(Record)); @@ -1142,7 +1142,8 @@ public: void* rwPtr; Error err = _allocator.alloc(&rxPtr, &rwPtr, size); - EXPECT(err == kErrorOk, "JitAllocator failed to allocate %zu bytes\n", size); + EXPECT_EQ(err, kErrorOk) + .message("JitAllocator failed to allocate %zu bytes\n", size); _insert(rxPtr, rwPtr, size); return rxPtr; @@ -1150,18 +1151,20 @@ public: void release(void* p) noexcept { _remove(p); - EXPECT(_allocator.release(p) == kErrorOk, "JitAllocator failed to release '%p'\n", p); + EXPECT_EQ(_allocator.release(p), kErrorOk) + .message("JitAllocator failed to release '%p'\n", p); } void shrink(void* p, size_t newSize) noexcept { Record* record = _records.get(static_cast(p)); - EXPECT(record != nullptr, "Address [%p] doesn't exist\n", p); + EXPECT_NOT_NULL(record); if (!newSize) return release(p); Error err = _allocator.shrink(p, newSize); - EXPECT(err == kErrorOk, "JitAllocator failed to shrink %p to %zu bytes\n", p, newSize); + EXPECT_EQ(err, kErrorOk) + .message("JitAllocator failed to shrink %p to %zu bytes\n", p, newSize); record->size = newSize; } @@ -1203,7 +1206,8 @@ static void BitVectorRangeIterator_testRandom(Random& rnd, size_t count) noexcep } for (size_t j = 0; j < kPatternSize; j++) { - EXPECT(in[j] == out[j], "Invalid pattern detected at [%zu] (%llX != %llX)", j, (unsigned long long)in[j], (unsigned long long)out[j]); + EXPECT_EQ(in[j], out[j]) + .message("Invalid pattern detected at [%zu] (%llX != %llX)", j, (unsigned long long)in[j], (unsigned long long)out[j]); } } } @@ -1259,8 +1263,7 @@ static void test_jit_allocator_alloc_release() noexcept { INFO(" Memory alloc/release test - %d allocations", kCount); void** ptrArray = (void**)::malloc(sizeof(void*) * size_t(kCount)); - EXPECT(ptrArray != nullptr, - "Couldn't allocate '%u' bytes for pointer-array", unsigned(sizeof(void*) * size_t(kCount))); + EXPECT_NOT_NULL(ptrArray); // Random blocks tests... INFO(" Allocating random blocks..."); @@ -1351,18 +1354,18 @@ static void test_jit_allocator_query() noexcept { void* rwPtr = nullptr; size_t size = 100; - EXPECT(allocator.alloc(&rxPtr, &rwPtr, size) == kErrorOk); - EXPECT(rxPtr != nullptr); - EXPECT(rwPtr != nullptr); + EXPECT_EQ(allocator.alloc(&rxPtr, &rwPtr, size), kErrorOk); + EXPECT_NOT_NULL(rxPtr); + EXPECT_NOT_NULL(rwPtr); void* rxPtrQueried = nullptr; void* rwPtrQueried = nullptr; size_t sizeQueried; - EXPECT(allocator.query(rxPtr, &rxPtrQueried, &rwPtrQueried, &sizeQueried) == kErrorOk); - EXPECT(rxPtrQueried == rxPtr); - EXPECT(rwPtrQueried == rwPtr); - EXPECT(sizeQueried == Support::alignUp(size, allocator.granularity())); + EXPECT_EQ(allocator.query(rxPtr, &rxPtrQueried, &rwPtrQueried, &sizeQueried), kErrorOk); + EXPECT_EQ(rxPtrQueried, rxPtr); + EXPECT_EQ(rwPtrQueried, rwPtr); + EXPECT_EQ(sizeQueried, Support::alignUp(size, allocator.granularity())); } UNIT(jit_allocator) { diff --git a/src/asmjit/core/operand.cpp b/src/asmjit/core/operand.cpp index ee02681..b78dc54 100644 --- a/src/asmjit/core/operand.cpp +++ b/src/asmjit/core/operand.cpp @@ -19,36 +19,36 @@ enum class StrongEnumForImmTests : uint32_t { UNIT(operand) { INFO("Checking operand sizes"); - EXPECT(sizeof(Operand) == 16); - EXPECT(sizeof(BaseReg) == 16); - EXPECT(sizeof(BaseMem) == 16); - EXPECT(sizeof(Imm) == 16); - EXPECT(sizeof(Label) == 16); + EXPECT_EQ(sizeof(Operand), 16u); + EXPECT_EQ(sizeof(BaseReg), 16u); + EXPECT_EQ(sizeof(BaseMem), 16u); + EXPECT_EQ(sizeof(Imm), 16u); + EXPECT_EQ(sizeof(Label), 16u); INFO("Checking basic functionality of Operand"); Operand a, b; Operand dummy; - EXPECT(a.isNone() == true); - EXPECT(a.isReg() == false); - EXPECT(a.isMem() == false); - EXPECT(a.isImm() == false); - EXPECT(a.isLabel() == false); - EXPECT(a == b); - EXPECT(a._data[0] == 0); - EXPECT(a._data[1] == 0); + EXPECT_TRUE(a.isNone()); + EXPECT_FALSE(a.isReg()); + EXPECT_FALSE(a.isMem()); + EXPECT_FALSE(a.isImm()); + EXPECT_FALSE(a.isLabel()); + EXPECT_EQ(a, b); + EXPECT_EQ(a._data[0], 0u); + EXPECT_EQ(a._data[1], 0u); INFO("Checking basic functionality of Label"); Label label; - EXPECT(label.isValid() == false); - EXPECT(label.id() == Globals::kInvalidId); + EXPECT_FALSE(label.isValid()); + EXPECT_EQ(label.id(), Globals::kInvalidId); INFO("Checking basic functionality of BaseReg"); - EXPECT(BaseReg().isReg() == true); - EXPECT(BaseReg().isValid() == false); - EXPECT(BaseReg()._data[0] == 0); - EXPECT(BaseReg()._data[1] == 0); - EXPECT(dummy.as().isValid() == false); + EXPECT_TRUE(BaseReg().isReg()); + EXPECT_FALSE(BaseReg().isValid()); + EXPECT_EQ(BaseReg()._data[0], 0u); + EXPECT_EQ(BaseReg()._data[1], 0u); + EXPECT_FALSE(dummy.as().isValid()); // Create some register (not specific to any architecture). OperandSignature rSig = OperandSignature::fromOpType(OperandType::kReg) | @@ -57,75 +57,75 @@ UNIT(operand) { OperandSignature::fromSize(8); BaseReg r1(rSig, 5); - EXPECT(r1.isValid() == true); - EXPECT(r1.isReg() == true); - EXPECT(r1.isReg(RegType::kVec128) == true); - EXPECT(r1.isPhysReg() == true); - EXPECT(r1.isVirtReg() == false); - EXPECT(r1.signature() == rSig); - EXPECT(r1.type() == RegType::kVec128); - EXPECT(r1.group() == RegGroup::kVec); - EXPECT(r1.size() == 8); - EXPECT(r1.id() == 5); - EXPECT(r1.isReg(RegType::kVec128, 5) == true); // RegType and Id. - EXPECT(r1._data[0] == 0); - EXPECT(r1._data[1] == 0); + EXPECT_TRUE(r1.isValid()); + EXPECT_TRUE(r1.isReg()); + EXPECT_TRUE(r1.isReg(RegType::kVec128)); + EXPECT_TRUE(r1.isPhysReg()); + EXPECT_FALSE(r1.isVirtReg()); + EXPECT_EQ(r1.signature(), rSig); + EXPECT_EQ(r1.type(), RegType::kVec128); + EXPECT_EQ(r1.group(), RegGroup::kVec); + EXPECT_EQ(r1.size(), 8u); + EXPECT_EQ(r1.id(), 5u); + EXPECT_TRUE(r1.isReg(RegType::kVec128, 5)); // RegType and Id. + EXPECT_EQ(r1._data[0], 0u); + EXPECT_EQ(r1._data[1], 0u); // The same type of register having different id. BaseReg r2(r1, 6); - EXPECT(r2.isValid() == true); - EXPECT(r2.isReg() == true); - EXPECT(r2.isReg(RegType::kVec128) == true); - EXPECT(r2.isPhysReg() == true); - EXPECT(r2.isVirtReg() == false); - EXPECT(r2.signature() == rSig); - EXPECT(r2.type() == r1.type()); - EXPECT(r2.group() == r1.group()); - EXPECT(r2.size() == r1.size()); - EXPECT(r2.id() == 6); - EXPECT(r2.isReg(RegType::kVec128, 6) == true); + EXPECT_TRUE(r2.isValid()); + EXPECT_TRUE(r2.isReg()); + EXPECT_TRUE(r2.isReg(RegType::kVec128)); + EXPECT_TRUE(r2.isPhysReg()); + EXPECT_FALSE(r2.isVirtReg()); + EXPECT_EQ(r2.signature(), rSig); + EXPECT_EQ(r2.type(), r1.type()); + EXPECT_EQ(r2.group(), r1.group()); + EXPECT_EQ(r2.size(), r1.size()); + EXPECT_EQ(r2.id(), 6u); + EXPECT_TRUE(r2.isReg(RegType::kVec128, 6)); r1.reset(); - EXPECT(!r1.isReg()); - EXPECT(!r1.isValid()); + EXPECT_FALSE(r1.isReg()); + EXPECT_FALSE(r1.isValid()); INFO("Checking basic functionality of BaseMem"); BaseMem m; - EXPECT(m.isMem()); - EXPECT(m == BaseMem()); - EXPECT(m.hasBase() == false); - EXPECT(m.hasIndex() == false); - EXPECT(m.hasOffset() == false); - EXPECT(m.isOffset64Bit() == true); - EXPECT(m.offset() == 0); + EXPECT_TRUE(m.isMem()); + EXPECT_EQ(m, BaseMem()); + EXPECT_FALSE(m.hasBase()); + EXPECT_FALSE(m.hasIndex()); + EXPECT_FALSE(m.hasOffset()); + EXPECT_TRUE(m.isOffset64Bit()); + EXPECT_EQ(m.offset(), 0); m.setOffset(-1); - EXPECT(m.offsetLo32() == -1); - EXPECT(m.offset() == -1); + EXPECT_EQ(m.offsetLo32(), -1); + EXPECT_EQ(m.offset(), -1); int64_t x = int64_t(0xFF00FF0000000001u); int32_t xHi = int32_t(0xFF00FF00u); m.setOffset(x); - EXPECT(m.offset() == x); - EXPECT(m.offsetLo32() == 1); - EXPECT(m.offsetHi32() == xHi); + EXPECT_EQ(m.offset(), x); + EXPECT_EQ(m.offsetLo32(), 1); + EXPECT_EQ(m.offsetHi32(), xHi); INFO("Checking basic functionality of Imm"); Imm immValue(-42); - EXPECT(immValue.type() == ImmType::kInt); - EXPECT(Imm(-1).value() == -1); - EXPECT(imm(-1).value() == -1); - EXPECT(immValue.value() == -42); - EXPECT(imm(0xFFFFFFFF).value() == int64_t(0xFFFFFFFF)); + EXPECT_EQ(immValue.type(), ImmType::kInt); + EXPECT_EQ(Imm(-1).value(), -1); + EXPECT_EQ(imm(-1).value(), -1); + EXPECT_EQ(immValue.value(), -42); + EXPECT_EQ(imm(0xFFFFFFFF).value(), int64_t(0xFFFFFFFF)); Imm immDouble(0.4); - EXPECT(immDouble.type() == ImmType::kDouble); - EXPECT(immDouble.valueAs() == 0.4); - EXPECT(immDouble == imm(0.4)); + EXPECT_EQ(immDouble.type(), ImmType::kDouble); + EXPECT_EQ(immDouble.valueAs(), 0.4); + EXPECT_EQ(immDouble, imm(0.4)); - EXPECT(Imm(StrongEnumForImmTests::kValue0).value() == 0); - EXPECT(Imm(StrongEnumForImmTests::kValue0xFFFFFFFF).value() == 0xFFFFFFFFu); + EXPECT_EQ(Imm(StrongEnumForImmTests::kValue0).value(), 0); + EXPECT_EQ(Imm(StrongEnumForImmTests::kValue0xFFFFFFFF).value(), 0xFFFFFFFFu); } #endif diff --git a/src/asmjit/core/string.cpp b/src/asmjit/core/string.cpp index 83dc6ef..518dd71 100644 --- a/src/asmjit/core/string.cpp +++ b/src/asmjit/core/string.cpp @@ -491,68 +491,68 @@ bool String::eq(const char* other, size_t size) const noexcept { UNIT(core_string) { String s; - EXPECT(s.isLargeOrExternal() == false); - EXPECT(s.isExternal() == false); + EXPECT_FALSE(s.isLargeOrExternal()); + EXPECT_FALSE(s.isExternal()); - EXPECT(s.assign('a') == kErrorOk); - EXPECT(s.size() == 1); - EXPECT(s.capacity() == String::kSSOCapacity); - EXPECT(s.data()[0] == 'a'); - EXPECT(s.data()[1] == '\0'); - EXPECT(s.eq("a") == true); - EXPECT(s.eq("a", 1) == true); + EXPECT_EQ(s.assign('a'), kErrorOk); + EXPECT_EQ(s.size(), 1u); + EXPECT_EQ(s.capacity(), String::kSSOCapacity); + EXPECT_EQ(s.data()[0], 'a'); + EXPECT_EQ(s.data()[1], '\0'); + EXPECT_TRUE(s.eq("a")); + EXPECT_TRUE(s.eq("a", 1)); - EXPECT(s.assignChars('b', 4) == kErrorOk); - EXPECT(s.size() == 4); - EXPECT(s.capacity() == String::kSSOCapacity); - EXPECT(s.data()[0] == 'b'); - EXPECT(s.data()[1] == 'b'); - EXPECT(s.data()[2] == 'b'); - EXPECT(s.data()[3] == 'b'); - EXPECT(s.data()[4] == '\0'); - EXPECT(s.eq("bbbb") == true); - EXPECT(s.eq("bbbb", 4) == true); + EXPECT_EQ(s.assignChars('b', 4), kErrorOk); + EXPECT_EQ(s.size(), 4u); + EXPECT_EQ(s.capacity(), String::kSSOCapacity); + EXPECT_EQ(s.data()[0], 'b'); + EXPECT_EQ(s.data()[1], 'b'); + EXPECT_EQ(s.data()[2], 'b'); + EXPECT_EQ(s.data()[3], 'b'); + EXPECT_EQ(s.data()[4], '\0'); + EXPECT_TRUE(s.eq("bbbb")); + EXPECT_TRUE(s.eq("bbbb", 4)); - EXPECT(s.assign("abc") == kErrorOk); - EXPECT(s.size() == 3); - EXPECT(s.capacity() == String::kSSOCapacity); - EXPECT(s.data()[0] == 'a'); - EXPECT(s.data()[1] == 'b'); - EXPECT(s.data()[2] == 'c'); - EXPECT(s.data()[3] == '\0'); - EXPECT(s.eq("abc") == true); - EXPECT(s.eq("abc", 3) == true); + EXPECT_EQ(s.assign("abc"), kErrorOk); + EXPECT_EQ(s.size(), 3u); + EXPECT_EQ(s.capacity(), String::kSSOCapacity); + EXPECT_EQ(s.data()[0], 'a'); + EXPECT_EQ(s.data()[1], 'b'); + EXPECT_EQ(s.data()[2], 'c'); + EXPECT_EQ(s.data()[3], '\0'); + EXPECT_TRUE(s.eq("abc")); + EXPECT_TRUE(s.eq("abc", 3)); const char* large = "Large string that will not fit into SSO buffer"; - EXPECT(s.assign(large) == kErrorOk); - EXPECT(s.isLargeOrExternal() == true); - EXPECT(s.size() == strlen(large)); - EXPECT(s.capacity() > String::kSSOCapacity); - EXPECT(s.eq(large) == true); - EXPECT(s.eq(large, strlen(large)) == true); + EXPECT_EQ(s.assign(large), kErrorOk); + EXPECT_TRUE(s.isLargeOrExternal()); + EXPECT_EQ(s.size(), strlen(large)); + EXPECT_GT(s.capacity(), String::kSSOCapacity); + EXPECT_TRUE(s.eq(large)); + EXPECT_TRUE(s.eq(large, strlen(large))); const char* additional = " (additional content)"; - EXPECT(s.isLargeOrExternal() == true); - EXPECT(s.append(additional) == kErrorOk); - EXPECT(s.size() == strlen(large) + strlen(additional)); + EXPECT_TRUE(s.isLargeOrExternal()); + EXPECT_EQ(s.append(additional), kErrorOk); + EXPECT_EQ(s.size(), strlen(large) + strlen(additional)); - EXPECT(s.clear() == kErrorOk); - EXPECT(s.size() == 0); - EXPECT(s.empty() == true); - EXPECT(s.data()[0] == '\0'); - EXPECT(s.isLargeOrExternal() == true); // Clear should never release the memory. + EXPECT_EQ(s.clear(), kErrorOk); + EXPECT_EQ(s.size(), 0u); + EXPECT_TRUE(s.empty()); + EXPECT_EQ(s.data()[0], '\0'); + EXPECT_TRUE(s.isLargeOrExternal()); // Clear should never release the memory. - EXPECT(s.appendUInt(1234) == kErrorOk); - EXPECT(s.eq("1234") == true); + EXPECT_EQ(s.appendUInt(1234), kErrorOk); + EXPECT_TRUE(s.eq("1234")); - EXPECT(s.assignUInt(0xFFFF, 16, 0, StringFormatFlags::kAlternate) == kErrorOk); - EXPECT(s.eq("0xFFFF")); + EXPECT_EQ(s.assignUInt(0xFFFF, 16, 0, StringFormatFlags::kAlternate), kErrorOk); + EXPECT_TRUE(s.eq("0xFFFF")); StringTmp<64> sTmp; - EXPECT(sTmp.isLargeOrExternal()); - EXPECT(sTmp.isExternal()); - EXPECT(sTmp.appendChars(' ', 1000) == kErrorOk); - EXPECT(!sTmp.isExternal()); + EXPECT_TRUE(sTmp.isLargeOrExternal()); + EXPECT_TRUE(sTmp.isExternal()); + EXPECT_EQ(sTmp.appendChars(' ', 1000), kErrorOk); + EXPECT_FALSE(sTmp.isExternal()); } #endif diff --git a/src/asmjit/core/support.cpp b/src/asmjit/core/support.cpp index 245398f..bebabbc 100644 --- a/src/asmjit/core/support.cpp +++ b/src/asmjit/core/support.cpp @@ -15,74 +15,76 @@ ASMJIT_BEGIN_NAMESPACE template static void testArrays(const T* a, const T* b, size_t size) noexcept { for (size_t i = 0; i < size; i++) - EXPECT(a[i] == b[i], "Mismatch at %u", unsigned(i)); + EXPECT_EQ(a[i], b[i]) + .message("Mismatch at %u", unsigned(i)); } static void testAlignment() noexcept { INFO("Support::isAligned()"); - EXPECT(Support::isAligned(0xFFFF, 4) == false); - EXPECT(Support::isAligned(0xFFF4, 4) == true); - EXPECT(Support::isAligned(0xFFF8, 8) == true); - EXPECT(Support::isAligned(0xFFF0, 16) == true); + EXPECT_FALSE(Support::isAligned(0xFFFF, 4u)); + EXPECT_TRUE(Support::isAligned(0xFFF4, 4u)); + EXPECT_TRUE(Support::isAligned(0xFFF8, 8u)); + EXPECT_TRUE(Support::isAligned(0xFFF0, 16u)); INFO("Support::alignUp()"); - EXPECT(Support::alignUp(0xFFFF, 4) == 0x10000); - EXPECT(Support::alignUp(0xFFF4, 4) == 0x0FFF4); - EXPECT(Support::alignUp(0xFFF8, 8) == 0x0FFF8); - EXPECT(Support::alignUp(0xFFF0, 16) == 0x0FFF0); - EXPECT(Support::alignUp(0xFFF0, 32) == 0x10000); + EXPECT_EQ(Support::alignUp(0xFFFF, 4), 0x10000u); + EXPECT_EQ(Support::alignUp(0xFFF4, 4), 0x0FFF4u); + EXPECT_EQ(Support::alignUp(0xFFF8, 8), 0x0FFF8u); + EXPECT_EQ(Support::alignUp(0xFFF0, 16), 0x0FFF0u); + EXPECT_EQ(Support::alignUp(0xFFF0, 32), 0x10000u); INFO("Support::alignUpDiff()"); - EXPECT(Support::alignUpDiff(0xFFFF, 4) == 1); - EXPECT(Support::alignUpDiff(0xFFF4, 4) == 0); - EXPECT(Support::alignUpDiff(0xFFF8, 8) == 0); - EXPECT(Support::alignUpDiff(0xFFF0, 16) == 0); - EXPECT(Support::alignUpDiff(0xFFF0, 32) == 16); + EXPECT_EQ(Support::alignUpDiff(0xFFFF, 4), 1u); + EXPECT_EQ(Support::alignUpDiff(0xFFF4, 4), 0u); + EXPECT_EQ(Support::alignUpDiff(0xFFF8, 8), 0u); + EXPECT_EQ(Support::alignUpDiff(0xFFF0, 16), 0u); + EXPECT_EQ(Support::alignUpDiff(0xFFF0, 32), 16u); INFO("Support::alignUpPowerOf2()"); - EXPECT(Support::alignUpPowerOf2(0x0000) == 0x00000); - EXPECT(Support::alignUpPowerOf2(0xFFFF) == 0x10000); - EXPECT(Support::alignUpPowerOf2(0xF123) == 0x10000); - EXPECT(Support::alignUpPowerOf2(0x0F00) == 0x01000); - EXPECT(Support::alignUpPowerOf2(0x0100) == 0x00100); - EXPECT(Support::alignUpPowerOf2(0x1001) == 0x02000); + EXPECT_EQ(Support::alignUpPowerOf2(0x0000), 0x00000u); + EXPECT_EQ(Support::alignUpPowerOf2(0xFFFF), 0x10000u); + EXPECT_EQ(Support::alignUpPowerOf2(0xF123), 0x10000u); + EXPECT_EQ(Support::alignUpPowerOf2(0x0F00), 0x01000u); + EXPECT_EQ(Support::alignUpPowerOf2(0x0100), 0x00100u); + EXPECT_EQ(Support::alignUpPowerOf2(0x1001), 0x02000u); } static void testBitUtils() noexcept { uint32_t i; INFO("Support::shl() / shr()"); - EXPECT(Support::shl(int32_t(0x00001111), 16) == int32_t(0x11110000u)); - EXPECT(Support::shl(uint32_t(0x00001111), 16) == uint32_t(0x11110000u)); - EXPECT(Support::shr(int32_t(0x11110000u), 16) == int32_t(0x00001111u)); - EXPECT(Support::shr(uint32_t(0x11110000u), 16) == uint32_t(0x00001111u)); - EXPECT(Support::sar(int32_t(0xFFFF0000u), 16) == int32_t(0xFFFFFFFFu)); - EXPECT(Support::sar(uint32_t(0xFFFF0000u), 16) == uint32_t(0xFFFFFFFFu)); + EXPECT_EQ(Support::shl(int32_t(0x00001111), 16), int32_t(0x11110000u)); + EXPECT_EQ(Support::shl(uint32_t(0x00001111), 16), uint32_t(0x11110000u)); + EXPECT_EQ(Support::shr(int32_t(0x11110000u), 16), int32_t(0x00001111u)); + EXPECT_EQ(Support::shr(uint32_t(0x11110000u), 16), uint32_t(0x00001111u)); + EXPECT_EQ(Support::sar(int32_t(0xFFFF0000u), 16), int32_t(0xFFFFFFFFu)); + EXPECT_EQ(Support::sar(uint32_t(0xFFFF0000u), 16), uint32_t(0xFFFFFFFFu)); INFO("Support::blsi()"); - for (i = 0; i < 32; i++) EXPECT(Support::blsi(uint32_t(1) << i) == uint32_t(1) << i); - for (i = 0; i < 31; i++) EXPECT(Support::blsi(uint32_t(3) << i) == uint32_t(1) << i); - for (i = 0; i < 64; i++) EXPECT(Support::blsi(uint64_t(1) << i) == uint64_t(1) << i); - for (i = 0; i < 63; i++) EXPECT(Support::blsi(uint64_t(3) << i) == uint64_t(1) << i); + for (i = 0; i < 32; i++) EXPECT_EQ(Support::blsi(uint32_t(1) << i), uint32_t(1) << i); + for (i = 0; i < 31; i++) EXPECT_EQ(Support::blsi(uint32_t(3) << i), uint32_t(1) << i); + for (i = 0; i < 64; i++) EXPECT_EQ(Support::blsi(uint64_t(1) << i), uint64_t(1) << i); + for (i = 0; i < 63; i++) EXPECT_EQ(Support::blsi(uint64_t(3) << i), uint64_t(1) << i); INFO("Support::ctz()"); - for (i = 0; i < 32; i++) EXPECT(Support::Internal::clzFallback(uint32_t(1) << i) == 31 - i); - for (i = 0; i < 64; i++) EXPECT(Support::Internal::clzFallback(uint64_t(1) << i) == 63 - i); - for (i = 0; i < 32; i++) EXPECT(Support::Internal::ctzFallback(uint32_t(1) << i) == i); - for (i = 0; i < 64; i++) EXPECT(Support::Internal::ctzFallback(uint64_t(1) << i) == i); - for (i = 0; i < 32; i++) EXPECT(Support::clz(uint32_t(1) << i) == 31 - i); - for (i = 0; i < 64; i++) EXPECT(Support::clz(uint64_t(1) << i) == 63 - i); - for (i = 0; i < 32; i++) EXPECT(Support::ctz(uint32_t(1) << i) == i); - for (i = 0; i < 64; i++) EXPECT(Support::ctz(uint64_t(1) << i) == i); + for (i = 0; i < 32; i++) EXPECT_EQ(Support::Internal::clzFallback(uint32_t(1) << i), 31 - i); + for (i = 0; i < 64; i++) EXPECT_EQ(Support::Internal::clzFallback(uint64_t(1) << i), 63 - i); + for (i = 0; i < 32; i++) EXPECT_EQ(Support::Internal::ctzFallback(uint32_t(1) << i), i); + for (i = 0; i < 64; i++) EXPECT_EQ(Support::Internal::ctzFallback(uint64_t(1) << i), i); + for (i = 0; i < 32; i++) EXPECT_EQ(Support::clz(uint32_t(1) << i), 31 - i); + for (i = 0; i < 64; i++) EXPECT_EQ(Support::clz(uint64_t(1) << i), 63 - i); + for (i = 0; i < 32; i++) EXPECT_EQ(Support::ctz(uint32_t(1) << i), i); + for (i = 0; i < 64; i++) EXPECT_EQ(Support::ctz(uint64_t(1) << i), i); INFO("Support::bitMask()"); - EXPECT(Support::bitMask(0, 1, 7) == 0x83u); + EXPECT_EQ(Support::bitMask(0, 1, 7), 0x83u); for (i = 0; i < 32; i++) - EXPECT(Support::bitMask(i) == (1u << i)); + EXPECT_EQ(Support::bitMask(i), (1u << i)); INFO("Support::bitTest()"); for (i = 0; i < 32; i++) { - EXPECT(Support::bitTest((1 << i), i) == true, "Support::bitTest(%X, %u) should return true", (1 << i), i); + EXPECT_TRUE(Support::bitTest((1 << i), i)) + .message("Support::bitTest(%X, %u) should return true", (1 << i), i); } INFO("Support::lsbMask()"); @@ -90,7 +92,7 @@ static void testBitUtils() noexcept { uint32_t expectedBits = 0; for (uint32_t b = 0; b < i; b++) expectedBits |= uint32_t(1) << b; - EXPECT(Support::lsbMask(i) == expectedBits); + EXPECT_EQ(Support::lsbMask(i), expectedBits); } INFO("Support::lsbMask()"); @@ -98,31 +100,31 @@ static void testBitUtils() noexcept { uint64_t expectedBits = 0; for (uint32_t b = 0; b < i; b++) expectedBits |= uint64_t(1) << b; - EXPECT(Support::lsbMask(i) == expectedBits); + EXPECT_EQ(Support::lsbMask(i), expectedBits); } INFO("Support::popcnt()"); - for (i = 0; i < 32; i++) EXPECT(Support::popcnt((uint32_t(1) << i)) == 1); - for (i = 0; i < 64; i++) EXPECT(Support::popcnt((uint64_t(1) << i)) == 1); - EXPECT(Support::popcnt(0x000000F0) == 4); - EXPECT(Support::popcnt(0x10101010) == 4); - EXPECT(Support::popcnt(0xFF000000) == 8); - EXPECT(Support::popcnt(0xFFFFFFF7) == 31); - EXPECT(Support::popcnt(0x7FFFFFFF) == 31); + for (i = 0; i < 32; i++) EXPECT_EQ(Support::popcnt((uint32_t(1) << i)), 1u); + for (i = 0; i < 64; i++) EXPECT_EQ(Support::popcnt((uint64_t(1) << i)), 1u); + EXPECT_EQ(Support::popcnt(0x000000F0), 4u); + EXPECT_EQ(Support::popcnt(0x10101010), 4u); + EXPECT_EQ(Support::popcnt(0xFF000000), 8u); + EXPECT_EQ(Support::popcnt(0xFFFFFFF7), 31u); + EXPECT_EQ(Support::popcnt(0x7FFFFFFF), 31u); INFO("Support::isPowerOf2()"); for (i = 0; i < 64; i++) { - EXPECT(Support::isPowerOf2(uint64_t(1) << i) == true); - EXPECT(Support::isPowerOf2((uint64_t(1) << i) ^ 0x001101) == false); + EXPECT_TRUE(Support::isPowerOf2(uint64_t(1) << i)); + EXPECT_FALSE(Support::isPowerOf2((uint64_t(1) << i) ^ 0x001101)); } } static void testIntUtils() noexcept { INFO("Support::byteswap()"); - EXPECT(Support::byteswap16(int32_t(0x0102)) == int32_t(0x0201)); - EXPECT(Support::byteswap32(int32_t(0x01020304)) == int32_t(0x04030201)); - EXPECT(Support::byteswap32(uint32_t(0x01020304)) == uint32_t(0x04030201)); - EXPECT(Support::byteswap64(uint64_t(0x0102030405060708)) == uint64_t(0x0807060504030201)); + EXPECT_EQ(Support::byteswap16(0x0102), 0x0201u); + EXPECT_EQ(Support::byteswap32(0x01020304), 0x04030201u); + EXPECT_EQ(Support::byteswap32(0x01020304), 0x04030201u); + EXPECT_EQ(Support::byteswap64(uint64_t(0x0102030405060708)), uint64_t(0x0807060504030201)); INFO("Support::bytepack()"); union BytePackData { @@ -131,60 +133,60 @@ static void testIntUtils() noexcept { } bpdata; bpdata.u32 = Support::bytepack32_4x8(0x00, 0x11, 0x22, 0x33); - EXPECT(bpdata.bytes[0] == 0x00); - EXPECT(bpdata.bytes[1] == 0x11); - EXPECT(bpdata.bytes[2] == 0x22); - EXPECT(bpdata.bytes[3] == 0x33); + EXPECT_EQ(bpdata.bytes[0], 0x00); + EXPECT_EQ(bpdata.bytes[1], 0x11); + EXPECT_EQ(bpdata.bytes[2], 0x22); + EXPECT_EQ(bpdata.bytes[3], 0x33); INFO("Support::isBetween()"); - EXPECT(Support::isBetween(10 , 10, 20) == true); - EXPECT(Support::isBetween(11 , 10, 20) == true); - EXPECT(Support::isBetween(20 , 10, 20) == true); - EXPECT(Support::isBetween(9 , 10, 20) == false); - EXPECT(Support::isBetween(21 , 10, 20) == false); - EXPECT(Support::isBetween(101, 10, 20) == false); + EXPECT_TRUE(Support::isBetween(10 , 10, 20)); + EXPECT_TRUE(Support::isBetween(11 , 10, 20)); + EXPECT_TRUE(Support::isBetween(20 , 10, 20)); + EXPECT_FALSE(Support::isBetween(9 , 10, 20)); + EXPECT_FALSE(Support::isBetween(21 , 10, 20)); + EXPECT_FALSE(Support::isBetween(101, 10, 20)); INFO("Support::isInt8()"); - EXPECT(Support::isInt8(-128) == true); - EXPECT(Support::isInt8( 127) == true); - EXPECT(Support::isInt8(-129) == false); - EXPECT(Support::isInt8( 128) == false); + EXPECT_TRUE(Support::isInt8(-128)); + EXPECT_TRUE(Support::isInt8( 127)); + EXPECT_FALSE(Support::isInt8(-129)); + EXPECT_FALSE(Support::isInt8( 128)); INFO("Support::isInt16()"); - EXPECT(Support::isInt16(-32768) == true); - EXPECT(Support::isInt16( 32767) == true); - EXPECT(Support::isInt16(-32769) == false); - EXPECT(Support::isInt16( 32768) == false); + EXPECT_TRUE(Support::isInt16(-32768)); + EXPECT_TRUE(Support::isInt16( 32767)); + EXPECT_FALSE(Support::isInt16(-32769)); + EXPECT_FALSE(Support::isInt16( 32768)); INFO("Support::isInt32()"); - EXPECT(Support::isInt32( 2147483647 ) == true); - EXPECT(Support::isInt32(-2147483647 - 1) == true); - EXPECT(Support::isInt32(uint64_t(2147483648u)) == false); - EXPECT(Support::isInt32(uint64_t(0xFFFFFFFFu)) == false); - EXPECT(Support::isInt32(uint64_t(0xFFFFFFFFu) + 1) == false); + EXPECT_TRUE(Support::isInt32( 2147483647 )); + EXPECT_TRUE(Support::isInt32(-2147483647 - 1)); + EXPECT_FALSE(Support::isInt32(uint64_t(2147483648u))); + EXPECT_FALSE(Support::isInt32(uint64_t(0xFFFFFFFFu))); + EXPECT_FALSE(Support::isInt32(uint64_t(0xFFFFFFFFu) + 1)); INFO("Support::isUInt8()"); - EXPECT(Support::isUInt8(0) == true); - EXPECT(Support::isUInt8(255) == true); - EXPECT(Support::isUInt8(256) == false); - EXPECT(Support::isUInt8(-1) == false); + EXPECT_TRUE(Support::isUInt8(0) ); + EXPECT_TRUE(Support::isUInt8(255)); + EXPECT_FALSE(Support::isUInt8(256)); + EXPECT_FALSE(Support::isUInt8(-1) ); INFO("Support::isUInt12()"); - EXPECT(Support::isUInt12(0) == true); - EXPECT(Support::isUInt12(4095) == true); - EXPECT(Support::isUInt12(4096) == false); - EXPECT(Support::isUInt12(-1) == false); + EXPECT_TRUE(Support::isUInt12(0) ); + EXPECT_TRUE(Support::isUInt12(4095)); + EXPECT_FALSE(Support::isUInt12(4096)); + EXPECT_FALSE(Support::isUInt12(-1) ); INFO("Support::isUInt16()"); - EXPECT(Support::isUInt16(0) == true); - EXPECT(Support::isUInt16(65535) == true); - EXPECT(Support::isUInt16(65536) == false); - EXPECT(Support::isUInt16(-1) == false); + EXPECT_TRUE(Support::isUInt16(0) ); + EXPECT_TRUE(Support::isUInt16(65535)); + EXPECT_FALSE(Support::isUInt16(65536)); + EXPECT_FALSE(Support::isUInt16(-1) ); INFO("Support::isUInt32()"); - EXPECT(Support::isUInt32(uint64_t(0xFFFFFFFF)) == true); - EXPECT(Support::isUInt32(uint64_t(0xFFFFFFFF) + 1) == false); - EXPECT(Support::isUInt32(-1) == false); + EXPECT_TRUE(Support::isUInt32(uint64_t(0xFFFFFFFF))); + EXPECT_FALSE(Support::isUInt32(uint64_t(0xFFFFFFFF) + 1)); + EXPECT_FALSE(Support::isUInt32(-1)); } static void testReadWrite() noexcept { @@ -194,17 +196,17 @@ static void testReadWrite() noexcept { Support::writeU16uBE(arr + 1, 0x0102u); Support::writeU16uBE(arr + 3, 0x0304u); - EXPECT(Support::readU32uBE(arr + 1) == 0x01020304u); - EXPECT(Support::readU32uLE(arr + 1) == 0x04030201u); - EXPECT(Support::readU32uBE(arr + 2) == 0x02030400u); - EXPECT(Support::readU32uLE(arr + 2) == 0x00040302u); + EXPECT_EQ(Support::readU32uBE(arr + 1), 0x01020304u); + EXPECT_EQ(Support::readU32uLE(arr + 1), 0x04030201u); + EXPECT_EQ(Support::readU32uBE(arr + 2), 0x02030400u); + EXPECT_EQ(Support::readU32uLE(arr + 2), 0x00040302u); Support::writeU32uLE(arr + 5, 0x05060708u); - EXPECT(Support::readU64uBE(arr + 1) == 0x0102030408070605u); - EXPECT(Support::readU64uLE(arr + 1) == 0x0506070804030201u); + EXPECT_EQ(Support::readU64uBE(arr + 1), 0x0102030408070605u); + EXPECT_EQ(Support::readU64uLE(arr + 1), 0x0506070804030201u); Support::writeU64uLE(arr + 7, 0x1122334455667788u); - EXPECT(Support::readU32uBE(arr + 8) == 0x77665544u); + EXPECT_EQ(Support::readU32uBE(arr + 8), 0x77665544u); } static void testBitVector() noexcept { @@ -212,132 +214,132 @@ static void testBitVector() noexcept { { uint32_t vec[3] = { 0 }; Support::bitVectorFill(vec, 1, 64); - EXPECT(vec[0] == 0xFFFFFFFEu); - EXPECT(vec[1] == 0xFFFFFFFFu); - EXPECT(vec[2] == 0x00000001u); + EXPECT_EQ(vec[0], 0xFFFFFFFEu); + EXPECT_EQ(vec[1], 0xFFFFFFFFu); + EXPECT_EQ(vec[2], 0x00000001u); Support::bitVectorClear(vec, 1, 1); - EXPECT(vec[0] == 0xFFFFFFFCu); - EXPECT(vec[1] == 0xFFFFFFFFu); - EXPECT(vec[2] == 0x00000001u); + EXPECT_EQ(vec[0], 0xFFFFFFFCu); + EXPECT_EQ(vec[1], 0xFFFFFFFFu); + EXPECT_EQ(vec[2], 0x00000001u); Support::bitVectorFill(vec, 0, 32); - EXPECT(vec[0] == 0xFFFFFFFFu); - EXPECT(vec[1] == 0xFFFFFFFFu); - EXPECT(vec[2] == 0x00000001u); + EXPECT_EQ(vec[0], 0xFFFFFFFFu); + EXPECT_EQ(vec[1], 0xFFFFFFFFu); + EXPECT_EQ(vec[2], 0x00000001u); Support::bitVectorClear(vec, 0, 32); - EXPECT(vec[0] == 0x00000000u); - EXPECT(vec[1] == 0xFFFFFFFFu); - EXPECT(vec[2] == 0x00000001u); + EXPECT_EQ(vec[0], 0x00000000u); + EXPECT_EQ(vec[1], 0xFFFFFFFFu); + EXPECT_EQ(vec[2], 0x00000001u); Support::bitVectorFill(vec, 1, 30); - EXPECT(vec[0] == 0x7FFFFFFEu); - EXPECT(vec[1] == 0xFFFFFFFFu); - EXPECT(vec[2] == 0x00000001u); + EXPECT_EQ(vec[0], 0x7FFFFFFEu); + EXPECT_EQ(vec[1], 0xFFFFFFFFu); + EXPECT_EQ(vec[2], 0x00000001u); Support::bitVectorClear(vec, 1, 95); - EXPECT(vec[0] == 0x00000000u); - EXPECT(vec[1] == 0x00000000u); - EXPECT(vec[2] == 0x00000000u); + EXPECT_EQ(vec[0], 0x00000000u); + EXPECT_EQ(vec[1], 0x00000000u); + EXPECT_EQ(vec[2], 0x00000000u); Support::bitVectorFill(vec, 32, 64); - EXPECT(vec[0] == 0x00000000u); - EXPECT(vec[1] == 0xFFFFFFFFu); - EXPECT(vec[2] == 0xFFFFFFFFu); + EXPECT_EQ(vec[0], 0x00000000u); + EXPECT_EQ(vec[1], 0xFFFFFFFFu); + EXPECT_EQ(vec[2], 0xFFFFFFFFu); Support::bitVectorSetBit(vec, 1, true); - EXPECT(vec[0] == 0x00000002u); - EXPECT(vec[1] == 0xFFFFFFFFu); - EXPECT(vec[2] == 0xFFFFFFFFu); + EXPECT_EQ(vec[0], 0x00000002u); + EXPECT_EQ(vec[1], 0xFFFFFFFFu); + EXPECT_EQ(vec[2], 0xFFFFFFFFu); Support::bitVectorSetBit(vec, 95, false); - EXPECT(vec[0] == 0x00000002u); - EXPECT(vec[1] == 0xFFFFFFFFu); - EXPECT(vec[2] == 0x7FFFFFFFu); + EXPECT_EQ(vec[0], 0x00000002u); + EXPECT_EQ(vec[1], 0xFFFFFFFFu); + EXPECT_EQ(vec[2], 0x7FFFFFFFu); Support::bitVectorClear(vec, 33, 32); - EXPECT(vec[0] == 0x00000002u); - EXPECT(vec[1] == 0x00000001u); - EXPECT(vec[2] == 0x7FFFFFFEu); + EXPECT_EQ(vec[0], 0x00000002u); + EXPECT_EQ(vec[1], 0x00000001u); + EXPECT_EQ(vec[2], 0x7FFFFFFEu); } INFO("Support::bitVectorIndexOf"); { uint32_t vec1[1] = { 0x80000000 }; - EXPECT(Support::bitVectorIndexOf(vec1, 0, true) == 31); - EXPECT(Support::bitVectorIndexOf(vec1, 1, true) == 31); - EXPECT(Support::bitVectorIndexOf(vec1, 31, true) == 31); + EXPECT_EQ(Support::bitVectorIndexOf(vec1, 0, true), 31u); + EXPECT_EQ(Support::bitVectorIndexOf(vec1, 1, true), 31u); + EXPECT_EQ(Support::bitVectorIndexOf(vec1, 31, true), 31u); uint32_t vec2[2] = { 0x00000000, 0x80000000 }; - EXPECT(Support::bitVectorIndexOf(vec2, 0, true) == 63); - EXPECT(Support::bitVectorIndexOf(vec2, 1, true) == 63); - EXPECT(Support::bitVectorIndexOf(vec2, 31, true) == 63); - EXPECT(Support::bitVectorIndexOf(vec2, 32, true) == 63); - EXPECT(Support::bitVectorIndexOf(vec2, 33, true) == 63); - EXPECT(Support::bitVectorIndexOf(vec2, 63, true) == 63); + EXPECT_EQ(Support::bitVectorIndexOf(vec2, 0, true), 63u); + EXPECT_EQ(Support::bitVectorIndexOf(vec2, 1, true), 63u); + EXPECT_EQ(Support::bitVectorIndexOf(vec2, 31, true), 63u); + EXPECT_EQ(Support::bitVectorIndexOf(vec2, 32, true), 63u); + EXPECT_EQ(Support::bitVectorIndexOf(vec2, 33, true), 63u); + EXPECT_EQ(Support::bitVectorIndexOf(vec2, 63, true), 63u); uint32_t vec3[3] = { 0x00000001, 0x00000000, 0x80000000 }; - EXPECT(Support::bitVectorIndexOf(vec3, 0, true) == 0); - EXPECT(Support::bitVectorIndexOf(vec3, 1, true) == 95); - EXPECT(Support::bitVectorIndexOf(vec3, 2, true) == 95); - EXPECT(Support::bitVectorIndexOf(vec3, 31, true) == 95); - EXPECT(Support::bitVectorIndexOf(vec3, 32, true) == 95); - EXPECT(Support::bitVectorIndexOf(vec3, 63, true) == 95); - EXPECT(Support::bitVectorIndexOf(vec3, 64, true) == 95); - EXPECT(Support::bitVectorIndexOf(vec3, 95, true) == 95); + EXPECT_EQ(Support::bitVectorIndexOf(vec3, 0, true), 0u); + EXPECT_EQ(Support::bitVectorIndexOf(vec3, 1, true), 95u); + EXPECT_EQ(Support::bitVectorIndexOf(vec3, 2, true), 95u); + EXPECT_EQ(Support::bitVectorIndexOf(vec3, 31, true), 95u); + EXPECT_EQ(Support::bitVectorIndexOf(vec3, 32, true), 95u); + EXPECT_EQ(Support::bitVectorIndexOf(vec3, 63, true), 95u); + EXPECT_EQ(Support::bitVectorIndexOf(vec3, 64, true), 95u); + EXPECT_EQ(Support::bitVectorIndexOf(vec3, 95, true), 95u); uint32_t vec4[3] = { ~vec3[0], ~vec3[1], ~vec3[2] }; - EXPECT(Support::bitVectorIndexOf(vec4, 0, false) == 0); - EXPECT(Support::bitVectorIndexOf(vec4, 1, false) == 95); - EXPECT(Support::bitVectorIndexOf(vec4, 2, false) == 95); - EXPECT(Support::bitVectorIndexOf(vec4, 31, false) == 95); - EXPECT(Support::bitVectorIndexOf(vec4, 32, false) == 95); - EXPECT(Support::bitVectorIndexOf(vec4, 63, false) == 95); - EXPECT(Support::bitVectorIndexOf(vec4, 64, false) == 95); - EXPECT(Support::bitVectorIndexOf(vec4, 95, false) == 95); + EXPECT_EQ(Support::bitVectorIndexOf(vec4, 0, false), 0u); + EXPECT_EQ(Support::bitVectorIndexOf(vec4, 1, false), 95u); + EXPECT_EQ(Support::bitVectorIndexOf(vec4, 2, false), 95u); + EXPECT_EQ(Support::bitVectorIndexOf(vec4, 31, false), 95u); + EXPECT_EQ(Support::bitVectorIndexOf(vec4, 32, false), 95u); + EXPECT_EQ(Support::bitVectorIndexOf(vec4, 63, false), 95u); + EXPECT_EQ(Support::bitVectorIndexOf(vec4, 64, false), 95u); + EXPECT_EQ(Support::bitVectorIndexOf(vec4, 95, false), 95u); } INFO("Support::BitWordIterator"); { Support::BitWordIterator it(0x80000F01u); - EXPECT(it.hasNext()); - EXPECT(it.next() == 0); - EXPECT(it.hasNext()); - EXPECT(it.next() == 8); - EXPECT(it.hasNext()); - EXPECT(it.next() == 9); - EXPECT(it.hasNext()); - EXPECT(it.next() == 10); - EXPECT(it.hasNext()); - EXPECT(it.next() == 11); - EXPECT(it.hasNext()); - EXPECT(it.next() == 31); - EXPECT(!it.hasNext()); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 0u); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 8u); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 9u); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 10u); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 11u); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 31u); + EXPECT_FALSE(it.hasNext()); // No bits set. it.init(0x00000000u); - ASMJIT_ASSERT(!it.hasNext()); + EXPECT_FALSE(it.hasNext()); // Only first bit set. it.init(0x00000001u); - EXPECT(it.hasNext()); - EXPECT(it.next() == 0); - ASMJIT_ASSERT(!it.hasNext()); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 0u); + EXPECT_FALSE(it.hasNext()); // Only last bit set (special case). it.init(0x80000000u); - ASMJIT_ASSERT(it.hasNext()); - ASMJIT_ASSERT(it.next() == 31); - ASMJIT_ASSERT(!it.hasNext()); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 31u); + EXPECT_FALSE(it.hasNext()); } INFO("Support::BitWordIterator"); { Support::BitWordIterator it(uint64_t(1) << 63); - ASMJIT_ASSERT(it.hasNext()); - ASMJIT_ASSERT(it.next() == 63); - ASMJIT_ASSERT(!it.hasNext()); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 63u); + EXPECT_FALSE(it.hasNext()); } INFO("Support::BitVectorIterator"); @@ -346,63 +348,63 @@ static void testBitVector() noexcept { static const uint32_t bitsNone[] = { 0xFFFFFFFFu }; Support::BitVectorIterator it(bitsNone, 0); - EXPECT(!it.hasNext()); + EXPECT_FALSE(it.hasNext()); it.init(bitsNone, 0, 1); - EXPECT(!it.hasNext()); + EXPECT_FALSE(it.hasNext()); it.init(bitsNone, 0, 128); - EXPECT(!it.hasNext()); + EXPECT_FALSE(it.hasNext()); static const uint32_t bits1[] = { 0x80000008u, 0x80000001u, 0x00000000u, 0x80000000u, 0x00000000u, 0x00000000u, 0x00003000u }; it.init(bits1, ASMJIT_ARRAY_SIZE(bits1)); - EXPECT(it.hasNext()); - EXPECT(it.next() == 3); - EXPECT(it.hasNext()); - EXPECT(it.next() == 31); - EXPECT(it.hasNext()); - EXPECT(it.next() == 32); - EXPECT(it.hasNext()); - EXPECT(it.next() == 63); - EXPECT(it.hasNext()); - EXPECT(it.next() == 127); - EXPECT(it.hasNext()); - EXPECT(it.next() == 204); - EXPECT(it.hasNext()); - EXPECT(it.next() == 205); - EXPECT(!it.hasNext()); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 3u); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 31u); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 32u); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 63u); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 127u); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 204u); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 205u); + EXPECT_FALSE(it.hasNext()); it.init(bits1, ASMJIT_ARRAY_SIZE(bits1), 4); - EXPECT(it.hasNext()); - EXPECT(it.next() == 31); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 31u); it.init(bits1, ASMJIT_ARRAY_SIZE(bits1), 64); - EXPECT(it.hasNext()); - EXPECT(it.next() == 127); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 127u); it.init(bits1, ASMJIT_ARRAY_SIZE(bits1), 127); - EXPECT(it.hasNext()); - EXPECT(it.next() == 127); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 127u); static const uint32_t bits2[] = { 0x80000000u, 0x80000000u, 0x00000000u, 0x80000000u }; it.init(bits2, ASMJIT_ARRAY_SIZE(bits2)); - EXPECT(it.hasNext()); - EXPECT(it.next() == 31); - EXPECT(it.hasNext()); - EXPECT(it.next() == 63); - EXPECT(it.hasNext()); - EXPECT(it.next() == 127); - EXPECT(!it.hasNext()); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 31u); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 63u); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 127u); + EXPECT_FALSE(it.hasNext()); static const uint32_t bits3[] = { 0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u }; it.init(bits3, ASMJIT_ARRAY_SIZE(bits3)); - EXPECT(!it.hasNext()); + EXPECT_FALSE(it.hasNext()); static const uint32_t bits4[] = { 0x00000000u, 0x00000000u, 0x00000000u, 0x80000000u }; it.init(bits4, ASMJIT_ARRAY_SIZE(bits4)); - EXPECT(it.hasNext()); - EXPECT(it.next() == 127); - EXPECT(!it.hasNext()); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 127u); + EXPECT_FALSE(it.hasNext()); } INFO("Support::BitVectorIterator"); @@ -410,20 +412,20 @@ static void testBitVector() noexcept { static const uint64_t bits1[] = { 0x80000000u, 0x80000000u, 0x00000000u, 0x80000000u }; Support::BitVectorIterator it(bits1, ASMJIT_ARRAY_SIZE(bits1)); - EXPECT(it.hasNext()); - EXPECT(it.next() == 31); - EXPECT(it.hasNext()); - EXPECT(it.next() == 95); - EXPECT(it.hasNext()); - EXPECT(it.next() == 223); - EXPECT(!it.hasNext()); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 31u); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 95u); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 223u); + EXPECT_FALSE(it.hasNext()); static const uint64_t bits2[] = { 0x8000000000000000u, 0, 0, 0 }; it.init(bits2, ASMJIT_ARRAY_SIZE(bits2)); - EXPECT(it.hasNext()); - EXPECT(it.next() == 63); - EXPECT(!it.hasNext()); + EXPECT_TRUE(it.hasNext()); + EXPECT_EQ(it.next(), 63u); + EXPECT_FALSE(it.hasNext()); } } diff --git a/src/asmjit/core/zonehash.cpp b/src/asmjit/core/zonehash.cpp index 3778fbe..578b083 100644 --- a/src/asmjit/core/zonehash.cpp +++ b/src/asmjit/core/zonehash.cpp @@ -288,8 +288,8 @@ UNIT(zone_hash) { for (key = 0; key < count; key++) { node = hashTable.get(MyKeyMatcher(key)); - EXPECT(node != nullptr); - EXPECT(node->_key == key); + EXPECT_NOT_NULL(node); + EXPECT_EQ(node->_key, key); } { @@ -298,11 +298,11 @@ UNIT(zone_hash) { hashTable.remove(&allocator, node); node = hashTable.get(MyKeyMatcher(count)); - EXPECT(node == nullptr); + EXPECT_NULL(node); } } while (count); - EXPECT(hashTable.empty()); + EXPECT_TRUE(hashTable.empty()); } #endif diff --git a/src/asmjit/core/zonelist.cpp b/src/asmjit/core/zonelist.cpp index d4b311d..ff2c2cf 100644 --- a/src/asmjit/core/zonelist.cpp +++ b/src/asmjit/core/zonelist.cpp @@ -27,136 +27,136 @@ UNIT(zone_list) { INFO("Append / Unlink"); // [] - EXPECT(list.empty() == true); + EXPECT_TRUE(list.empty()); // [A] list.append(a); - EXPECT(list.empty() == false); - EXPECT(list.first() == a); - EXPECT(list.last() == a); - EXPECT(a->prev() == nullptr); - EXPECT(a->next() == nullptr); + EXPECT_FALSE(list.empty()); + EXPECT_EQ(list.first(), a); + EXPECT_EQ(list.last(), a); + EXPECT_NULL(a->prev()); + EXPECT_NULL(a->next()); // [A, B] list.append(b); - EXPECT(list.first() == a); - EXPECT(list.last() == b); - EXPECT(a->prev() == nullptr); - EXPECT(a->next() == b); - EXPECT(b->prev() == a); - EXPECT(b->next() == nullptr); + EXPECT_EQ(list.first(), a); + EXPECT_EQ(list.last(), b); + EXPECT_NULL(a->prev()); + EXPECT_EQ(a->next(), b); + EXPECT_EQ(b->prev(), a); + EXPECT_NULL(b->next()); // [A, B, C] list.append(c); - EXPECT(list.first() == a); - EXPECT(list.last() == c); - EXPECT(a->prev() == nullptr); - EXPECT(a->next() == b); - EXPECT(b->prev() == a); - EXPECT(b->next() == c); - EXPECT(c->prev() == b); - EXPECT(c->next() == nullptr); + EXPECT_EQ(list.first(), a); + EXPECT_EQ(list.last(), c); + EXPECT_NULL(a->prev()); + EXPECT_EQ(a->next(), b); + EXPECT_EQ(b->prev(), a); + EXPECT_EQ(b->next(), c); + EXPECT_EQ(c->prev(), b); + EXPECT_NULL(c->next()); // [B, C] list.unlink(a); - EXPECT(list.first() == b); - EXPECT(list.last() == c); - EXPECT(a->prev() == nullptr); - EXPECT(a->next() == nullptr); - EXPECT(b->prev() == nullptr); - EXPECT(b->next() == c); - EXPECT(c->prev() == b); - EXPECT(c->next() == nullptr); + EXPECT_EQ(list.first(), b); + EXPECT_EQ(list.last(), c); + EXPECT_NULL(a->prev()); + EXPECT_NULL(a->next()); + EXPECT_NULL(b->prev()); + EXPECT_EQ(b->next(), c); + EXPECT_EQ(c->prev(), b); + EXPECT_NULL(c->next()); // [B] list.unlink(c); - EXPECT(list.first() == b); - EXPECT(list.last() == b); - EXPECT(b->prev() == nullptr); - EXPECT(b->next() == nullptr); - EXPECT(c->prev() == nullptr); - EXPECT(c->next() == nullptr); + EXPECT_EQ(list.first(), b); + EXPECT_EQ(list.last(), b); + EXPECT_NULL(b->prev()); + EXPECT_NULL(b->next()); + EXPECT_NULL(c->prev()); + EXPECT_NULL(c->next()); // [] list.unlink(b); - EXPECT(list.empty() == true); - EXPECT(list.first() == nullptr); - EXPECT(list.last() == nullptr); - EXPECT(b->prev() == nullptr); - EXPECT(b->next() == nullptr); + EXPECT_TRUE(list.empty()); + EXPECT_NULL(list.first()); + EXPECT_NULL(list.last()); + EXPECT_NULL(b->prev()); + EXPECT_NULL(b->next()); INFO("Prepend / Unlink"); // [A] list.prepend(a); - EXPECT(list.empty() == false); - EXPECT(list.first() == a); - EXPECT(list.last() == a); - EXPECT(a->prev() == nullptr); - EXPECT(a->next() == nullptr); + EXPECT_FALSE(list.empty()); + EXPECT_EQ(list.first(), a); + EXPECT_EQ(list.last(), a); + EXPECT_NULL(a->prev()); + EXPECT_NULL(a->next()); // [B, A] list.prepend(b); - EXPECT(list.first() == b); - EXPECT(list.last() == a); - EXPECT(b->prev() == nullptr); - EXPECT(b->next() == a); - EXPECT(a->prev() == b); - EXPECT(a->next() == nullptr); + EXPECT_EQ(list.first(), b); + EXPECT_EQ(list.last(), a); + EXPECT_NULL(b->prev()); + EXPECT_EQ(b->next(), a); + EXPECT_EQ(a->prev(), b); + EXPECT_NULL(a->next()); INFO("InsertAfter / InsertBefore"); // [B, A, C] list.insertAfter(a, c); - EXPECT(list.first() == b); - EXPECT(list.last() == c); - EXPECT(b->prev() == nullptr); - EXPECT(b->next() == a); - EXPECT(a->prev() == b); - EXPECT(a->next() == c); - EXPECT(c->prev() == a); - EXPECT(c->next() == nullptr); + EXPECT_EQ(list.first(), b); + EXPECT_EQ(list.last(), c); + EXPECT_NULL(b->prev()); + EXPECT_EQ(b->next(), a); + EXPECT_EQ(a->prev(), b); + EXPECT_EQ(a->next(), c); + EXPECT_EQ(c->prev(), a); + EXPECT_NULL(c->next()); // [B, D, A, C] list.insertBefore(a, d); - EXPECT(list.first() == b); - EXPECT(list.last() == c); - EXPECT(b->prev() == nullptr); - EXPECT(b->next() == d); - EXPECT(d->prev() == b); - EXPECT(d->next() == a); - EXPECT(a->prev() == d); - EXPECT(a->next() == c); - EXPECT(c->prev() == a); - EXPECT(c->next() == nullptr); + EXPECT_EQ(list.first(), b); + EXPECT_EQ(list.last(), c); + EXPECT_NULL(b->prev()); + EXPECT_EQ(b->next(), d); + EXPECT_EQ(d->prev(), b); + EXPECT_EQ(d->next(), a); + EXPECT_EQ(a->prev(), d); + EXPECT_EQ(a->next(), c); + EXPECT_EQ(c->prev(), a); + EXPECT_NULL(c->next()); INFO("PopFirst / Pop"); // [D, A, C] - EXPECT(list.popFirst() == b); - EXPECT(b->prev() == nullptr); - EXPECT(b->next() == nullptr); + EXPECT_EQ(list.popFirst(), b); + EXPECT_NULL(b->prev()); + EXPECT_NULL(b->next()); - EXPECT(list.first() == d); - EXPECT(list.last() == c); - EXPECT(d->prev() == nullptr); - EXPECT(d->next() == a); - EXPECT(a->prev() == d); - EXPECT(a->next() == c); - EXPECT(c->prev() == a); - EXPECT(c->next() == nullptr); + EXPECT_EQ(list.first(), d); + EXPECT_EQ(list.last(), c); + EXPECT_NULL(d->prev()); + EXPECT_EQ(d->next(), a); + EXPECT_EQ(a->prev(), d); + EXPECT_EQ(a->next(), c); + EXPECT_EQ(c->prev(), a); + EXPECT_NULL(c->next()); // [D, A] - EXPECT(list.pop() == c); - EXPECT(c->prev() == nullptr); - EXPECT(c->next() == nullptr); + EXPECT_EQ(list.pop(), c); + EXPECT_NULL(c->prev()); + EXPECT_NULL(c->next()); - EXPECT(list.first() == d); - EXPECT(list.last() == a); - EXPECT(d->prev() == nullptr); - EXPECT(d->next() == a); - EXPECT(a->prev() == d); - EXPECT(a->next() == nullptr); + EXPECT_EQ(list.first(), d); + EXPECT_EQ(list.last(), a); + EXPECT_NULL(d->prev()); + EXPECT_EQ(d->next(), a); + EXPECT_EQ(a->prev(), d); + EXPECT_NULL(a->next()); } #endif diff --git a/src/asmjit/core/zonestack.cpp b/src/asmjit/core/zonestack.cpp index 77e6f20..66f706d 100644 --- a/src/asmjit/core/zonestack.cpp +++ b/src/asmjit/core/zonestack.cpp @@ -100,18 +100,24 @@ static void test_zone_stack(ZoneAllocator* allocator, const char* typeName) { INFO("Testing ZoneStack<%s>", typeName); INFO(" (%d items per one Block)", ZoneStack::kNumBlockItems); - EXPECT(stack.init(allocator) == kErrorOk); - EXPECT(stack.empty(), "Stack must be empty after `init()`"); + EXPECT_EQ(stack.init(allocator), kErrorOk); + EXPECT_TRUE(stack.empty()); - 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_EQ(stack.append(42), kErrorOk); + EXPECT_FALSE(stack.empty()) + .message("Stack must not be empty after an item has been appended"); + EXPECT_EQ(stack.pop(), 42) + .message("Stack.pop() must return the item that has been appended last"); + EXPECT_TRUE(stack.empty()) + .message("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"); + EXPECT_EQ(stack.prepend(43), kErrorOk); + EXPECT_FALSE(stack.empty()) + .message("Stack must not be empty after an item has been prepended"); + EXPECT_EQ(stack.popFirst(), 43) + .message("Stack.popFirst() must return the item that has been prepended last"); + EXPECT_TRUE(stack.empty()) + .message("Stack must be empty after the last item has been removed"); int i; int iMin =-100000; @@ -121,27 +127,31 @@ static void test_zone_stack(ZoneAllocator* allocator, const char* typeName) { 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); + EXPECT_EQ(i, item) + .message("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); + EXPECT_EQ(i + 1, item) + .message("Item '%d' didn't match the item '%lld' popped", i + 1, (long long)item); stack.prepend(item); } } - EXPECT(stack.empty()); + EXPECT_TRUE(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); + EXPECT_EQ(i, item) + .message("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); + EXPECT_EQ(i - 1, item) + .message("Item '%d' didn't match the item '%lld' popped", i - 1, (long long)item); stack.append(item); } } - EXPECT(stack.empty()); + EXPECT_TRUE(stack.empty()); INFO("Validating append()/prepend() & popFirst()"); for (i = 1; i <= iMax; i++) stack.append(T(i)); @@ -149,9 +159,9 @@ static void test_zone_stack(ZoneAllocator* allocator, const char* typeName) { 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_EQ(i, item); } - EXPECT(stack.empty()); + EXPECT_TRUE(stack.empty()); INFO("Validating append()/prepend() & pop()"); for (i = 0; i >= iMin; i--) stack.prepend(T(i)); @@ -159,9 +169,9 @@ static void test_zone_stack(ZoneAllocator* allocator, const char* typeName) { 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_EQ(i, item); } - EXPECT(stack.empty()); + EXPECT_TRUE(stack.empty()); } UNIT(zone_stack) { diff --git a/src/asmjit/core/zonetree.cpp b/src/asmjit/core/zonetree.cpp index 8c42af8..e8a0e11 100644 --- a/src/asmjit/core/zonetree.cpp +++ b/src/asmjit/core/zonetree.cpp @@ -19,7 +19,7 @@ struct ZoneRBUnit { typedef ZoneTree Tree; static void verifyTree(Tree& tree) noexcept { - EXPECT(checkHeight(static_cast(tree._root)) > 0); + EXPECT_GT(checkHeight(static_cast(tree._root)), 0); } // Check whether the Red-Black tree is valid. @@ -30,17 +30,16 @@ struct ZoneRBUnit { NodeT* rn = node->right(); // Invalid tree. - EXPECT(ln == nullptr || *ln < *node); - EXPECT(rn == nullptr || *rn > *node); + EXPECT_TRUE(ln == nullptr || *ln < *node); + EXPECT_TRUE(rn == nullptr || *rn > *node); // Red violation. - EXPECT(!node->isRed() || - (!ZoneTreeNode::_isValidRed(ln) && !ZoneTreeNode::_isValidRed(rn))); + EXPECT_TRUE(!node->isRed() || (!ZoneTreeNode::_isValidRed(ln) && !ZoneTreeNode::_isValidRed(rn))); // Black violation. int lh = checkHeight(ln); int rh = checkHeight(rn); - EXPECT(!lh || !rh || lh == rh); + EXPECT_TRUE(!lh || !rh || lh == rh); // Only count black links. return (lh && rh) ? lh + !node->isRed() : 0; @@ -83,8 +82,8 @@ UNIT(zone_rbtree) { for (key = 0; key < count; key++) { node = rbTree.get(key); - EXPECT(node != nullptr); - EXPECT(node->_key == key); + EXPECT_NOT_NULL(node); + EXPECT_EQ(node->_key, key); } node = rbTree.get(--count); @@ -92,7 +91,7 @@ UNIT(zone_rbtree) { ZoneRBUnit::verifyTree(rbTree); } while (count); - EXPECT(rbTree.empty()); + EXPECT_TRUE(rbTree.empty()); } #endif diff --git a/src/asmjit/core/zonevector.cpp b/src/asmjit/core/zonevector.cpp index dfec5d5..4e5067e 100644 --- a/src/asmjit/core/zonevector.cpp +++ b/src/asmjit/core/zonevector.cpp @@ -272,26 +272,26 @@ static void test_zone_vector(ZoneAllocator* allocator, const char* typeName) { ZoneVector vec; INFO("ZoneVector<%s> basic tests", typeName); - EXPECT(vec.append(allocator, 0) == kErrorOk); - EXPECT(vec.empty() == false); - EXPECT(vec.size() == 1); - EXPECT(vec.capacity() >= 1); - EXPECT(vec.indexOf(0) == 0); - EXPECT(vec.indexOf(-11) == Globals::kNotFound); + EXPECT_EQ(vec.append(allocator, 0), kErrorOk); + EXPECT_FALSE(vec.empty()); + EXPECT_EQ(vec.size(), 1u); + EXPECT_GE(vec.capacity(), 1u); + EXPECT_EQ(vec.indexOf(0), 0u); + EXPECT_EQ(vec.indexOf(-11), Globals::kNotFound); vec.clear(); - EXPECT(vec.empty()); - EXPECT(vec.size() == 0); - EXPECT(vec.indexOf(0) == Globals::kNotFound); + EXPECT_TRUE(vec.empty()); + EXPECT_EQ(vec.size(), 0u); + EXPECT_EQ(vec.indexOf(0), Globals::kNotFound); for (i = 0; i < kMax; i++) { - EXPECT(vec.append(allocator, T(i)) == kErrorOk); + EXPECT_EQ(vec.append(allocator, T(i)), kErrorOk); } - EXPECT(vec.empty() == false); - EXPECT(vec.size() == uint32_t(kMax)); - EXPECT(vec.indexOf(T(kMax - 1)) == uint32_t(kMax - 1)); + EXPECT_FALSE(vec.empty()); + EXPECT_EQ(vec.size(), uint32_t(kMax)); + EXPECT_EQ(vec.indexOf(T(kMax - 1)), uint32_t(kMax - 1)); - EXPECT(vec.rbegin()[0] == kMax - 1); + EXPECT_EQ(vec.rbegin()[0], kMax - 1); vec.release(allocator); } @@ -303,31 +303,31 @@ static void test_zone_bitvector(ZoneAllocator* allocator) { uint32_t kMaxCount = 100; ZoneBitVector vec; - EXPECT(vec.empty()); - EXPECT(vec.size() == 0); + EXPECT_TRUE(vec.empty()); + EXPECT_EQ(vec.size(), 0u); INFO("ZoneBitVector::resize()"); for (count = 1; count < kMaxCount; count++) { vec.clear(); - EXPECT(vec.resize(allocator, count, false) == kErrorOk); - EXPECT(vec.size() == count); + EXPECT_EQ(vec.resize(allocator, count, false), kErrorOk); + EXPECT_EQ(vec.size(), count); for (i = 0; i < count; i++) - EXPECT(vec.bitAt(i) == false); + EXPECT_FALSE(vec.bitAt(i)); vec.clear(); - EXPECT(vec.resize(allocator, count, true) == kErrorOk); - EXPECT(vec.size() == count); + EXPECT_EQ(vec.resize(allocator, count, true), kErrorOk); + EXPECT_EQ(vec.size(), count); for (i = 0; i < count; i++) - EXPECT(vec.bitAt(i) == true); + EXPECT_TRUE(vec.bitAt(i)); } INFO("ZoneBitVector::fillBits() / clearBits()"); for (count = 1; count < kMaxCount; count += 2) { vec.clear(); - EXPECT(vec.resize(allocator, count) == kErrorOk); - EXPECT(vec.size() == count); + EXPECT_EQ(vec.resize(allocator, count), kErrorOk); + EXPECT_EQ(vec.size(), count); for (i = 0; i < (count + 1) / 2; i++) { bool value = bool(i & 1); @@ -338,7 +338,7 @@ static void test_zone_bitvector(ZoneAllocator* allocator) { } for (i = 0; i < count; i++) { - EXPECT(vec.bitAt(i) == bool(i & 1)); + EXPECT_EQ(vec.bitAt(i), bool(i & 1)); } } } diff --git a/src/asmjit/x86/x86assembler.cpp b/src/asmjit/x86/x86assembler.cpp index ee2f746..6a4d512 100644 --- a/src/asmjit/x86/x86assembler.cpp +++ b/src/asmjit/x86/x86assembler.cpp @@ -4274,7 +4274,7 @@ EmitModSib_LabelRip_X86: } else { // Non-bound label or label bound to a different section. - relOffset = -4 - immSize; + relOffset = -4 - int32_t(immSize); relSize = 4; goto EmitRel; } diff --git a/src/asmjit/x86/x86instapi.cpp b/src/asmjit/x86/x86instapi.cpp index 50d3e83..c10ccb6 100644 --- a/src/asmjit/x86/x86instapi.cpp +++ b/src/asmjit/x86/x86instapi.cpp @@ -1667,15 +1667,14 @@ UNIT(x86_inst_api_text) { INFO("Matching all X86 instructions"); for (uint32_t a = 1; a < Inst::_kIdCount; a++) { StringTmp<128> aName; - EXPECT(InstInternal::instIdToString(Arch::kX86, a, aName) == kErrorOk, - "Failed to get the name of instruction #%u", a); + EXPECT_EQ(InstInternal::instIdToString(Arch::kX86, a, aName), kErrorOk) + .message("Failed to get the name of instruction #%u", a); uint32_t b = InstInternal::stringToInstId(Arch::kX86, aName.data(), aName.size()); StringTmp<128> bName; InstInternal::instIdToString(Arch::kX86, b, bName); - - EXPECT(a == b, - "Instructions do not match \"%s\" (#%u) != \"%s\" (#%u)", aName.data(), a, bName.data(), b); + EXPECT_EQ(a, b) + .message("Instructions do not match \"%s\" (#%u) != \"%s\" (#%u)", aName.data(), a, bName.data(), b); } } @@ -1693,10 +1692,10 @@ UNIT(x86_inst_api_rm_feature) { InstRWInfo rwi; queryRWInfoSimple(&rwi, Arch::kX64, Inst::kIdPextrw, InstOptions::kNone, eax, mm1, imm(1)); - EXPECT(rwi.rmFeature() == 0); + EXPECT_EQ(rwi.rmFeature(), 0u); queryRWInfoSimple(&rwi, Arch::kX64, Inst::kIdPextrw, InstOptions::kNone, eax, xmm1, imm(1)); - EXPECT(rwi.rmFeature() == CpuFeatures::X86::kSSE4_1); + EXPECT_EQ(rwi.rmFeature(), CpuFeatures::X86::kSSE4_1); } INFO("Verifying whether RM/feature is reported correctly for AVX512 shift instructions"); @@ -1704,40 +1703,40 @@ UNIT(x86_inst_api_rm_feature) { InstRWInfo rwi; queryRWInfoSimple(&rwi, Arch::kX64, Inst::kIdVpslld, InstOptions::kNone, xmm1, xmm2, imm(8)); - EXPECT(rwi.rmFeature() == CpuFeatures::X86::kAVX512_F); + EXPECT_EQ(rwi.rmFeature(), CpuFeatures::X86::kAVX512_F); queryRWInfoSimple(&rwi, Arch::kX64, Inst::kIdVpsllq, InstOptions::kNone, ymm1, ymm2, imm(8)); - EXPECT(rwi.rmFeature() == CpuFeatures::X86::kAVX512_F); + EXPECT_EQ(rwi.rmFeature(), CpuFeatures::X86::kAVX512_F); queryRWInfoSimple(&rwi, Arch::kX64, Inst::kIdVpsrad, InstOptions::kNone, xmm1, xmm2, imm(8)); - EXPECT(rwi.rmFeature() == CpuFeatures::X86::kAVX512_F); + EXPECT_EQ(rwi.rmFeature(), CpuFeatures::X86::kAVX512_F); queryRWInfoSimple(&rwi, Arch::kX64, Inst::kIdVpsrld, InstOptions::kNone, ymm1, ymm2, imm(8)); - EXPECT(rwi.rmFeature() == CpuFeatures::X86::kAVX512_F); + EXPECT_EQ(rwi.rmFeature(), CpuFeatures::X86::kAVX512_F); queryRWInfoSimple(&rwi, Arch::kX64, Inst::kIdVpsrlq, InstOptions::kNone, xmm1, xmm2, imm(8)); - EXPECT(rwi.rmFeature() == CpuFeatures::X86::kAVX512_F); + EXPECT_EQ(rwi.rmFeature(), CpuFeatures::X86::kAVX512_F); queryRWInfoSimple(&rwi, Arch::kX64, Inst::kIdVpslldq, InstOptions::kNone, xmm1, xmm2, imm(8)); - EXPECT(rwi.rmFeature() == CpuFeatures::X86::kAVX512_BW); + EXPECT_EQ(rwi.rmFeature(), CpuFeatures::X86::kAVX512_BW); queryRWInfoSimple(&rwi, Arch::kX64, Inst::kIdVpsllw, InstOptions::kNone, ymm1, ymm2, imm(8)); - EXPECT(rwi.rmFeature() == CpuFeatures::X86::kAVX512_BW); + EXPECT_EQ(rwi.rmFeature(), CpuFeatures::X86::kAVX512_BW); queryRWInfoSimple(&rwi, Arch::kX64, Inst::kIdVpsraw, InstOptions::kNone, xmm1, xmm2, imm(8)); - EXPECT(rwi.rmFeature() == CpuFeatures::X86::kAVX512_BW); + EXPECT_EQ(rwi.rmFeature(), CpuFeatures::X86::kAVX512_BW); queryRWInfoSimple(&rwi, Arch::kX64, Inst::kIdVpsrldq, InstOptions::kNone, ymm1, ymm2, imm(8)); - EXPECT(rwi.rmFeature() == CpuFeatures::X86::kAVX512_BW); + EXPECT_EQ(rwi.rmFeature(), CpuFeatures::X86::kAVX512_BW); queryRWInfoSimple(&rwi, Arch::kX64, Inst::kIdVpsrlw, InstOptions::kNone, xmm1, xmm2, imm(8)); - EXPECT(rwi.rmFeature() == CpuFeatures::X86::kAVX512_BW); + EXPECT_EQ(rwi.rmFeature(), CpuFeatures::X86::kAVX512_BW); queryRWInfoSimple(&rwi, Arch::kX64, Inst::kIdVpslld, InstOptions::kNone, xmm1, xmm2, xmm3); - EXPECT(rwi.rmFeature() == 0); + EXPECT_EQ(rwi.rmFeature(), 0u); queryRWInfoSimple(&rwi, Arch::kX64, Inst::kIdVpsllw, InstOptions::kNone, xmm1, xmm2, xmm3); - EXPECT(rwi.rmFeature() == 0); + EXPECT_EQ(rwi.rmFeature(), 0u); } } #endif diff --git a/src/asmjit/x86/x86instdb.cpp b/src/asmjit/x86/x86instdb.cpp index ef65910..5632dd5 100644 --- a/src/asmjit/x86/x86instdb.cpp +++ b/src/asmjit/x86/x86instdb.cpp @@ -5931,20 +5931,33 @@ UNIT(x86_inst_db) { INFO("Checking validity of Inst enums"); // Cross-validate prefixes. - EXPECT(uint32_t(InstOptions::kX86_Rex ) == 0x40000000u, "REX prefix must be at 0x40000000"); - EXPECT(uint32_t(InstOptions::kX86_Evex) == 0x00001000u, "EVEX prefix must be at 0x00001000"); + EXPECT_EQ(uint32_t(InstOptions::kX86_Rex ), 0x40000000u) + .message("REX prefix must be at 0x40000000"); + + EXPECT_EQ(uint32_t(InstOptions::kX86_Evex), 0x00001000u) + .message("EVEX prefix must be at 0x00001000"); // These could be combined together to form a valid REX prefix, they must match. - EXPECT(uint32_t(InstOptions::kX86_OpCodeB) == uint32_t(Opcode::kB), "Opcode::kB must match InstOptions::kX86_OpCodeB"); - EXPECT(uint32_t(InstOptions::kX86_OpCodeX) == uint32_t(Opcode::kX), "Opcode::kX must match InstOptions::kX86_OpCodeX"); - EXPECT(uint32_t(InstOptions::kX86_OpCodeR) == uint32_t(Opcode::kR), "Opcode::kR must match InstOptions::kX86_OpCodeR"); - EXPECT(uint32_t(InstOptions::kX86_OpCodeW) == uint32_t(Opcode::kW), "Opcode::kW must match InstOptions::kX86_OpCodeW"); + EXPECT_EQ(uint32_t(InstOptions::kX86_OpCodeB), uint32_t(Opcode::kB)) + .message("Opcode::kB must match InstOptions::kX86_OpCodeB"); + + EXPECT_EQ(uint32_t(InstOptions::kX86_OpCodeX), uint32_t(Opcode::kX)) + .message("Opcode::kX must match InstOptions::kX86_OpCodeX"); + + EXPECT_EQ(uint32_t(InstOptions::kX86_OpCodeR), uint32_t(Opcode::kR)) + .message("Opcode::kR must match InstOptions::kX86_OpCodeR"); + + EXPECT_EQ(uint32_t(InstOptions::kX86_OpCodeW), uint32_t(Opcode::kW)) + .message("Opcode::kW must match InstOptions::kX86_OpCodeW"); uint32_t rex_rb = (Opcode::kR >> Opcode::kREX_Shift) | (Opcode::kB >> Opcode::kREX_Shift) | 0x40; uint32_t rex_rw = (Opcode::kR >> Opcode::kREX_Shift) | (Opcode::kW >> Opcode::kREX_Shift) | 0x40; - EXPECT(rex_rb == 0x45, "Opcode::kR|B must form a valid REX prefix (0x45) if combined with 0x40"); - EXPECT(rex_rw == 0x4C, "Opcode::kR|W must form a valid REX prefix (0x4C) if combined with 0x40"); + EXPECT_EQ(rex_rb, 0x45u) + .message("Opcode::kR|B must form a valid REX prefix (0x45) if combined with 0x40"); + + EXPECT_EQ(rex_rw, 0x4Cu) + .message("Opcode::kR|W must form a valid REX prefix (0x4C) if combined with 0x40"); } #endif diff --git a/src/asmjit/x86/x86operand.cpp b/src/asmjit/x86/x86operand.cpp index a47fec2..5ab50de 100644 --- a/src/asmjit/x86/x86operand.cpp +++ b/src/asmjit/x86/x86operand.cpp @@ -19,210 +19,210 @@ UNIT(x86_operand) { Label L(1000); // Label with some ID. INFO("Checking basic properties of built-in X86 registers"); - EXPECT(gpb(Gp::kIdAx) == al); - EXPECT(gpb(Gp::kIdBx) == bl); - EXPECT(gpb(Gp::kIdCx) == cl); - EXPECT(gpb(Gp::kIdDx) == dl); + EXPECT_EQ(gpb(Gp::kIdAx), al); + EXPECT_EQ(gpb(Gp::kIdBx), bl); + EXPECT_EQ(gpb(Gp::kIdCx), cl); + EXPECT_EQ(gpb(Gp::kIdDx), dl); - EXPECT(gpb_lo(Gp::kIdAx) == al); - EXPECT(gpb_lo(Gp::kIdBx) == bl); - EXPECT(gpb_lo(Gp::kIdCx) == cl); - EXPECT(gpb_lo(Gp::kIdDx) == dl); + EXPECT_EQ(gpb_lo(Gp::kIdAx), al); + EXPECT_EQ(gpb_lo(Gp::kIdBx), bl); + EXPECT_EQ(gpb_lo(Gp::kIdCx), cl); + EXPECT_EQ(gpb_lo(Gp::kIdDx), dl); - EXPECT(gpb_hi(Gp::kIdAx) == ah); - EXPECT(gpb_hi(Gp::kIdBx) == bh); - EXPECT(gpb_hi(Gp::kIdCx) == ch); - EXPECT(gpb_hi(Gp::kIdDx) == dh); + EXPECT_EQ(gpb_hi(Gp::kIdAx), ah); + EXPECT_EQ(gpb_hi(Gp::kIdBx), bh); + EXPECT_EQ(gpb_hi(Gp::kIdCx), ch); + EXPECT_EQ(gpb_hi(Gp::kIdDx), dh); - EXPECT(gpw(Gp::kIdAx) == ax); - EXPECT(gpw(Gp::kIdBx) == bx); - EXPECT(gpw(Gp::kIdCx) == cx); - EXPECT(gpw(Gp::kIdDx) == dx); + EXPECT_EQ(gpw(Gp::kIdAx), ax); + EXPECT_EQ(gpw(Gp::kIdBx), bx); + EXPECT_EQ(gpw(Gp::kIdCx), cx); + EXPECT_EQ(gpw(Gp::kIdDx), dx); - EXPECT(gpd(Gp::kIdAx) == eax); - EXPECT(gpd(Gp::kIdBx) == ebx); - EXPECT(gpd(Gp::kIdCx) == ecx); - EXPECT(gpd(Gp::kIdDx) == edx); + EXPECT_EQ(gpd(Gp::kIdAx), eax); + EXPECT_EQ(gpd(Gp::kIdBx), ebx); + EXPECT_EQ(gpd(Gp::kIdCx), ecx); + EXPECT_EQ(gpd(Gp::kIdDx), edx); - EXPECT(gpq(Gp::kIdAx) == rax); - EXPECT(gpq(Gp::kIdBx) == rbx); - EXPECT(gpq(Gp::kIdCx) == rcx); - EXPECT(gpq(Gp::kIdDx) == rdx); + EXPECT_EQ(gpq(Gp::kIdAx), rax); + EXPECT_EQ(gpq(Gp::kIdBx), rbx); + EXPECT_EQ(gpq(Gp::kIdCx), rcx); + EXPECT_EQ(gpq(Gp::kIdDx), rdx); - EXPECT(gpb(Gp::kIdAx) != dl); - EXPECT(gpw(Gp::kIdBx) != cx); - EXPECT(gpd(Gp::kIdCx) != ebx); - EXPECT(gpq(Gp::kIdDx) != rax); + EXPECT_NE(gpb(Gp::kIdAx), dl); + EXPECT_NE(gpw(Gp::kIdBx), cx); + EXPECT_NE(gpd(Gp::kIdCx), ebx); + EXPECT_NE(gpq(Gp::kIdDx), rax); INFO("Checking if x86::reg(...) matches built-in IDs"); - EXPECT(gpb(5) == bpl); - EXPECT(gpw(5) == bp); - EXPECT(gpd(5) == ebp); - EXPECT(gpq(5) == rbp); - EXPECT(st(5) == st5); - EXPECT(mm(5) == mm5); - EXPECT(k(5) == k5); - EXPECT(cr(5) == cr5); - EXPECT(dr(5) == dr5); - EXPECT(xmm(5) == xmm5); - EXPECT(ymm(5) == ymm5); - EXPECT(zmm(5) == zmm5); + EXPECT_EQ(gpb(5), bpl); + EXPECT_EQ(gpw(5), bp); + EXPECT_EQ(gpd(5), ebp); + EXPECT_EQ(gpq(5), rbp); + EXPECT_EQ(st(5) , st5); + EXPECT_EQ(mm(5) , mm5); + EXPECT_EQ(k(5) , k5); + EXPECT_EQ(cr(5) , cr5); + EXPECT_EQ(dr(5) , dr5); + EXPECT_EQ(xmm(5), xmm5); + EXPECT_EQ(ymm(5), ymm5); + EXPECT_EQ(zmm(5), zmm5); INFO("Checking x86::Gp register properties"); - EXPECT(Gp().isReg() == true); - EXPECT(eax.isReg() == true); - EXPECT(eax.id() == 0); - EXPECT(eax.size() == 4); - EXPECT(eax.type() == RegType::kX86_Gpd); - EXPECT(eax.group() == RegGroup::kGp); + EXPECT_TRUE(Gp().isReg()); + EXPECT_TRUE(eax.isReg()); + EXPECT_EQ(eax.id(), 0u); + EXPECT_EQ(eax.size(), 4u); + EXPECT_EQ(eax.type(), RegType::kX86_Gpd); + EXPECT_EQ(eax.group(), RegGroup::kGp); INFO("Checking x86::Xmm register properties"); - EXPECT(Xmm().isReg() == true); - EXPECT(xmm4.isReg() == true); - EXPECT(xmm4.id() == 4); - EXPECT(xmm4.size() == 16); - EXPECT(xmm4.type() == RegType::kX86_Xmm); - EXPECT(xmm4.group() == RegGroup::kVec); - EXPECT(xmm4.isVec()); + EXPECT_TRUE(Xmm().isReg()); + EXPECT_TRUE(xmm4.isReg()); + EXPECT_EQ(xmm4.id(), 4u); + EXPECT_EQ(xmm4.size(), 16u); + EXPECT_EQ(xmm4.type(), RegType::kX86_Xmm); + EXPECT_EQ(xmm4.group(), RegGroup::kVec); + EXPECT_TRUE(xmm4.isVec()); INFO("Checking x86::Ymm register properties"); - EXPECT(Ymm().isReg() == true); - EXPECT(ymm5.isReg() == true); - EXPECT(ymm5.id() == 5); - EXPECT(ymm5.size() == 32); - EXPECT(ymm5.type() == RegType::kX86_Ymm); - EXPECT(ymm5.group() == RegGroup::kVec); - EXPECT(ymm5.isVec()); + EXPECT_TRUE(Ymm().isReg()); + EXPECT_TRUE(ymm5.isReg()); + EXPECT_EQ(ymm5.id(), 5u); + EXPECT_EQ(ymm5.size(), 32u); + EXPECT_EQ(ymm5.type(), RegType::kX86_Ymm); + EXPECT_EQ(ymm5.group(), RegGroup::kVec); + EXPECT_TRUE(ymm5.isVec()); INFO("Checking x86::Zmm register properties"); - EXPECT(Zmm().isReg() == true); - EXPECT(zmm6.isReg() == true); - EXPECT(zmm6.id() == 6); - EXPECT(zmm6.size() == 64); - EXPECT(zmm6.type() == RegType::kX86_Zmm); - EXPECT(zmm6.group() == RegGroup::kVec); - EXPECT(zmm6.isVec()); + EXPECT_TRUE(Zmm().isReg()); + EXPECT_TRUE(zmm6.isReg()); + EXPECT_EQ(zmm6.id(), 6u); + EXPECT_EQ(zmm6.size(), 64u); + EXPECT_EQ(zmm6.type(), RegType::kX86_Zmm); + EXPECT_EQ(zmm6.group(), RegGroup::kVec); + EXPECT_TRUE(zmm6.isVec()); INFO("Checking x86::Vec register properties"); - EXPECT(Vec().isReg() == true); + EXPECT_TRUE(Vec().isReg()); // Converts a VEC register to a type of the passed register, but keeps the ID. - EXPECT(xmm4.cloneAs(ymm10) == ymm4); - EXPECT(xmm4.cloneAs(zmm11) == zmm4); - EXPECT(ymm5.cloneAs(xmm12) == xmm5); - EXPECT(ymm5.cloneAs(zmm13) == zmm5); - EXPECT(zmm6.cloneAs(xmm14) == xmm6); - EXPECT(zmm6.cloneAs(ymm15) == ymm6); + EXPECT_EQ(xmm4.cloneAs(ymm10), ymm4); + EXPECT_EQ(xmm4.cloneAs(zmm11), zmm4); + EXPECT_EQ(ymm5.cloneAs(xmm12), xmm5); + EXPECT_EQ(ymm5.cloneAs(zmm13), zmm5); + EXPECT_EQ(zmm6.cloneAs(xmm14), xmm6); + EXPECT_EQ(zmm6.cloneAs(ymm15), ymm6); - EXPECT(xmm7.xmm() == xmm7); - EXPECT(xmm7.ymm() == ymm7); - EXPECT(xmm7.zmm() == zmm7); + EXPECT_EQ(xmm7.xmm(), xmm7); + EXPECT_EQ(xmm7.ymm(), ymm7); + EXPECT_EQ(xmm7.zmm(), zmm7); - EXPECT(ymm7.xmm() == xmm7); - EXPECT(ymm7.ymm() == ymm7); - EXPECT(ymm7.zmm() == zmm7); + EXPECT_EQ(ymm7.xmm(), xmm7); + EXPECT_EQ(ymm7.ymm(), ymm7); + EXPECT_EQ(ymm7.zmm(), zmm7); - EXPECT(zmm7.xmm() == xmm7); - EXPECT(zmm7.ymm() == ymm7); - EXPECT(zmm7.zmm() == zmm7); + EXPECT_EQ(zmm7.xmm(), xmm7); + EXPECT_EQ(zmm7.ymm(), ymm7); + EXPECT_EQ(zmm7.zmm(), zmm7); INFO("Checking x86::Mm register properties"); - EXPECT(Mm().isReg() == true); - EXPECT(mm2.isReg() == true); - EXPECT(mm2.id() == 2); - EXPECT(mm2.size() == 8); - EXPECT(mm2.type() == RegType::kX86_Mm); - EXPECT(mm2.group() == RegGroup::kX86_MM); + EXPECT_TRUE(Mm().isReg()); + EXPECT_TRUE(mm2.isReg()); + EXPECT_EQ(mm2.id(), 2u); + EXPECT_EQ(mm2.size(), 8u); + EXPECT_EQ(mm2.type(), RegType::kX86_Mm); + EXPECT_EQ(mm2.group(), RegGroup::kX86_MM); INFO("Checking x86::KReg register properties"); - EXPECT(KReg().isReg() == true); - EXPECT(k3.isReg() == true); - EXPECT(k3.id() == 3); - EXPECT(k3.size() == 0); - EXPECT(k3.type() == RegType::kX86_KReg); - EXPECT(k3.group() == RegGroup::kX86_K); + EXPECT_TRUE(KReg().isReg()); + EXPECT_TRUE(k3.isReg()); + EXPECT_EQ(k3.id(), 3u); + EXPECT_EQ(k3.size(), 0u); + EXPECT_EQ(k3.type(), RegType::kX86_KReg); + EXPECT_EQ(k3.group(), RegGroup::kX86_K); INFO("Checking x86::St register properties"); - EXPECT(St().isReg() == true); - EXPECT(st1.isReg() == true); - EXPECT(st1.id() == 1); - EXPECT(st1.size() == 10); - EXPECT(st1.type() == RegType::kX86_St); - EXPECT(st1.group() == RegGroup::kX86_St); + EXPECT_TRUE(St().isReg()); + EXPECT_TRUE(st1.isReg()); + EXPECT_EQ(st1.id(), 1u); + EXPECT_EQ(st1.size(), 10u); + EXPECT_EQ(st1.type(), RegType::kX86_St); + EXPECT_EQ(st1.group(), RegGroup::kX86_St); INFO("Checking if default constructed regs behave as expected"); - EXPECT(Reg().isValid() == false); - EXPECT(Gp().isValid() == false); - EXPECT(Xmm().isValid() == false); - EXPECT(Ymm().isValid() == false); - EXPECT(Zmm().isValid() == false); - EXPECT(Mm().isValid() == false); - EXPECT(KReg().isValid() == false); - EXPECT(SReg().isValid() == false); - EXPECT(CReg().isValid() == false); - EXPECT(DReg().isValid() == false); - EXPECT(St().isValid() == false); - EXPECT(Bnd().isValid() == false); + EXPECT_FALSE(Reg().isValid()); + EXPECT_FALSE(Gp().isValid()); + EXPECT_FALSE(Xmm().isValid()); + EXPECT_FALSE(Ymm().isValid()); + EXPECT_FALSE(Zmm().isValid()); + EXPECT_FALSE(Mm().isValid()); + EXPECT_FALSE(KReg().isValid()); + EXPECT_FALSE(SReg().isValid()); + EXPECT_FALSE(CReg().isValid()); + EXPECT_FALSE(DReg().isValid()); + EXPECT_FALSE(St().isValid()); + EXPECT_FALSE(Bnd().isValid()); INFO("Checking x86::Mem operand"); Mem m; - EXPECT(m == Mem(), "Two default constructed x86::Mem operands must be equal"); + EXPECT_EQ(m, Mem()); m = ptr(L); - EXPECT(m.hasBase() == true); - EXPECT(m.hasBaseReg() == false); - EXPECT(m.hasBaseLabel() == true); - EXPECT(m.hasOffset() == false); - EXPECT(m.isOffset64Bit() == false); - EXPECT(m.offset() == 0); - EXPECT(m.offsetLo32() == 0); + EXPECT_TRUE(m.hasBase()); + EXPECT_FALSE(m.hasBaseReg()); + EXPECT_TRUE(m.hasBaseLabel()); + EXPECT_FALSE(m.hasOffset()); + EXPECT_FALSE(m.isOffset64Bit()); + EXPECT_EQ(m.offset(), 0); + EXPECT_EQ(m.offsetLo32(), 0); m = ptr(0x0123456789ABCDEFu); - EXPECT(m.hasBase() == false); - EXPECT(m.hasBaseReg() == false); - EXPECT(m.hasIndex() == false); - EXPECT(m.hasIndexReg() == false); - EXPECT(m.hasOffset() == true); - EXPECT(m.isOffset64Bit() == true); - EXPECT(m.offset() == int64_t(0x0123456789ABCDEFu)); - EXPECT(m.offsetLo32() == int32_t(0x89ABCDEFu)); + EXPECT_FALSE(m.hasBase()); + EXPECT_FALSE(m.hasBaseReg()); + EXPECT_FALSE(m.hasIndex()); + EXPECT_FALSE(m.hasIndexReg()); + EXPECT_TRUE(m.hasOffset()); + EXPECT_TRUE(m.isOffset64Bit()); + EXPECT_EQ(m.offset(), int64_t(0x0123456789ABCDEFu)); + EXPECT_EQ(m.offsetLo32(), int32_t(0x89ABCDEFu)); m.addOffset(1); - EXPECT(m.offset() == int64_t(0x0123456789ABCDF0u)); + EXPECT_EQ(m.offset(), int64_t(0x0123456789ABCDF0u)); m = ptr(0x0123456789ABCDEFu, rdi, 3); - EXPECT(m.hasSegment() == false); - EXPECT(m.hasBase() == false); - EXPECT(m.hasBaseReg() == false); - EXPECT(m.hasIndex() == true); - EXPECT(m.hasIndexReg() == true); - EXPECT(m.indexType() == rdi.type()); - EXPECT(m.indexId() == rdi.id()); - EXPECT(m.shift() == 3); - EXPECT(m.hasOffset() == true); - EXPECT(m.isOffset64Bit() == true); - EXPECT(m.offset() == int64_t(0x0123456789ABCDEFu)); - EXPECT(m.offsetLo32() == int32_t(0x89ABCDEFu)); + EXPECT_FALSE(m.hasSegment()); + EXPECT_FALSE(m.hasBase()); + EXPECT_FALSE(m.hasBaseReg()); + EXPECT_TRUE(m.hasIndex()); + EXPECT_TRUE(m.hasIndexReg()); + EXPECT_EQ(m.indexType(), rdi.type()); + EXPECT_EQ(m.indexId(), rdi.id()); + EXPECT_EQ(m.shift(), 3u); + EXPECT_TRUE(m.hasOffset()); + EXPECT_TRUE(m.isOffset64Bit()); + EXPECT_EQ(m.offset(), int64_t(0x0123456789ABCDEFu)); + EXPECT_EQ(m.offsetLo32(), int32_t(0x89ABCDEFu)); m.resetIndex(); - EXPECT(m.hasIndex() == false); - EXPECT(m.hasIndexReg() == false); + EXPECT_FALSE(m.hasIndex()); + EXPECT_FALSE(m.hasIndexReg()); m = ptr(rax); - EXPECT(m.hasBase() == true); - EXPECT(m.hasBaseReg() == true); - EXPECT(m.baseType() == rax.type()); - EXPECT(m.baseId() == rax.id()); - EXPECT(m.hasIndex() == false); - EXPECT(m.hasIndexReg() == false); - EXPECT(m.indexType() == RegType::kNone); - EXPECT(m.indexId() == 0); - EXPECT(m.hasOffset() == false); - EXPECT(m.isOffset64Bit() == false); - EXPECT(m.offset() == 0); - EXPECT(m.offsetLo32() == 0); + EXPECT_TRUE(m.hasBase()); + EXPECT_TRUE(m.hasBaseReg()); + EXPECT_EQ(m.baseType(), rax.type()); + EXPECT_EQ(m.baseId(), rax.id()); + EXPECT_FALSE(m.hasIndex()); + EXPECT_FALSE(m.hasIndexReg()); + EXPECT_EQ(m.indexType(), RegType::kNone); + EXPECT_EQ(m.indexId(), 0u); + EXPECT_FALSE(m.hasOffset()); + EXPECT_FALSE(m.isOffset64Bit()); + EXPECT_EQ(m.offset(), 0); + EXPECT_EQ(m.offsetLo32(), 0); m.setIndex(rsi); - EXPECT(m.hasIndex() == true); - EXPECT(m.hasIndexReg() == true); - EXPECT(m.indexType() == rsi.type()); - EXPECT(m.indexId() == rsi.id()); + EXPECT_TRUE(m.hasIndex()); + EXPECT_TRUE(m.hasIndexReg()); + EXPECT_EQ(m.indexType(), rsi.type()); + EXPECT_EQ(m.indexId(), rsi.id()); } #endif diff --git a/test/asmjit_test_perf_x86.cpp b/test/asmjit_test_perf_x86.cpp index 29c1e1f..d634c30 100644 --- a/test/asmjit_test_perf_x86.cpp +++ b/test/asmjit_test_perf_x86.cpp @@ -2384,19 +2384,19 @@ static void generateAvx512SequenceInternalRegOnly( cc.evex().vcvtqq2ps(xmmA, ymmB); cc.evex().vcvtqq2ps(ymmA, zmmB); cc.evex().vcvtsd2si(gpd, xmmB); - if (cc.is64Bit()) cc.evex().vcvtsd2si(gpq, xmmB); + cc.evex().vcvtsd2si(gpz, xmmB); cc.evex().vcvtsd2ss(xmmA, xmmB, xmmC); cc.evex().vcvtsd2usi(gpd, xmmB); - if (cc.is64Bit()) cc.evex().vcvtsd2usi(gpq, xmmB); + cc.evex().vcvtsd2usi(gpz, xmmB); cc.evex().vcvtsi2sd(xmmA, xmmB, gpd); - if (cc.is64Bit()) cc.evex().vcvtsi2sd(xmmA, xmmB, gpq); + cc.evex().vcvtsi2sd(xmmA, xmmB, gpz); cc.evex().vcvtsi2ss(xmmA, xmmB, gpd); - if (cc.is64Bit()) cc.evex().vcvtsi2ss(xmmA, xmmB, gpq); + cc.evex().vcvtsi2ss(xmmA, xmmB, gpz); cc.evex().vcvtss2sd(xmmA, xmmB, xmmC); cc.evex().vcvtss2si(gpd, xmmB); - if (cc.is64Bit()) cc.evex().vcvtss2si(gpq, xmmB); + cc.evex().vcvtss2si(gpz, xmmB); cc.evex().vcvtss2usi(gpd, xmmB); - if (cc.is64Bit()) cc.evex().vcvtss2usi(gpq, xmmB); + cc.evex().vcvtss2usi(gpz, xmmB); cc.evex().vcvttpd2dq(xmmA, xmmB); cc.evex().vcvttpd2dq(xmmA, ymmB); cc.evex().vcvttpd2dq(ymmA, zmmB); @@ -2422,13 +2422,13 @@ static void generateAvx512SequenceInternalRegOnly( cc.evex().vcvttps2uqq(ymmA, xmmB); cc.evex().vcvttps2uqq(zmmA, ymmB); cc.evex().vcvttsd2si(gpd, xmmB); - if (cc.is64Bit()) cc.evex().vcvttsd2si(gpq, xmmB); + cc.evex().vcvttsd2si(gpz, xmmB); cc.evex().vcvttsd2usi(gpd, xmmB); - if (cc.is64Bit()) cc.evex().vcvttsd2usi(gpq, xmmB); + cc.evex().vcvttsd2usi(gpz, xmmB); cc.evex().vcvttss2si(gpd, xmmB); - if (cc.is64Bit()) cc.evex().vcvttss2si(gpq, xmmB); + cc.evex().vcvttss2si(gpz, xmmB); cc.evex().vcvttss2usi(gpd, xmmB); - if (cc.is64Bit()) cc.evex().vcvttss2usi(gpq, xmmB); + cc.evex().vcvttss2usi(gpz, xmmB); cc.evex().vcvtudq2pd(xmmA, xmmB); cc.evex().vcvtudq2pd(ymmA, xmmB); cc.evex().vcvtudq2pd(zmmA, ymmB); @@ -2442,9 +2442,9 @@ static void generateAvx512SequenceInternalRegOnly( cc.evex().vcvtuqq2ps(xmmA, ymmB); cc.evex().vcvtuqq2ps(ymmA, zmmB); cc.evex().vcvtusi2sd(xmmA, xmmB, gpd); - if (cc.is64Bit()) cc.evex().vcvtusi2sd(xmmA, xmmB, gpq); + cc.evex().vcvtusi2sd(xmmA, xmmB, gpz); cc.evex().vcvtusi2ss(xmmA, xmmB, gpd); - if (cc.is64Bit()) cc.evex().vcvtusi2ss(xmmA, xmmB, gpq); + cc.evex().vcvtusi2ss(xmmA, xmmB, gpz); cc.evex().vdbpsadbw(xmmA, xmmB, xmmC, 0); cc.evex().vdbpsadbw(ymmA, ymmB, ymmC, 0); cc.evex().vdbpsadbw(zmmA, zmmB, zmmC, 0); @@ -3706,19 +3706,19 @@ static void generateAvx512SequenceInternalRegMem( cc.evex().vcvtqq2ps(xmmA, m256); cc.evex().vcvtqq2ps(ymmA, m512); cc.evex().vcvtsd2si(gpd, m); - if (cc.is64Bit()) cc.evex().vcvtsd2si(gpq, m); + cc.evex().vcvtsd2si(gpz, m); cc.evex().vcvtsd2ss(xmmA, xmmB, m); cc.evex().vcvtsd2usi(gpd, m); - if (cc.is64Bit()) cc.evex().vcvtsd2usi(gpq, m); + cc.evex().vcvtsd2usi(gpz, m); cc.evex().vcvtsi2sd(xmmA, xmmB, m32); if (cc.is64Bit()) cc.evex().vcvtsi2sd(xmmA, xmmB, m64); cc.evex().vcvtsi2ss(xmmA, xmmB, m32); if (cc.is64Bit()) cc.evex().vcvtsi2ss(xmmA, xmmB, m64); cc.evex().vcvtss2sd(xmmA, xmmB, m); cc.evex().vcvtss2si(gpd, m); - if (cc.is64Bit()) cc.evex().vcvtss2si(gpq, m); + cc.evex().vcvtss2si(gpz, m); cc.evex().vcvtss2usi(gpd, m); - if (cc.is64Bit()) cc.evex().vcvtss2usi(gpq, m); + cc.evex().vcvtss2usi(gpz, m); cc.evex().vcvttpd2dq(xmmA, m128); cc.evex().vcvttpd2dq(xmmA, m256); cc.evex().vcvttpd2dq(ymmA, m512); @@ -3744,13 +3744,13 @@ static void generateAvx512SequenceInternalRegMem( cc.evex().vcvttps2uqq(ymmA, m); cc.evex().vcvttps2uqq(zmmA, m); cc.evex().vcvttsd2si(gpd, m); - if (cc.is64Bit()) cc.evex().vcvttsd2si(gpq, m); + cc.evex().vcvttsd2si(gpz, m); cc.evex().vcvttsd2usi(gpd, m); - if (cc.is64Bit()) cc.evex().vcvttsd2usi(gpq, m); + cc.evex().vcvttsd2usi(gpz, m); cc.evex().vcvttss2si(gpd, m); - if (cc.is64Bit()) cc.evex().vcvttss2si(gpq, m); + cc.evex().vcvttss2si(gpz, m); cc.evex().vcvttss2usi(gpd, m); - if (cc.is64Bit()) cc.evex().vcvttss2usi(gpq, m); + cc.evex().vcvttss2usi(gpz, m); cc.evex().vcvtudq2pd(xmmA, m); cc.evex().vcvtudq2pd(ymmA, m); cc.evex().vcvtudq2pd(zmmA, m); diff --git a/test/broken.cpp b/test/broken.cpp index bb874fd..c28ffa7 100644 --- a/test/broken.cpp +++ b/test/broken.cpp @@ -25,12 +25,11 @@ // // For more information, please refer to -#include "./broken.h" +#include "broken.h" #include -// ============================================================================ -// [Broken - Global] -// ============================================================================ +// Broken - Globals +// ================ // Zero initialized globals. struct BrokenGlobal { @@ -56,9 +55,8 @@ struct BrokenGlobal { }; static BrokenGlobal _brokenGlobal; -// ============================================================================ -// [Broken - API] -// ============================================================================ +// Broken - API +// ============ // Get whether the string `a` starts with string `b`. static bool BrokenAPI_startsWith(const char* a, const char* b) noexcept { @@ -185,7 +183,7 @@ bool BrokenAPI::hasArg(const char* name) noexcept { return _brokenGlobal.hasArg(name); } -void BrokenAPI::add(Unit* unit) noexcept { +void BrokenAPI::addUnit(Unit* unit) noexcept { Unit** pPrev = &_brokenGlobal._unitList; Unit* current = *pPrev; @@ -308,5 +306,5 @@ void BrokenAPI::fail(const char* file, int line, const char* expression, const c fprintf(dst, " SOURCE: %s (Line: %d)\n", file, line); fflush(dst); - exit(1); + abort(); } diff --git a/test/broken.h b/test/broken.h index 701bc8b..74b901c 100644 --- a/test/broken.h +++ b/test/broken.h @@ -38,79 +38,125 @@ //! \cond -// ============================================================================ -// [Broken - API] -// ============================================================================ +// Broken - API +// ============ -struct BrokenAPI { - //! Entry point of a unit test defined by `UNIT` macro. - typedef void (*Entry)(void); +namespace BrokenAPI { - enum Flags : unsigned { - kFlagFinished = 0x1 - }; +//! Entry point of a unit test defined by `UNIT` macro. +typedef void (*Entry)(void); - //! Test defined by `UNIT` macro. - struct Unit { - Entry entry; - const char* name; - int priority; - unsigned flags; - Unit* next; - }; +enum Flags : unsigned { + kFlagFinished = 0x1 +}; - //! Automatic unit registration by using static initialization. - struct AutoUnit : Unit { - inline AutoUnit(Entry entry_, const char* name_, int priority_ = 0, int dummy_ = 0) noexcept { - // Not used, only to trick `UNIT()` macro. - (void)dummy_; +struct Unit; - this->entry = entry_; - this->name = name_; - this->priority = priority_; - this->flags = 0; - this->next = nullptr; - BrokenAPI::add(this); - } - }; +bool hasArg(const char* name) noexcept; - static bool hasArg(const char* name) noexcept; +//! Register a new unit test (called automatically by `AutoUnit` and `UNIT`). +void addUnit(Unit* unit) noexcept; - //! Register a new unit test (called automatically by `AutoUnit` and `UNIT`). - static void add(Unit* unit) noexcept; +//! Set output file to a `file`. +void setOutputFile(FILE* file) noexcept; - //! Set output file to a `file`. - static void setOutputFile(FILE* file) noexcept; +//! Initialize `Broken` framework. +//! +//! Returns `true` if `run()` should be called. +int run(int argc, const char* argv[], Entry onBeforeRun = nullptr, Entry onAfterRun = nullptr); - //! Initialize `Broken` framework. - //! - //! Returns `true` if `run()` should be called. - static int run(int argc, const char* argv[], Entry onBeforeRun = nullptr, Entry onAfterRun = nullptr); +//! Log message, adds automatically new line if not present. +void info(const char* fmt, ...) noexcept; - //! Log message, adds automatically new line if not present. - static void info(const char* fmt, ...) noexcept; +//! Called on `EXPECT()` failure. +void fail(const char* file, int line, const char* expression, const char* fmt, ...) noexcept; - //! Called on `EXPECT()` failure. - static void fail(const char* file, int line, const char* expression, const char* fmt, ...) noexcept; +//! Test defined by `UNIT` macro. +struct Unit { + Entry entry; + const char* name; + int priority; + unsigned flags; + Unit* next; +}; - //! Used internally by `EXPECT` macro. - template - static inline void expect(const char* file, int line, const char* expression, const T& result) noexcept { - if (!result) - fail(file, line, expression, nullptr); - } +//! Automatic unit registration by using static initialization. +class AutoUnit : public Unit { +public: + inline AutoUnit(Entry entry_, const char* name_, int priority_ = 0, int dummy_ = 0) noexcept { + // Not used, only to trick `UNIT()` macro. + (void)dummy_; - //! Used internally by `EXPECT` macro. - template - static inline void expect(const char* file, int line, const char* expression, const T& result, const char* fmt, Args&&... args) noexcept { - if (!result) - fail(file, line, expression, fmt, std::forward(args)...); + this->entry = entry_; + this->name = name_; + this->priority = priority_; + this->flags = 0; + this->next = nullptr; + addUnit(this); } }; -// ============================================================================ -// [Broken - Macros] -// ============================================================================ +class Failure { +public: + const char* _file = nullptr; + const char* _expression = nullptr; + int _line = 0; + bool _handled = false; + + inline Failure(const char* file, int line, const char* expression) noexcept + : _file(file), + _expression(expression), + _line(line) {} + + inline ~Failure() noexcept { + if (!_handled) + fail(_file, _line, _expression, nullptr); + } + + template + inline void message(const char* fmt, Args&&... args) noexcept { + fail(_file, _line, _expression, fmt, std::forward(args)...); + _handled = true; + } +}; + +template +static inline bool check(Result&& result) noexcept { return !!result; } + +template +static inline bool checkEq(LHS&& lhs, RHS&& rhs) noexcept { return lhs == rhs; } + +template +static inline bool checkNe(LHS&& lhs, RHS&& rhs) noexcept { return lhs != rhs; } + +template +static inline bool checkGt(LHS&& lhs, RHS&& rhs) noexcept { return lhs > rhs; } + +template +static inline bool checkGe(LHS&& lhs, RHS&& rhs) noexcept { return lhs >= rhs; } + +template +static inline bool checkLt(LHS&& lhs, RHS&& rhs) noexcept { return lhs < rhs; } + +template +static inline bool checkLe(LHS&& lhs, RHS&& rhs) noexcept { return lhs <= rhs; } + +template +static inline bool checkTrue(Result&& result) noexcept { return !!result; } + +template +static inline bool checkFalse(Result&& result) noexcept { return !result; } + +template +static inline bool checkNull(Result&& result) noexcept { return result == nullptr; } + +template +static inline bool checkNotNull(Result&& result) noexcept { return result != nullptr; } + +} // {BrokenAPI} + +// Broken - Macros +// =============== //! Internal macro used by `UNIT()`. #define BROKEN_UNIT_INTERNAL(NAME, PRIORITY) \ @@ -118,19 +164,14 @@ struct BrokenAPI { static ::BrokenAPI::AutoUnit unit_##NAME##_autoinit(unit_##NAME##_entry, #NAME, PRIORITY); \ static void unit_##NAME##_entry(void) -//! Stringifies the expression used by EXPECT(). -#define BROKEN_STRINFIGY_EXPRESSION_INTERNAL(EXP, ...) #EXP - //! \def UNIT(NAME [, PRIORITY]) //! //! Define a unit test with an optional priority. //! -//! `NAME` can only contain ASCII characters, numbers and underscore. It has -//! the same rules as identifiers in C and C++. +//! `NAME` can only contain ASCII characters, numbers and underscore. It has the same rules as identifiers in C and C++. //! -//! `PRIORITY` specifies the order in which unit tests are run. Lesses value -//! increases the priority. At the moment all units are first sorted by -//! priority and then by name - this makes the run always deterministic. +//! `PRIORITY` specifies the order in which unit tests are run. Lesses value increases the priority. At the moment all +//!units are first sorted by priority and then by name - this makes the run always deterministic. #define UNIT(NAME, ...) BROKEN_UNIT_INTERNAL(NAME, __VA_ARGS__ + 0) //! #define INFO(FORMAT [, ...]) @@ -138,10 +179,21 @@ struct BrokenAPI { //! Informative message printed to `stdout`. #define INFO(...) ::BrokenAPI::info(__VA_ARGS__) -//! #define INFO(EXP [, FORMAT [, ...]]) -//! -//! Expect `EXP` to be true or evaluates to true, fail otherwise. -#define EXPECT(...) ::BrokenAPI::expect(__FILE__, __LINE__, BROKEN_STRINFIGY_EXPRESSION_INTERNAL(__VA_ARGS__), __VA_ARGS__) +#define BROKEN_EXPECT_INTERNAL(file, line, expression, result) \ + for (bool _testInternalResult = (result); !_testInternalResult; _testInternalResult = true) \ + ::BrokenAPI::Failure(file, line, expression) + +#define EXPECT(...) BROKEN_EXPECT_INTERNAL(__FILE__, __LINE__, "EXPECT(" #__VA_ARGS__ ")", !!(__VA_ARGS__)) +#define EXPECT_EQ(...) BROKEN_EXPECT_INTERNAL(__FILE__, __LINE__, "EXPECT_EQ(" #__VA_ARGS__ ")", ::BrokenAPI::checkEq(__VA_ARGS__)) +#define EXPECT_NE(...) BROKEN_EXPECT_INTERNAL(__FILE__, __LINE__, "EXPECT_NE(" #__VA_ARGS__ ")", ::BrokenAPI::checkNe(__VA_ARGS__)) +#define EXPECT_GT(...) BROKEN_EXPECT_INTERNAL(__FILE__, __LINE__, "EXPECT_GT(" #__VA_ARGS__ ")", ::BrokenAPI::checkGt(__VA_ARGS__)) +#define EXPECT_GE(...) BROKEN_EXPECT_INTERNAL(__FILE__, __LINE__, "EXPECT_GE(" #__VA_ARGS__ ")", ::BrokenAPI::checkGe(__VA_ARGS__)) +#define EXPECT_LT(...) BROKEN_EXPECT_INTERNAL(__FILE__, __LINE__, "EXPECT_LT(" #__VA_ARGS__ ")", ::BrokenAPI::checkLt(__VA_ARGS__)) +#define EXPECT_LE(...) BROKEN_EXPECT_INTERNAL(__FILE__, __LINE__, "EXPECT_LE(" #__VA_ARGS__ ")", ::BrokenAPI::checkLe(__VA_ARGS__)) +#define EXPECT_TRUE(...) BROKEN_EXPECT_INTERNAL(__FILE__, __LINE__, "EXPECT_TRUE(" #__VA_ARGS__ ")", ::BrokenAPI::checkTrue(__VA_ARGS__)) +#define EXPECT_FALSE(...) BROKEN_EXPECT_INTERNAL(__FILE__, __LINE__, "EXPECT_FALSE(" #__VA_ARGS__ ")", ::BrokenAPI::checkFalse(__VA_ARGS__)) +#define EXPECT_NULL(...) BROKEN_EXPECT_INTERNAL(__FILE__, __LINE__, "EXPECT_NULL(" #__VA_ARGS__ ")", ::BrokenAPI::checkNull(__VA_ARGS__)) +#define EXPECT_NOT_NULL(...) BROKEN_EXPECT_INTERNAL(__FILE__, __LINE__, "EXPECT_NOT_NULL(" #__VA_ARGS__ ")", ::BrokenAPI::checkNotNull(__VA_ARGS__)) //! \endcond