//===- subzero/unittest/AssemblerX8664/Locked.cpp -------------------------===//
//
// The Subzero Code Generator
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "AssemblerX8664/TestUtil.h"
namespace Ice {
namespace X8664 {
namespace Test {
namespace {
TEST_F(AssemblerX8664LowLevelTest, Mfence) {
__ mfence();
static constexpr uint8_t ByteCount = 3;
ASSERT_EQ(ByteCount, codeBytesSize());
verifyBytes<ByteCount>(codeBytes(), 0x0F, 0xAE, 0xF0);
}
TEST_F(AssemblerX8664LowLevelTest, Lock) {
__ lock();
static constexpr uint8_t ByteCount = 1;
ASSERT_EQ(ByteCount, codeBytesSize());
verifyBytes<ByteCount>(codeBytes(), 0xF0);
}
TEST_F(AssemblerX8664Test, Xchg) {
static constexpr uint32_t Mask8 = 0x000000FF;
static constexpr uint32_t Mask16 = 0x0000FFFF;
static constexpr uint32_t Mask32 = 0xFFFFFFFF;
#define TestImplAddrReg(Value0, Dst1, Value1, Size) \
do { \
static constexpr char TestString[] = \
"(" #Value0 ", " #Dst1 ", " #Value1 ", " #Size ")"; \
const uint32_t T0 = allocateDword(); \
const uint32_t V0 = (Value0)&Mask##Size; \
const uint32_t V1 = (Value1)&Mask##Size; \
\
__ mov(IceType_i##Size, Encoded_GPR_##Dst1(), Immediate(Value1)); \
__ xchg(IceType_i##Size, dwordAddress(T0), Encoded_GPR_##Dst1()); \
__ And(IceType_i32, Encoded_GPR_##Dst1(), Immediate(Mask##Size)); \
\
AssembledTest test = assemble(); \
test.setDwordTo(T0, V0); \
test.run(); \
\
ASSERT_EQ(V0, test.Dst1()) << TestString; \
ASSERT_EQ(V1, test.contentsOfDword(T0)) << TestString; \
reset(); \
} while (0)
#define TestImplSize(Dst1, Size) \
do { \
TestImplAddrReg(0xa2b34567, Dst1, 0x0507ddee, Size); \
} while (0)
#define TestImpl(Dst1) \
do { \
TestImplSize(Dst1, 8); \
TestImplSize(Dst1, 16); \
TestImplSize(Dst1, 32); \
} while (0)
TestImpl(r1);
TestImpl(r2);
TestImpl(r3);
TestImpl(r4);
TestImpl(r5);
TestImpl(r6);
TestImpl(r7);
TestImpl(r8);
TestImpl(r10);
TestImpl(r11);
TestImpl(r12);
TestImpl(r13);
TestImpl(r14);
TestImpl(r15);
#undef TestImpl
#undef TestImplSize
#undef TestImplAddrReg
#define TestImplRegReg(Reg0, Value0, Reg1, Value1, Size) \
do { \
static constexpr char TestString[] = \
"(" #Reg0 "," #Value0 ", " #Reg1 ", " #Value1 ", " #Size ")"; \
const uint32_t V0 = (Value0)&Mask##Size; \
const uint32_t V1 = (Value1)&Mask##Size; \
\
__ mov(IceType_i##Size, Encoded_GPR_##Reg0(), Immediate(Value0)); \
__ mov(IceType_i##Size, Encoded_GPR_##Reg1(), Immediate(Value1)); \
__ xchg(IceType_i##Size, Encoded_GPR_##Reg0(), Encoded_GPR_##Reg1()); \
__ And(IceType_i32, Encoded_GPR_##Reg0(), Immediate(Mask##Size)); \
__ And(IceType_i32, Encoded_GPR_##Reg1(), Immediate(Mask##Size)); \
\
AssembledTest test = assemble(); \
test.run(); \
\
ASSERT_EQ(V0, test.Reg1()) << TestString; \
ASSERT_EQ(V1, test.Reg0()) << TestString; \
reset(); \
} while (0)
#define TestImplSize(Reg0, Reg1, Size) \
do { \
TestImplRegReg(Reg0, 0xa2b34567, Reg1, 0x0507ddee, Size); \
} while (0)
#define TestImpl(Reg0, Reg1) \
do { \
TestImplSize(Reg0, Reg1, 8); \
TestImplSize(Reg0, Reg1, 16); \
TestImplSize(Reg0, Reg1, 32); \
} while (0)
// r1 == rax so has a short encoding
TestImpl(r6, r1);
TestImpl(r1, r8);
TestImpl(r2, r10);
TestImpl(r3, r11);
TestImpl(r4, r12);
TestImpl(r5, r13);
TestImpl(r6, r14);
TestImpl(r7, r15);
#undef TestImpl
#undef TestImplSize
#undef TestImplRegReg
}
TEST_F(AssemblerX8664Test, Xadd) {
static constexpr bool NotLocked = false;
static constexpr bool Locked = true;
static constexpr uint32_t Mask8 = 0x000000FF;
static constexpr uint32_t Mask16 = 0x0000FFFF;
static constexpr uint32_t Mask32 = 0xFFFFFFFF;
#define TestImplAddrReg(Value0, Dst1, Value1, LockedOrNot, Size) \
do { \
static constexpr char TestString[] = \
"(" #Value0 ", " #Dst1 ", " #Value1 ", " #Size ")"; \
const uint32_t T0 = allocateDword(); \
const uint32_t V0 = (Value0)&Mask##Size; \
const uint32_t V1 = (Value1)&Mask##Size; \
\
__ mov(IceType_i##Size, Encoded_GPR_##Dst1(), Immediate(Value1)); \
__ xadd(IceType_i##Size, dwordAddress(T0), Encoded_GPR_##Dst1(), \
LockedOrNot); \
__ And(IceType_i32, Encoded_GPR_##Dst1(), Immediate(Mask##Size)); \
\
AssembledTest test = assemble(); \
test.setDwordTo(T0, V0); \
test.run(); \
\
ASSERT_EQ(V0, test.Dst1()) << TestString; \
ASSERT_EQ(Mask##Size &(V1 + V0), test.contentsOfDword(T0)) << TestString; \
reset(); \
} while (0)
#define TestImplSize(Dst1, Size) \
do { \
TestImplAddrReg(0xa2b34567, Dst1, 0x0507ddee, NotLocked, Size); \
TestImplAddrReg(0xa2b34567, Dst1, 0x0507ddee, Locked, Size); \
} while (0)
#define TestImpl(Dst1) \
do { \
TestImplSize(Dst1, 8); \
TestImplSize(Dst1, 16); \
TestImplSize(Dst1, 32); \
} while (0)
TestImpl(r1);
TestImpl(r2);
TestImpl(r3);
TestImpl(r4);
TestImpl(r5);
TestImpl(r6);
TestImpl(r7);
TestImpl(r8);
TestImpl(r10);
TestImpl(r11);
TestImpl(r12);
TestImpl(r13);
TestImpl(r14);
TestImpl(r15);
#undef TestImpl
#undef TestImplSize
#undef TestImplAddrReg
}
TEST_F(AssemblerX8664LowLevelTest, Xadd) {
static constexpr bool NotLocked = false;
static constexpr bool Locked = true;
// Ensures that xadd emits a lock prefix accordingly.
{
__ xadd(IceType_i8, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
NotLocked);
static constexpr uint8_t ByteCountNotLocked8 = 10;
ASSERT_EQ(ByteCountNotLocked8, codeBytesSize());
ASSERT_TRUE(verifyBytes<ByteCountNotLocked8>(codeBytes(), 0x67, 0x44, 0x0F,
0xC0, 0x34, 0x25, 0x00, 0xFF,
0x01, 0x00));
reset();
__ xadd(IceType_i8, Address::Absolute(0x1FF00), Encoded_GPR_r14(), Locked);
static constexpr uint8_t ByteCountLocked8 = 1 + ByteCountNotLocked8;
ASSERT_EQ(ByteCountLocked8, codeBytesSize());
ASSERT_TRUE(verifyBytes<ByteCountLocked8>(codeBytes(), 0xF0, 0x67, 0x44,
0x0F, 0xC0, 0x34, 0x25, 0x00,
0xFF, 0x01, 0x00));
reset();
}
{
__ xadd(IceType_i16, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
NotLocked);
static constexpr uint8_t ByteCountNotLocked16 = 11;
ASSERT_EQ(ByteCountNotLocked16, codeBytesSize());
ASSERT_TRUE(verifyBytes<ByteCountNotLocked16>(codeBytes(), 0x66, 0x67, 0x44,
0x0F, 0xC1, 0x34, 0x25, 0x00,
0xFF, 0x01, 0x00));
reset();
__ xadd(IceType_i16, Address::Absolute(0x1FF00), Encoded_GPR_r14(), Locked);
static constexpr uint8_t ByteCountLocked16 = 1 + ByteCountNotLocked16;
ASSERT_EQ(ByteCountLocked16, codeBytesSize());
ASSERT_TRUE(verifyBytes<ByteCountLocked16>(codeBytes(), 0x66, 0xF0, 0x67,
0x44, 0x0F, 0xC1, 0x34, 0x25,
0x00, 0xFF, 0x01, 0x00));
reset();
}
{
__ xadd(IceType_i32, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
NotLocked);
static constexpr uint8_t ByteCountNotLocked32 = 10;
ASSERT_EQ(ByteCountNotLocked32, codeBytesSize());
ASSERT_TRUE(verifyBytes<ByteCountNotLocked32>(codeBytes(), 0x67, 0x44, 0x0F,
0xC1, 0x34, 0x25, 0x00, 0xFF,
0x01, 0x00));
reset();
__ xadd(IceType_i32, Address::Absolute(0x1FF00), Encoded_GPR_r14(), Locked);
static constexpr uint8_t ByteCountLocked32 = 1 + ByteCountNotLocked32;
ASSERT_EQ(ByteCountLocked32, codeBytesSize());
ASSERT_TRUE(verifyBytes<ByteCountLocked32>(codeBytes(), 0xF0, 0x67, 0x44,
0x0F, 0xC1, 0x34, 0x25, 0x00,
0xFF, 0x01, 0x00));
reset();
}
}
TEST_F(AssemblerX8664LowLevelTest, EmitSegmentOverride) {
#define TestImpl(Prefix) \
do { \
static constexpr uint8_t ByteCount = 1; \
__ emitSegmentOverride(Prefix); \
ASSERT_EQ(ByteCount, codeBytesSize()) << Prefix; \
ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), Prefix)); \
reset(); \
} while (0)
TestImpl(0x26);
TestImpl(0x2E);
TestImpl(0x36);
TestImpl(0x3E);
TestImpl(0x64);
TestImpl(0x65);
TestImpl(0x66);
TestImpl(0x67);
#undef TestImpl
}
TEST_F(AssemblerX8664Test, Cmpxchg8b) {
static constexpr bool NotLocked = false;
static constexpr bool Locked = true;
#define TestImpl(Value0, Value1, ValueMem, LockedOrNot) \
do { \
static constexpr char TestString[] = \
"(" #Value0 ", " #Value1 ", " #ValueMem ", " #LockedOrNot ")"; \
const uint32_t T0 = allocateQword(); \
static constexpr uint64_t V0 = ValueMem; \
const uint32_t ZeroFlag = allocateDword(); \
\
__ mov(IceType_i32, Encoded_GPR_eax(), \
Immediate(uint64_t(Value0) & 0xFFFFFFFF)); \
__ mov(IceType_i32, Encoded_GPR_edx(), Immediate(uint64_t(Value0) >> 32)); \
__ mov(IceType_i32, Encoded_GPR_ebx(), \
Immediate(uint64_t(Value1) & 0xFFFFFFFF)); \
__ mov(IceType_i32, Encoded_GPR_ecx(), Immediate(uint64_t(Value1) >> 32)); \
__ cmpxchg8b(dwordAddress(T0), LockedOrNot); \
__ setcc(Cond::Br_e, dwordAddress(ZeroFlag)); \
\
AssembledTest test = assemble(); \
test.setQwordTo(T0, V0); \
test.setDwordTo(ZeroFlag, uint32_t(0xFF)); \
test.run(); \
\
if (V0 == (Value0)) { \
ASSERT_EQ(uint64_t(Value1), test.contentsOfQword(T0)) << TestString; \
ASSERT_EQ(1u, test.contentsOfDword(ZeroFlag)) << TestString; \
} else { \
ASSERT_EQ(uint64_t(ValueMem) & 0xFFFFFFFF, test.eax()) << TestString; \
ASSERT_EQ((uint64_t(ValueMem) >> 32) & 0xFFFFFFFF, test.edx()) \
<< TestString; \
ASSERT_EQ(0u, test.contentsOfDword(ZeroFlag)) << TestString; \
} \
reset(); \
} while (0)
TestImpl(0x98987676543210ull, 0x1, 0x98987676543210ull, NotLocked);
TestImpl(0x98987676543210ull, 0x1, 0x98987676543210ull, Locked);
TestImpl(0x98987676543210ull, 0x1, 0x98987676543211ull, NotLocked);
TestImpl(0x98987676543210ull, 0x1, 0x98987676543211ull, Locked);
#undef TestImpl
}
TEST_F(AssemblerX8664LowLevelTest, Cmpxchg8b) {
static constexpr bool NotLocked = false;
static constexpr bool Locked = true;
// Ensures that cmpxchg8b emits a lock prefix accordingly.
__ cmpxchg8b(Address::Absolute(0x1FF00), NotLocked);
static constexpr uint8_t ByteCountNotLocked = 9;
ASSERT_EQ(ByteCountNotLocked, codeBytesSize());
ASSERT_TRUE(verifyBytes<ByteCountNotLocked>(
codeBytes(), 0x67, 0x0F, 0xC7, 0x0C, 0x25, 0x00, 0xFF, 0x01, 0x00));
reset();
__ cmpxchg8b(Address::Absolute(0x1FF00), Locked);
static constexpr uint8_t ByteCountLocked = 1 + ByteCountNotLocked;
ASSERT_EQ(ByteCountLocked, codeBytesSize());
ASSERT_TRUE(verifyBytes<ByteCountLocked>(codeBytes(), 0xF0, 0x67, 0x0F, 0xC7,
0x0C, 0x25, 0x00, 0xFF, 0x01, 0x00));
reset();
}
TEST_F(AssemblerX8664Test, Cmpxchg) {
static constexpr bool NotLocked = false;
static constexpr bool Locked = true;
static constexpr uint32_t Mask8 = 0x000000FF;
static constexpr uint32_t Mask16 = 0x0000FFFF;
static constexpr uint32_t Mask32 = 0xFFFFFFFF;
#define TestImplAddrReg(Value0, Src, Value1, ValueMem, LockedOrNot, Size) \
do { \
static constexpr char TestString[] = \
"(" #Value0 ", " #Src ", " #Value1 ", " #ValueMem ", " #LockedOrNot \
", " #Size ")"; \
const uint32_t T0 = allocateDword(); \
static constexpr uint32_t V0 = (ValueMem)&Mask##Size; \
const uint32_t ZeroFlag = allocateDword(); \
\
__ mov(IceType_i##Size, Encoded_GPR_eax(), \
Immediate((Value0)&Mask##Size)); \
__ mov(IceType_i##Size, Encoded_GPR_##Src(), \
Immediate((Value1)&Mask##Size)); \
__ cmpxchg(IceType_i##Size, dwordAddress(T0), Encoded_GPR_##Src(), \
LockedOrNot); \
__ setcc(Cond::Br_e, dwordAddress(ZeroFlag)); \
\
AssembledTest test = assemble(); \
test.setDwordTo(T0, V0); \
test.setDwordTo(ZeroFlag, uint32_t(0xFF)); \
test.run(); \
\
if (V0 == (Mask##Size & (Value0))) { \
ASSERT_EQ(uint32_t((Value1)&Mask##Size), test.contentsOfDword(T0)) \
<< TestString; \
ASSERT_EQ(1u, test.contentsOfDword(ZeroFlag)) << TestString; \
} else { \
ASSERT_EQ(uint32_t((ValueMem)&Mask##Size), test.eax()) << TestString; \
ASSERT_EQ(0u, test.contentsOfDword(ZeroFlag)) << TestString; \
} \
reset(); \
} while (0)
#define TestImplValue(Value0, Src, Value1, ValueMem, LockedOrNot) \
do { \
TestImplAddrReg(Value0, Src, Value1, ValueMem, LockedOrNot, 8); \
TestImplAddrReg(Value0, Src, Value1, ValueMem, LockedOrNot, 16); \
TestImplAddrReg(Value0, Src, Value1, ValueMem, LockedOrNot, 32); \
} while (0)
#define TestImpl(Src, LockedOrNot) \
do { \
TestImplValue(0xFFFFFFFF, Src, 0x1, 0xFFFFFFFF, LockedOrNot); \
TestImplValue(0x0FFF0F0F, Src, 0x1, 0xFFFFFFFF, LockedOrNot); \
} while (0)
TestImpl(r2, Locked);
TestImpl(r2, NotLocked);
TestImpl(r3, Locked);
TestImpl(r3, NotLocked);
TestImpl(r4, Locked);
TestImpl(r4, NotLocked);
TestImpl(r5, Locked);
TestImpl(r5, NotLocked);
TestImpl(r6, Locked);
TestImpl(r6, NotLocked);
TestImpl(r7, Locked);
TestImpl(r7, NotLocked);
TestImpl(r8, Locked);
TestImpl(r8, NotLocked);
TestImpl(r10, Locked);
TestImpl(r10, NotLocked);
TestImpl(r11, Locked);
TestImpl(r11, NotLocked);
TestImpl(r12, Locked);
TestImpl(r12, NotLocked);
TestImpl(r13, Locked);
TestImpl(r13, NotLocked);
TestImpl(r14, Locked);
TestImpl(r14, NotLocked);
TestImpl(r15, Locked);
TestImpl(r15, NotLocked);
#undef TestImpl
#undef TestImplValue
#undef TestImplAddrReg
}
TEST_F(AssemblerX8664LowLevelTest, Cmpxchg) {
static constexpr bool NotLocked = false;
static constexpr bool Locked = true;
// Ensures that cmpxchg emits a lock prefix accordingly.
{
__ cmpxchg(IceType_i8, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
NotLocked);
static constexpr uint8_t ByteCountNotLocked8 = 10;
ASSERT_EQ(ByteCountNotLocked8, codeBytesSize());
ASSERT_TRUE(verifyBytes<ByteCountNotLocked8>(codeBytes(), 0x67, 0x44, 0x0F,
0xB0, 0x34, 0x25, 0x00, 0xFF,
0x01, 0x00));
reset();
__ cmpxchg(IceType_i8, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
Locked);
static constexpr uint8_t ByteCountLocked8 = 1 + ByteCountNotLocked8;
ASSERT_EQ(ByteCountLocked8, codeBytesSize());
ASSERT_TRUE(verifyBytes<ByteCountLocked8>(codeBytes(), 0xF0, 0x67, 0x44,
0x0F, 0xB0, 0x34, 0x25, 0x00,
0xFF, 0x01, 0x00));
reset();
}
{
__ cmpxchg(IceType_i16, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
NotLocked);
static constexpr uint8_t ByteCountNotLocked16 = 11;
ASSERT_EQ(ByteCountNotLocked16, codeBytesSize());
ASSERT_TRUE(verifyBytes<ByteCountNotLocked16>(codeBytes(), 0x66, 0x67, 0x44,
0x0F, 0xB1, 0x34, 0x25, 0x00,
0xFF, 0x01, 0x00));
reset();
__ cmpxchg(IceType_i16, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
Locked);
static constexpr uint8_t ByteCountLocked16 = 1 + ByteCountNotLocked16;
ASSERT_EQ(ByteCountLocked16, codeBytesSize());
ASSERT_TRUE(verifyBytes<ByteCountLocked16>(codeBytes(), 0x66, 0xF0, 0x67,
0x44, 0x0F, 0xB1, 0x34, 0x25,
0x00, 0xFF, 0x01, 0x00));
reset();
}
{
__ cmpxchg(IceType_i32, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
NotLocked);
static constexpr uint8_t ByteCountNotLocked32 = 10;
ASSERT_EQ(ByteCountNotLocked32, codeBytesSize());
ASSERT_TRUE(verifyBytes<ByteCountNotLocked32>(codeBytes(), 0x67, 0x44, 0x0F,
0xB1, 0x34, 0x25, 0x00, 0xFF,
0x01, 0x00));
reset();
__ cmpxchg(IceType_i32, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
Locked);
static constexpr uint8_t ByteCountLocked32 = 1 + ByteCountNotLocked32;
ASSERT_EQ(ByteCountLocked32, codeBytesSize());
ASSERT_TRUE(verifyBytes<ByteCountLocked32>(codeBytes(), 0xF0, 0x67, 0x44,
0x0F, 0xB1, 0x34, 0x25, 0x00,
0xFF, 0x01, 0x00));
reset();
}
}
} // end of anonymous namespace
} // end of namespace Test
} // end of namespace X8664
} // end of namespace Ice