Skip to content

Commit b3e8670

Browse files
arsenmarsenm
committed
GlobalISel: Improve gtest usage
Don't unnecessarily use ASSERT_*, and print the MachineFunction on failure. llvm-svn: 353072
1 parent fd3e7a9 commit b3e8670

File tree

9 files changed

+188
-169
lines changed

9 files changed

+188
-169
lines changed

‎llvm/unittests/CodeGen/GlobalISel/CMakeLists.txt

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -14,5 +14,6 @@ add_llvm_unittest(GlobalISelTests
1414
LegalizerHelperTest.cpp
1515
LegalizerInfoTest.cpp
1616
MachineIRBuilderTest.cpp
17+
GISelMITest.cpp
1718
PatternMatchTest.cpp
1819
)

‎llvm/unittests/CodeGen/GlobalISel/CSETest.cpp

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -29,35 +29,35 @@ TEST_F(GISelMITest, TestCSE) {
2929
unsigned AddReg = MRI->createGenericVirtualRegister(s16);
3030
auto MIBAddCopy =
3131
CSEB.buildInstr(TargetOpcode::G_ADD, {AddReg}, {MIBInput, MIBInput});
32-
ASSERT_EQ(MIBAddCopy->getOpcode(), TargetOpcode::COPY);
32+
EXPECT_EQ(MIBAddCopy->getOpcode(), TargetOpcode::COPY);
3333
auto MIBAdd2 =
3434
CSEB.buildInstr(TargetOpcode::G_ADD, {s16}, {MIBInput, MIBInput});
35-
ASSERT_TRUE(&*MIBAdd == &*MIBAdd2);
35+
EXPECT_TRUE(&*MIBAdd == &*MIBAdd2);
3636
auto MIBAdd4 =
3737
CSEB.buildInstr(TargetOpcode::G_ADD, {s16}, {MIBInput, MIBInput});
38-
ASSERT_TRUE(&*MIBAdd == &*MIBAdd4);
38+
EXPECT_TRUE(&*MIBAdd == &*MIBAdd4);
3939
auto MIBAdd5 =
4040
CSEB.buildInstr(TargetOpcode::G_ADD, {s16}, {MIBInput, MIBInput1});
41-
ASSERT_TRUE(&*MIBAdd != &*MIBAdd5);
41+
EXPECT_TRUE(&*MIBAdd != &*MIBAdd5);
4242

4343
// Try building G_CONSTANTS.
4444
auto MIBCst = CSEB.buildConstant(s32, 0);
4545
auto MIBCst1 = CSEB.buildConstant(s32, 0);
46-
ASSERT_TRUE(&*MIBCst == &*MIBCst1);
46+
EXPECT_TRUE(&*MIBCst == &*MIBCst1);
4747
// Try the CFing of BinaryOps.
4848
auto MIBCF1 = CSEB.buildInstr(TargetOpcode::G_ADD, {s32}, {MIBCst, MIBCst});
49-
ASSERT_TRUE(&*MIBCF1 == &*MIBCst);
49+
EXPECT_TRUE(&*MIBCF1 == &*MIBCst);
5050

5151
// Try out building FCONSTANTs.
5252
auto MIBFP0 = CSEB.buildFConstant(s32, 1.0);
5353
auto MIBFP0_1 = CSEB.buildFConstant(s32, 1.0);
54-
ASSERT_TRUE(&*MIBFP0 == &*MIBFP0_1);
54+
EXPECT_TRUE(&*MIBFP0 == &*MIBFP0_1);
5555
CSEInfo.print();
5656

5757
// Check G_UNMERGE_VALUES
5858
auto MIBUnmerge = CSEB.buildUnmerge({s32, s32}, Copies[0]);
5959
auto MIBUnmerge2 = CSEB.buildUnmerge({s32, s32}, Copies[0]);
60-
ASSERT_TRUE(&*MIBUnmerge == &*MIBUnmerge2);
60+
EXPECT_TRUE(&*MIBUnmerge == &*MIBUnmerge2);
6161
}
6262

6363
TEST_F(GISelMITest, TestCSEConstantConfig) {
@@ -77,10 +77,10 @@ TEST_F(GISelMITest, TestCSEConstantConfig) {
7777
auto MIBAdd1 =
7878
CSEB.buildInstr(TargetOpcode::G_ADD, {s16}, {MIBInput, MIBInput});
7979
// We should CSE constants only. Adds should not be CSEd.
80-
ASSERT_TRUE(MIBAdd1->getOpcode() != TargetOpcode::COPY);
81-
ASSERT_TRUE(&*MIBAdd1 != &*MIBAdd);
80+
EXPECT_TRUE(MIBAdd1->getOpcode() != TargetOpcode::COPY);
81+
EXPECT_TRUE(&*MIBAdd1 != &*MIBAdd);
8282
// We should CSE constant.
8383
auto MIBZeroTmp = CSEB.buildConstant(s16, 0);
84-
ASSERT_TRUE(&*MIBZero == &*MIBZeroTmp);
84+
EXPECT_TRUE(&*MIBZero == &*MIBZeroTmp);
8585
}
8686
} // namespace

