summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/asmjit/src/asmjit/x86/x86operand.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/asmjit/src/asmjit/x86/x86operand.cpp')
-rw-r--r--3rdparty/asmjit/src/asmjit/x86/x86operand.cpp400
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