You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
309 lines
16 KiB
309 lines
16 KiB
//===- subzero/unittest/AssemblerX8664/ControlFlow.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(AssemblerX8664Test, J) {
|
|
#define TestJ(C, Near, Dest, Src0, Value0, Src1, Value1) \
|
|
do { \
|
|
static constexpr char TestString[] = \
|
|
"(" #C ", " #Near ", " #Dest ", " #Src0 ", " #Value0 ", " #Src1 \
|
|
", " #Value1 ")"; \
|
|
const bool NearJmp = AssemblerX8664::k##Near##Jump; \
|
|
Label ShouldBeTaken; \
|
|
__ mov(IceType_i32, Encoded_GPR_##Src0(), Immediate(Value0)); \
|
|
__ mov(IceType_i32, Encoded_GPR_##Src1(), Immediate(Value1)); \
|
|
__ mov(IceType_i32, Encoded_GPR_##Dest(), Immediate(0xBEEF)); \
|
|
__ cmp(IceType_i32, Encoded_GPR_##Src0(), Encoded_GPR_##Src1()); \
|
|
__ j(Cond::Br_##C, &ShouldBeTaken, NearJmp); \
|
|
__ mov(IceType_i32, Encoded_GPR_##Dest(), Immediate(0xC0FFEE)); \
|
|
__ bind(&ShouldBeTaken); \
|
|
AssembledTest test = assemble(); \
|
|
test.run(); \
|
|
ASSERT_EQ(Value0, test.Src0()) << TestString; \
|
|
ASSERT_EQ(Value1, test.Src1()) << TestString; \
|
|
ASSERT_EQ(0xBEEFul, test.Dest()) << TestString; \
|
|
reset(); \
|
|
} while (0)
|
|
|
|
#define TestImpl(Dst, Src0, Src1) \
|
|
do { \
|
|
TestJ(o, Near, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(o, Far, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(no, Near, Dst, Src0, 0x1ul, Src1, 0x1ul); \
|
|
TestJ(no, Far, Dst, Src0, 0x1ul, Src1, 0x1ul); \
|
|
TestJ(b, Near, Dst, Src0, 0x1ul, Src1, 0x80000000ul); \
|
|
TestJ(b, Far, Dst, Src0, 0x1ul, Src1, 0x80000000ul); \
|
|
TestJ(ae, Near, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(ae, Far, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(e, Near, Dst, Src0, 0x80000000ul, Src1, 0x80000000ul); \
|
|
TestJ(e, Far, Dst, Src0, 0x80000000ul, Src1, 0x80000000ul); \
|
|
TestJ(ne, Near, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(ne, Far, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(be, Near, Dst, Src0, 0x1ul, Src1, 0x80000000ul); \
|
|
TestJ(be, Far, Dst, Src0, 0x1ul, Src1, 0x80000000ul); \
|
|
TestJ(a, Near, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(a, Far, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(s, Near, Dst, Src0, 0x1ul, Src1, 0x80000000ul); \
|
|
TestJ(s, Far, Dst, Src0, 0x1ul, Src1, 0x80000000ul); \
|
|
TestJ(ns, Near, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(ns, Far, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(p, Near, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(p, Far, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(np, Near, Dst, Src0, 0x1ul, Src1, 0x80000000ul); \
|
|
TestJ(np, Far, Dst, Src0, 0x1ul, Src1, 0x80000000ul); \
|
|
TestJ(l, Near, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(l, Far, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(ge, Near, Dst, Src0, 0x1ul, Src1, 0x80000000ul); \
|
|
TestJ(ge, Far, Dst, Src0, 0x1ul, Src1, 0x80000000ul); \
|
|
TestJ(le, Near, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(le, Far, Dst, Src0, 0x80000000ul, Src1, 0x1ul); \
|
|
TestJ(g, Near, Dst, Src0, 0x1ul, Src1, 0x80000000ul); \
|
|
TestJ(g, Far, Dst, Src0, 0x1ul, Src1, 0x80000000ul); \
|
|
} while (0)
|
|
|
|
TestImpl(r1, r2, r3);
|
|
TestImpl(r2, r3, r4);
|
|
TestImpl(r3, r4, r5);
|
|
TestImpl(r4, r5, r6);
|
|
TestImpl(r5, r6, r7);
|
|
TestImpl(r6, r7, r8);
|
|
TestImpl(r7, r8, r10);
|
|
TestImpl(r8, r10, r11);
|
|
TestImpl(r10, r11, r12);
|
|
TestImpl(r11, r12, r13);
|
|
TestImpl(r12, r13, r14);
|
|
TestImpl(r13, r14, r15);
|
|
TestImpl(r14, r15, r1);
|
|
TestImpl(r15, r1, r2);
|
|
|
|
#undef TestImpl
|
|
#undef TestJ
|
|
}
|
|
|
|
TEST_F(AssemblerX8664Test, CallImm) {
|
|
__ call(Immediate(16));
|
|
__ hlt();
|
|
__ hlt();
|
|
__ hlt();
|
|
__ hlt();
|
|
__ hlt();
|
|
__ hlt();
|
|
__ hlt();
|
|
__ hlt();
|
|
__ hlt();
|
|
__ hlt();
|
|
__ hlt();
|
|
__ hlt();
|
|
__ mov(IceType_i32, GPRRegister::Encoded_Reg_eax, Immediate(0xf00f));
|
|
__ popl(GPRRegister::Encoded_Reg_ebx);
|
|
|
|
AssembledTest test = assemble();
|
|
|
|
test.run();
|
|
|
|
EXPECT_EQ(0xF00Fu, test.eax());
|
|
}
|
|
|
|
TEST_F(AssemblerX8664Test, CallReg) {
|
|
#define TestImpl(Dst, Src) \
|
|
do { \
|
|
__ call(Immediate(16)); \
|
|
int CallTargetAddr = codeBytesSize() + 12; \
|
|
__ popl(Encoded_GPR_##Dst()); \
|
|
__ pushl(Encoded_GPR_##Dst()); \
|
|
__ ret(); \
|
|
for (int I = codeBytesSize(); I < CallTargetAddr; ++I) { \
|
|
__ hlt(); \
|
|
} \
|
|
__ popl(Encoded_GPR_##Src()); \
|
|
__ call(Encoded_GPR_##Src()); \
|
|
\
|
|
AssembledTest test = assemble(); \
|
|
\
|
|
test.run(); \
|
|
\
|
|
ASSERT_LE(15u, test.Dst() - test.Src()) << "(" #Dst ", " #Src ")"; \
|
|
reset(); \
|
|
} while (0)
|
|
|
|
TestImpl(r1, r2);
|
|
TestImpl(r2, r3);
|
|
TestImpl(r3, r4);
|
|
TestImpl(r4, r5);
|
|
TestImpl(r5, r6);
|
|
TestImpl(r6, r7);
|
|
TestImpl(r7, r8);
|
|
TestImpl(r8, r10);
|
|
TestImpl(r10, r11);
|
|
TestImpl(r11, r12);
|
|
TestImpl(r12, r13);
|
|
TestImpl(r13, r14);
|
|
TestImpl(r14, r15);
|
|
TestImpl(r15, r1);
|
|
|
|
#undef TestImpl
|
|
}
|
|
|
|
TEST_F(AssemblerX8664Test, CallAddr) {
|
|
#define TestImpl(Dst, Src) \
|
|
do { \
|
|
const uint32_t T0 = allocateQword(); \
|
|
const uint64_t V0 = 0xA0C0FFEEBEEFFEEFull; \
|
|
const uint32_t T1 = allocateDword(); \
|
|
__ call(Immediate(16)); \
|
|
int CallTargetAddr = codeBytesSize() + 12; \
|
|
__ mov(IceType_i8, Encoded_GPR_##Dst##l(), Immediate(0xf4)); \
|
|
__ ret(); \
|
|
for (int I = codeBytesSize(); I < CallTargetAddr; ++I) { \
|
|
__ hlt(); \
|
|
} \
|
|
__ mov(IceType_i64, Encoded_GPR_##Dst##q(), dwordAddress(T0)); \
|
|
__ popl(Encoded_GPR_##Src##q()); \
|
|
__ mov(IceType_i32, dwordAddress(T1), Encoded_GPR_##Src##d()); \
|
|
__ call(dwordAddress(T1)); \
|
|
\
|
|
AssembledTest test = assemble(); \
|
|
test.setQwordTo(T0, V0); \
|
|
test.run(); \
|
|
\
|
|
ASSERT_EQ(0xA0C0FFEEBEEFFEF4ull, test.Dst##q()) << "(" #Dst ", " #Src ")"; \
|
|
reset(); \
|
|
} while (0)
|
|
|
|
TestImpl(r1, r2);
|
|
TestImpl(r2, r3);
|
|
TestImpl(r3, r4);
|
|
TestImpl(r4, r5);
|
|
TestImpl(r5, r6);
|
|
TestImpl(r6, r7);
|
|
TestImpl(r7, r8);
|
|
TestImpl(r8, r10);
|
|
TestImpl(r10, r11);
|
|
TestImpl(r11, r12);
|
|
TestImpl(r12, r13);
|
|
TestImpl(r13, r14);
|
|
TestImpl(r14, r15);
|
|
TestImpl(r15, r1);
|
|
|
|
#undef TestImpl
|
|
}
|
|
|
|
TEST_F(AssemblerX8664Test, Jmp) {
|
|
// TestImplReg uses jmp(Label), so jmp(Label) needs to be tested before it.
|
|
#define TestImplAddr(Near) \
|
|
do { \
|
|
Label ForwardJmp; \
|
|
Label BackwardJmp; \
|
|
Label Done; \
|
|
\
|
|
__ jmp(&ForwardJmp, AssemblerX8664::k##Near##Jump); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ bind(&BackwardJmp); \
|
|
__ jmp(&Done, AssemblerX8664::k##Near##Jump); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ bind(&ForwardJmp); \
|
|
__ jmp(&BackwardJmp, AssemblerX8664::k##NearJump); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ bind(&Done); \
|
|
} while (0)
|
|
|
|
#define TestImplReg(Dst) \
|
|
do { \
|
|
__ call(Immediate(16)); \
|
|
Label Done; \
|
|
__ jmp(&Done, AssemblerX8664::kNearJump); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ popl(Encoded_GPR_##Dst()); \
|
|
__ jmp(Encoded_GPR_##Dst()); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ hlt(); \
|
|
__ bind(&Done); \
|
|
\
|
|
AssembledTest test = assemble(); \
|
|
test.run(); \
|
|
\
|
|
reset(); \
|
|
} while (0)
|
|
|
|
TestImplAddr(Near);
|
|
TestImplAddr(Far);
|
|
|
|
TestImplReg(r1);
|
|
TestImplReg(r2);
|
|
TestImplReg(r3);
|
|
TestImplReg(r4);
|
|
TestImplReg(r5);
|
|
TestImplReg(r6);
|
|
TestImplReg(r7);
|
|
TestImplReg(r8);
|
|
TestImplReg(r10);
|
|
TestImplReg(r11);
|
|
TestImplReg(r12);
|
|
TestImplReg(r13);
|
|
TestImplReg(r14);
|
|
TestImplReg(r15);
|
|
|
|
#undef TestImplReg
|
|
#undef TestImplAddr
|
|
}
|
|
|
|
} // end of anonymous namespace
|
|
} // end of namespace Test
|
|
} // end of namespace X8664
|
|
} // end of namespace Ice
|