| //===- 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 |