‎llvm/unittests/CodeGen/GlobalISel/GISelMITest.cpp

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
//===------------------------------------------------------------*- C++ -*-===//
2+
//
3+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4+
// See https://llvm.org/LICENSE.txt for license information.
5+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6+
//
7+
//===----------------------------------------------------------------------===//
8+
9+
#include "GISelMITest.h"
10+
11+
namespace llvm {
12+
std::ostream &
13+
operator<<(std::ostream &OS, const LLT Ty) {
14+
std::string Repr;
15+
raw_string_ostream SS{Repr};
16+
Ty.print(SS);
17+
OS << SS.str();
18+
return OS;
19+
}
20+
21+
std::ostream &
22+
operator<<(std::ostream &OS, const MachineFunction &MF) {
23+
std::string Repr;
24+
raw_string_ostream SS{Repr};
25+
MF.print(SS);
26+
OS << SS.str();
27+
return OS;
28+
}
29+
30+
}

‎llvm/unittests/CodeGen/GlobalISel/GISelMITest.h

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -43,6 +43,15 @@ static inline void initLLVM() {
4343
initializeCodeGen(*Registry);
4444
}
4545

46+
// Define a printers to help debugging when things go wrong.
47+
namespace llvm {
48+
std::ostream &
49+
operator<<(std::ostream &OS, const LLT Ty);
50+
51+
std::ostream &
52+
operator<<(std::ostream &OS, const MachineFunction &MF);
53+
}
54+
4655
/// Create a TargetMachine. As we lack a dedicated always available target for
4756
/// unittests, we go for "AArch64".
4857
static std::unique_ptr<LLVMTargetMachine> createTargetMachine() {

‎llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp

Lines changed: 28 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -36,7 +36,7 @@ TEST_F(GISelMITest, LowerBitCountingCTTZ0) {
3636
DummyGISelObserver Observer;
3737
LegalizerHelper Helper(*MF, Info, Observer, B);
3838
// Perform Legalization
39-
ASSERT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
39+
EXPECT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
4040
LegalizerHelper::LegalizeResult::Legalized);
4141

4242
auto CheckStr = R"(
@@ -48,7 +48,7 @@ TEST_F(GISelMITest, LowerBitCountingCTTZ0) {
4848
)";
4949

5050
// Check
51-
ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
51+
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
5252
}
5353

5454
// CTTZ expansion in terms of CTLZ
@@ -67,7 +67,7 @@ TEST_F(GISelMITest, LowerBitCountingCTTZ1) {
6767
DummyGISelObserver Observer;
6868
LegalizerHelper Helper(*MF, Info, Observer, B);
6969
// Perform Legalization
70-
ASSERT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
70+
EXPECT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
7171
LegalizerHelper::LegalizeResult::Legalized);
7272

7373
auto CheckStr = R"(
@@ -81,7 +81,7 @@ TEST_F(GISelMITest, LowerBitCountingCTTZ1) {
8181
)";
8282

8383
// Check
84-
ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
84+
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
8585
}
8686

8787
// CTTZ expansion in terms of CTPOP
@@ -99,7 +99,7 @@ TEST_F(GISelMITest, LowerBitCountingCTTZ2) {
9999
AInfo Info(MF->getSubtarget());
100100
DummyGISelObserver Observer;
101101
LegalizerHelper Helper(*MF, Info, Observer, B);
102-
ASSERT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
102+
EXPECT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
103103
LegalizerHelper::LegalizeResult::Legalized);
104104

105105
auto CheckStr = R"(
@@ -111,7 +111,7 @@ TEST_F(GISelMITest, LowerBitCountingCTTZ2) {
111111
)";
112112

113113
// Check
114-
ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
114+
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
115115
}
116116

117117
// CTTZ_ZERO_UNDEF expansion in terms of CTTZ
@@ -129,15 +129,15 @@ TEST_F(GISelMITest, LowerBitCountingCTTZ3) {
129129
AInfo Info(MF->getSubtarget());
130130
DummyGISelObserver Observer;
131131
LegalizerHelper Helper(*MF, Info, Observer, B);
132-
ASSERT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
132+
EXPECT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
133133
LegalizerHelper::LegalizeResult::Legalized);
134134

