diff options
Diffstat (limited to '3rdparty/asmjit/src/asmjit/x86/x86operand.cpp')
-rw-r--r-- | 3rdparty/asmjit/src/asmjit/x86/x86operand.cpp | 400 |
1 files changed, 180 insertions, 220 deletions
diff --git a/3rdparty/asmjit/src/asmjit/x86/x86operand.cpp b/3rdparty/asmjit/src/asmjit/x86/x86operand.cpp index ca7ce5a8c66..5ab50de570e 100644 --- a/3rdparty/asmjit/src/asmjit/x86/x86operand.cpp +++ b/3rdparty/asmjit/src/asmjit/x86/x86operand.cpp @@ -1,271 +1,231 @@ -// AsmJit - Machine code generation for C++ +// This file is part of AsmJit project <https://asmjit.com> // -// * Official AsmJit Home Page: https://asmjit.com -// * Official Github Repository: https://github.com/asmjit/asmjit -// -// Copyright (c) 2008-2020 The AsmJit Authors -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib #include "../core/api-build_p.h" -#ifdef ASMJIT_BUILD_X86 +#if !defined(ASMJIT_NO_X86) #include "../core/misc_p.h" #include "../x86/x86operand.h" ASMJIT_BEGIN_SUB_NAMESPACE(x86) -// ============================================================================ -// [asmjit::x86::OpData] -// ============================================================================ - -const OpData opData = { - { - // RegInfo[] - #define VALUE(X) { RegTraits<X>::kSignature } - { ASMJIT_LOOKUP_TABLE_32(VALUE, 0) }, - #undef VALUE - - // RegCount[] - #define VALUE(X) RegTraits<X>::kCount - { ASMJIT_LOOKUP_TABLE_32(VALUE, 0) }, - #undef VALUE - - // RegTypeToTypeId[] - #define VALUE(X) RegTraits<X>::kTypeId - { ASMJIT_LOOKUP_TABLE_32(VALUE, 0) } - #undef VALUE - } -}; - -// ============================================================================ -// [asmjit::x86::Operand - Unit] -// ============================================================================ +// x86::Operand - Tests +// ==================== #if defined(ASMJIT_TEST) 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(gpb_lo(Gp::kIdAx) == al); - EXPECT(gpb_lo(Gp::kIdBx) == bl); - EXPECT(gpb_lo(Gp::kIdCx) == cl); - EXPECT(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(gpw(Gp::kIdAx) == ax); - EXPECT(gpw(Gp::kIdBx) == bx); - EXPECT(gpw(Gp::kIdCx) == cx); - EXPECT(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(gpq(Gp::kIdAx) == rax); - EXPECT(gpq(Gp::kIdBx) == rbx); - EXPECT(gpq(Gp::kIdCx) == rcx); - EXPECT(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_EQ(gpb(Gp::kIdAx), al); + EXPECT_EQ(gpb(Gp::kIdBx), bl); + EXPECT_EQ(gpb(Gp::kIdCx), cl); + EXPECT_EQ(gpb(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_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_EQ(gpw(Gp::kIdAx), ax); + EXPECT_EQ(gpw(Gp::kIdBx), bx); + EXPECT_EQ(gpw(Gp::kIdCx), cx); + EXPECT_EQ(gpw(Gp::kIdDx), dx); + + 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_EQ(gpq(Gp::kIdAx), rax); + EXPECT_EQ(gpq(Gp::kIdBx), rbx); + EXPECT_EQ(gpq(Gp::kIdCx), rcx); + EXPECT_EQ(gpq(Gp::kIdDx), rdx); + + 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() == Reg::kTypeGpd); - EXPECT(eax.group() == Reg::kGroupGp); + 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() == Reg::kTypeXmm); - EXPECT(xmm4.group() == Reg::kGroupVec); - 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() == Reg::kTypeYmm); - EXPECT(ymm5.group() == Reg::kGroupVec); - 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() == Reg::kTypeZmm); - EXPECT(zmm6.group() == Reg::kGroupVec); - 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(xmm7.xmm() == xmm7); - EXPECT(xmm7.ymm() == ymm7); - EXPECT(xmm7.zmm() == zmm7); - - EXPECT(ymm7.xmm() == xmm7); - EXPECT(ymm7.ymm() == ymm7); - EXPECT(ymm7.zmm() == zmm7); - - EXPECT(zmm7.xmm() == xmm7); - EXPECT(zmm7.ymm() == ymm7); - EXPECT(zmm7.zmm() == zmm7); - - INFO("Checking x86::FpMm register properties"); - EXPECT(Mm().isReg() == true); - EXPECT(mm2.isReg() == true); - EXPECT(mm2.id() == 2); - EXPECT(mm2.size() == 8); - EXPECT(mm2.type() == Reg::kTypeMm); - EXPECT(mm2.group() == Reg::kGroupMm); + 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_EQ(xmm7.xmm(), xmm7); + EXPECT_EQ(xmm7.ymm(), ymm7); + EXPECT_EQ(xmm7.zmm(), zmm7); + + EXPECT_EQ(ymm7.xmm(), xmm7); + EXPECT_EQ(ymm7.ymm(), ymm7); + EXPECT_EQ(ymm7.zmm(), zmm7); + + EXPECT_EQ(zmm7.xmm(), xmm7); + EXPECT_EQ(zmm7.ymm(), ymm7); + EXPECT_EQ(zmm7.zmm(), zmm7); + + INFO("Checking x86::Mm register properties"); + 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() == Reg::kTypeKReg); - EXPECT(k3.group() == Reg::kGroupKReg); + 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() == Reg::kTypeSt); - EXPECT(st1.group() == Reg::kGroupSt); + 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)); - - m = ptr(0x0123456789ABCDEFu, rdi, 4); - 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.hasOffset() == true); - EXPECT(m.isOffset64Bit() == true); - EXPECT(m.offset() == int64_t(0x0123456789ABCDEFu)); - EXPECT(m.offsetLo32() == int32_t(0x89ABCDEFu)); + EXPECT_EQ(m.offset(), int64_t(0x0123456789ABCDF0u)); + + m = ptr(0x0123456789ABCDEFu, rdi, 3); + 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() == 0); - 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 ASMJIT_END_SUB_NAMESPACE -#endif // ASMJIT_BUILD_X86 +#endif // !ASMJIT_NO_X86 |