135135
auto CheckStr = R"(
136136
CHECK: CTTZ
137137
)";
138138

139139
// Check
140-
ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
140+
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
141141
}
142142

143143
// CTLZ expansion in terms of CTLZ_ZERO_UNDEF
@@ -155,7 +155,7 @@ TEST_F(GISelMITest, LowerBitCountingCTLZ0) {
155155
AInfo Info(MF->getSubtarget());
156156
DummyGISelObserver Observer;
157157
LegalizerHelper Helper(*MF, Info, Observer, B);
158-
ASSERT_TRUE(Helper.lower(*MIBCTLZ, 0, LLT::scalar(64)) ==
158+
EXPECT_TRUE(Helper.lower(*MIBCTLZ, 0, LLT::scalar(64)) ==
159159
LegalizerHelper::LegalizeResult::Legalized);
160160

161161
auto CheckStr = R"(
@@ -167,7 +167,7 @@ TEST_F(GISelMITest, LowerBitCountingCTLZ0) {
167167
)";
168168

169169
// Check
170-
ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
170+
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
171171
}
172172

173173
// CTLZ expansion in terms of CTLZ_ZERO_UNDEF if the latter is a libcall
@@ -185,7 +185,7 @@ TEST_F(GISelMITest, LowerBitCountingCTLZLibcall) {
185185
AInfo Info(MF->getSubtarget());
186186
DummyGISelObserver Observer;
187187
LegalizerHelper Helper(*MF, Info, Observer, B);
188-
ASSERT_TRUE(Helper.lower(*MIBCTLZ, 0, LLT::scalar(64)) ==
188+
EXPECT_TRUE(Helper.lower(*MIBCTLZ, 0, LLT::scalar(64)) ==
189189
LegalizerHelper::LegalizeResult::Legalized);
190190

191191
auto CheckStr = R"(
@@ -197,7 +197,7 @@ TEST_F(GISelMITest, LowerBitCountingCTLZLibcall) {
197197
)";
198198

199199
// Check
200-
ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
200+
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
201201
}
202202

203203
// CTLZ expansion
@@ -217,7 +217,7 @@ TEST_F(GISelMITest, LowerBitCountingCTLZ1) {
217217
AInfo Info(MF->getSubtarget());
218218
DummyGISelObserver Observer;
219219
LegalizerHelper Helper(*MF, Info, Observer, B);
220-
ASSERT_TRUE(Helper.lower(*MIBCTLZ, 0, s8) ==
220+
EXPECT_TRUE(Helper.lower(*MIBCTLZ, 0, s8) ==
221221
LegalizerHelper::LegalizeResult::Legalized);
222222

223223
auto CheckStr = R"(
@@ -237,7 +237,7 @@ TEST_F(GISelMITest, LowerBitCountingCTLZ1) {
237237
)";
238238

239239
// Check
240-
ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
240+
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
241241
}
242242

243243
// CTLZ widening.
@@ -258,7 +258,7 @@ TEST_F(GISelMITest, WidenBitCountingCTLZ) {
258258
AInfo Info(MF->getSubtarget());
259259
DummyGISelObserver Observer;
260260
LegalizerHelper Helper(*MF, Info, Observer, B);
261-
ASSERT_TRUE(Helper.widenScalar(*MIBCTLZ, 1, s16) ==
261+
EXPECT_TRUE(Helper.widenScalar(*MIBCTLZ, 1, s16) ==
262262
LegalizerHelper::LegalizeResult::Legalized);
263263

264264
auto CheckStr = R"(
@@ -271,7 +271,7 @@ TEST_F(GISelMITest, WidenBitCountingCTLZ) {
271271
)";
272272

273273
// Check
274-
ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
274+
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
275275
}
276276

277277
// CTLZ_ZERO_UNDEF widening.
@@ -293,7 +293,7 @@ TEST_F(GISelMITest, WidenBitCountingCTLZZeroUndef) {
293293
AInfo Info(MF->getSubtarget());
294294
DummyGISelObserver Observer;
295295
LegalizerHelper Helper(*MF, Info, Observer, B);
296-
ASSERT_TRUE(Helper.widenScalar(*MIBCTLZ_ZU, 1, s16) ==
296+
EXPECT_TRUE(Helper.widenScalar(*MIBCTLZ_ZU, 1, s16) ==
297297
LegalizerHelper::LegalizeResult::Legalized);
298298

299299
auto CheckStr = R"(
@@ -306,7 +306,7 @@ TEST_F(GISelMITest, WidenBitCountingCTLZZeroUndef) {
306306
)";
307307

308308
// Check
309-
ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
309+
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
310310
}
311311

312312
// CTPOP widening.
@@ -327,7 +327,7 @@ TEST_F(GISelMITest, WidenBitCountingCTPOP) {
327327
AInfo Info(MF->getSubtarget());
328328
DummyGISelObserver Observer;
329329
LegalizerHelper Helper(*MF, Info, Observer, B);
330-
ASSERT_TRUE(Helper.widenScalar(*MIBCTPOP, 1, s16) ==
330+
EXPECT_TRUE(Helper.widenScalar(*MIBCTPOP, 1, s16) ==
331331
LegalizerHelper::LegalizeResult::Legalized);
332332

333333
auto CheckStr = R"(
@@ -338,7 +338,7 @@ TEST_F(GISelMITest, WidenBitCountingCTPOP) {
338338
)";
339339

340340
// Check
341-
ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
341+
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
342342
}
343343

344344
// CTTZ_ZERO_UNDEF widening.
@@ -360,7 +360,7 @@ TEST_F(GISelMITest, WidenBitCountingCTTZ_ZERO_UNDEF) {
360360
AInfo Info(MF->getSubtarget());
361361
DummyGISelObserver Observer;
362362
LegalizerHelper Helper(*MF, Info, Observer, B);
363-
ASSERT_TRUE(Helper.widenScalar(*MIBCTTZ_ZERO_UNDEF, 1, s16) ==
363+
EXPECT_TRUE(Helper.widenScalar(*MIBCTTZ_ZERO_UNDEF, 1, s16) ==
364364
LegalizerHelper::LegalizeResult::Legalized);
365365

366366
auto CheckStr = R"(
@@ -371,7 +371,7 @@ TEST_F(GISelMITest, WidenBitCountingCTTZ_ZERO_UNDEF) {
371371
)";
372372

373373
// Check
374-
ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
374+
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
375375
}
376376

377377
// CTTZ widening.
@@ -392,7 +392,7 @@ TEST_F(GISelMITest, WidenBitCountingCTTZ) {
392392
AInfo Info(MF->getSubtarget());
393393
DummyGISelObserver Observer;
394394
LegalizerHelper Helper(*MF, Info, Observer, B);
395-
ASSERT_TRUE(Helper.widenScalar(*MIBCTTZ, 1, s16) ==
395+
EXPECT_TRUE(Helper.widenScalar(*MIBCTTZ, 1, s16) ==
396396
LegalizerHelper::LegalizeResult::Legalized);
397397

398398
auto CheckStr = R"(
@@ -405,7 +405,7 @@ TEST_F(GISelMITest, WidenBitCountingCTTZ) {
405405
)";
406406

407407
// Check
408-
ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
408+
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
409409
}
410410
// UADDO widening.
411411
TEST_F(GISelMITest, WidenUADDO) {
@@ -427,7 +427,7 @@ TEST_F(GISelMITest, WidenUADDO) {
427427
AInfo Info(MF->getSubtarget());
428428
DummyGISelObserver Observer;
429429
LegalizerHelper Helper(*MF, Info, Observer, B);
430-
ASSERT_TRUE(Helper.widenScalar(*MIBUAddO, 0, s16) ==
430+
EXPECT_TRUE(Helper.widenScalar(*MIBUAddO, 0, s16) ==
431431
LegalizerHelper::LegalizeResult::Legalized);
432432

433433
auto CheckStr = R"(
@@ -442,7 +442,7 @@ TEST_F(GISelMITest, WidenUADDO) {
442442
)";
443443

444444
// Check
445-
ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
445+
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
446446
}
447447

448448
// USUBO widening.
@@ -465,7 +465,7 @@ TEST_F(GISelMITest, WidenUSUBO) {
465465
AInfo Info(MF->getSubtarget());
466466
DummyGISelObserver Observer;
467467
LegalizerHelper Helper(*MF, Info, Observer, B);
468-
ASSERT_TRUE(Helper.widenScalar(*MIBUSUBO, 0, s16) ==
468+
EXPECT_TRUE(Helper.widenScalar(*MIBUSUBO, 0, s16) ==
469469
LegalizerHelper::LegalizeResult::Legalized);
470470

471471
auto CheckStr = R"(
@@ -480,6 +480,6 @@ TEST_F(GISelMITest, WidenUSUBO) {
480480
)";
481481

482482
// Check
483-
ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
483+
EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
484484
}
485485
} // namespace

0 commit comments

Comments
 (0)