[GISel]: Add support for CSEing continuously during GISel passes.
https://reviews.llvm.org/D52803
This patch adds support to continuously CSE instructions during
each of the GISel passes. It consists of a GISelCSEInfo analysis pass
that can be used by the CSEMIRBuilder.
llvm-svn: 351283
diff --git a/llvm/unittests/CodeGen/GlobalISel/CMakeLists.txt b/llvm/unittests/CodeGen/GlobalISel/CMakeLists.txt
index 60566cb..32bbd56 100644
--- a/llvm/unittests/CodeGen/GlobalISel/CMakeLists.txt
+++ b/llvm/unittests/CodeGen/GlobalISel/CMakeLists.txt
@@ -13,4 +13,5 @@
LegalizerInfoTest.cpp
PatternMatchTest.cpp
LegalizerHelperTest.cpp
+ CSETest.cpp
)
diff --git a/llvm/unittests/CodeGen/GlobalISel/CSETest.cpp b/llvm/unittests/CodeGen/GlobalISel/CSETest.cpp
new file mode 100644
index 0000000..c6bbd8b
--- /dev/null
+++ b/llvm/unittests/CodeGen/GlobalISel/CSETest.cpp
@@ -0,0 +1,87 @@
+//===- CSETest.cpp -----------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "GISelMITest.h"
+#include "llvm/CodeGen/GlobalISel/CSEMIRBuilder.h"
+
+namespace {
+
+TEST_F(GISelMITest, TestCSE) {
+ if (!TM)
+ return;
+
+ LLT s16{LLT::scalar(16)};
+ LLT s32{LLT::scalar(32)};
+ auto MIBInput = B.buildInstr(TargetOpcode::G_TRUNC, {s16}, {Copies[0]});
+ auto MIBInput1 = B.buildInstr(TargetOpcode::G_TRUNC, {s16}, {Copies[1]});
+ auto MIBAdd = B.buildInstr(TargetOpcode::G_ADD, {s16}, {MIBInput, MIBInput});
+ GISelCSEInfo CSEInfo;
+ CSEInfo.setCSEConfig(make_unique<CSEConfig>());
+ CSEInfo.analyze(*MF);
+ B.setCSEInfo(&CSEInfo);
+ CSEMIRBuilder CSEB(B.getState());
+ CSEB.setInsertPt(*EntryMBB, EntryMBB->begin());
+ unsigned AddReg = MRI->createGenericVirtualRegister(s16);
+ auto MIBAddCopy =
+ CSEB.buildInstr(TargetOpcode::G_ADD, {AddReg}, {MIBInput, MIBInput});
+ ASSERT_EQ(MIBAddCopy->getOpcode(), TargetOpcode::COPY);
+ auto MIBAdd2 =
+ CSEB.buildInstr(TargetOpcode::G_ADD, {s16}, {MIBInput, MIBInput});
+ ASSERT_TRUE(&*MIBAdd == &*MIBAdd2);
+ auto MIBAdd4 =
+ CSEB.buildInstr(TargetOpcode::G_ADD, {s16}, {MIBInput, MIBInput});
+ ASSERT_TRUE(&*MIBAdd == &*MIBAdd4);
+ auto MIBAdd5 =
+ CSEB.buildInstr(TargetOpcode::G_ADD, {s16}, {MIBInput, MIBInput1});
+ ASSERT_TRUE(&*MIBAdd != &*MIBAdd5);
+
+ // Try building G_CONSTANTS.
+ auto MIBCst = CSEB.buildConstant(s32, 0);
+ auto MIBCst1 = CSEB.buildConstant(s32, 0);
+ ASSERT_TRUE(&*MIBCst == &*MIBCst1);
+ // Try the CFing of BinaryOps.
+ auto MIBCF1 = CSEB.buildInstr(TargetOpcode::G_ADD, {s32}, {MIBCst, MIBCst});
+ ASSERT_TRUE(&*MIBCF1 == &*MIBCst);
+
+ // Try out building FCONSTANTs.
+ auto MIBFP0 = CSEB.buildFConstant(s32, 1.0);
+ auto MIBFP0_1 = CSEB.buildFConstant(s32, 1.0);
+ ASSERT_TRUE(&*MIBFP0 == &*MIBFP0_1);
+ CSEInfo.print();
+
+ // Check G_UNMERGE_VALUES
+ auto MIBUnmerge = CSEB.buildUnmerge({s32, s32}, Copies[0]);
+ auto MIBUnmerge2 = CSEB.buildUnmerge({s32, s32}, Copies[0]);
+ ASSERT_TRUE(&*MIBUnmerge == &*MIBUnmerge2);
+}
+
+TEST_F(GISelMITest, TestCSEConstantConfig) {
+ if (!TM)
+ return;
+
+ LLT s16{LLT::scalar(16)};
+ auto MIBInput = B.buildInstr(TargetOpcode::G_TRUNC, {s16}, {Copies[0]});
+ auto MIBAdd = B.buildInstr(TargetOpcode::G_ADD, {s16}, {MIBInput, MIBInput});
+ auto MIBZero = B.buildConstant(s16, 0);
+ GISelCSEInfo CSEInfo;
+ CSEInfo.setCSEConfig(make_unique<CSEConfigConstantOnly>());
+ CSEInfo.analyze(*MF);
+ B.setCSEInfo(&CSEInfo);
+ CSEMIRBuilder CSEB(B.getState());
+ CSEB.setInsertPt(*EntryMBB, EntryMBB->begin());
+ auto MIBAdd1 =
+ CSEB.buildInstr(TargetOpcode::G_ADD, {s16}, {MIBInput, MIBInput});
+ // We should CSE constants only. Adds should not be CSEd.
+ ASSERT_TRUE(MIBAdd1->getOpcode() != TargetOpcode::COPY);
+ ASSERT_TRUE(&*MIBAdd1 != &*MIBAdd);
+ // We should CSE constant.
+ auto MIBZeroTmp = CSEB.buildConstant(s16, 0);
+ ASSERT_TRUE(&*MIBZero == &*MIBZeroTmp);
+}
+} // namespace
diff --git a/llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.h b/llvm/unittests/CodeGen/GlobalISel/GISelMITest.h
similarity index 85%
rename from llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.h
rename to llvm/unittests/CodeGen/GlobalISel/GISelMITest.h
index 0a171a7..91b8e81 100644
--- a/llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.h
+++ b/llvm/unittests/CodeGen/GlobalISel/GISelMITest.h
@@ -1,4 +1,4 @@
-//===- LegalizerHelperTest.h
+//===- GISelMITest.h
//-----------------------------------------------===//
//
// The LLVM Compiler Infrastructure
@@ -7,6 +7,8 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
+#ifndef LLVM_UNITTEST_CODEGEN_GLOBALISEL_GISELMI_H
+#define LLVM_UNITTEST_CODEGEN_GLOBALISEL_GISELMI_H
#include "llvm/CodeGen/GlobalISel/GISelChangeObserver.h"
#include "llvm/CodeGen/GlobalISel/LegalizerHelper.h"
@@ -32,7 +34,7 @@
using namespace llvm;
using namespace MIPatternMatch;
-void initLLVM() {
+static inline void initLLVM() {
InitializeAllTargets();
InitializeAllTargetMCs();
InitializeAllAsmPrinters();
@@ -45,7 +47,7 @@
/// Create a TargetMachine. As we lack a dedicated always available target for
/// unittests, we go for "AArch64".
-std::unique_ptr<LLVMTargetMachine> createTargetMachine() {
+static std::unique_ptr<LLVMTargetMachine> createTargetMachine() {
Triple TargetTriple("aarch64--");
std::string Error;
const Target *T = TargetRegistry::lookupTarget("", TargetTriple, Error);
@@ -53,15 +55,16 @@
return nullptr;
TargetOptions Options;
- return std::unique_ptr<LLVMTargetMachine>(static_cast<LLVMTargetMachine*>(
- T->createTargetMachine("AArch64", "", "", Options, None, None,
- CodeGenOpt::Aggressive)));
+ return std::unique_ptr<LLVMTargetMachine>(
+ static_cast<LLVMTargetMachine *>(T->createTargetMachine(
+ "AArch64", "", "", Options, None, None, CodeGenOpt::Aggressive)));
}
-std::unique_ptr<Module> parseMIR(LLVMContext &Context,
- std::unique_ptr<MIRParser> &MIR,
- const TargetMachine &TM, StringRef MIRCode,
- const char *FuncName, MachineModuleInfo &MMI) {
+static std::unique_ptr<Module> parseMIR(LLVMContext &Context,
+ std::unique_ptr<MIRParser> &MIR,
+ const TargetMachine &TM,
+ StringRef MIRCode, const char *FuncName,
+ MachineModuleInfo &MMI) {
SMDiagnostic Diagnostic;
std::unique_ptr<MemoryBuffer> MBuffer = MemoryBuffer::getMemBuffer(MIRCode);
MIR = createMIRParser(std::move(MBuffer), Context);
@@ -80,7 +83,7 @@
return M;
}
-std::pair<std::unique_ptr<Module>, std::unique_ptr<MachineModuleInfo>>
+static std::pair<std::unique_ptr<Module>, std::unique_ptr<MachineModuleInfo>>
createDummyModule(LLVMContext &Context, const LLVMTargetMachine &TM,
StringRef MIRFunc) {
SmallString<512> S;
@@ -123,9 +126,9 @@
}
}
-class LegalizerHelperTest : public ::testing::Test {
+class GISelMITest : public ::testing::Test {
protected:
- LegalizerHelperTest() : ::testing::Test() {
+ GISelMITest() : ::testing::Test() {
TM = createTargetMachine();
if (!TM)
return;
@@ -168,8 +171,8 @@
} \
};
-static bool CheckMachineFunction(const MachineFunction &MF,
- StringRef CheckStr) {
+static inline bool CheckMachineFunction(const MachineFunction &MF,
+ StringRef CheckStr) {
SmallString<512> Msg;
raw_svector_ostream OS(Msg);
MF.print(OS);
@@ -190,3 +193,4 @@
SM.AddNewSourceBuffer(std::move(OutputBuf), SMLoc());
return FC.CheckInput(SM, OutBuffer, CheckStrings);
}
+#endif
diff --git a/llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp b/llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp
index ee84aef..9764a0b 100644
--- a/llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp
+++ b/llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp
@@ -1,4 +1,5 @@
-//===- PatternMatchTest.cpp -----------------------------------------------===//
+//===- LegalizerHelperTest.cpp
+//-----------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
@@ -7,21 +8,21 @@
//
//===----------------------------------------------------------------------===//
-#include "LegalizerHelperTest.h"
+#include "GISelMITest.h"
namespace {
class DummyGISelObserver : public GISelChangeObserver {
public:
- void changingInstr(const MachineInstr &MI) override {}
- void changedInstr(const MachineInstr &MI) override {}
- void createdInstr(const MachineInstr &MI) override {}
- void erasingInstr(const MachineInstr &MI) override {}
+ void changingInstr(MachineInstr &MI) override {}
+ void changedInstr(MachineInstr &MI) override {}
+ void createdInstr(MachineInstr &MI) override {}
+ void erasingInstr(MachineInstr &MI) override {}
};
// Test CTTZ expansion when CTTZ_ZERO_UNDEF is legal or custom,
// in which case it becomes CTTZ_ZERO_UNDEF with select.
-TEST_F(LegalizerHelperTest, LowerBitCountingCTTZ0) {
+TEST_F(GISelMITest, LowerBitCountingCTTZ0) {
if (!TM)
return;
@@ -33,7 +34,7 @@
B.buildInstr(TargetOpcode::G_CTTZ, {LLT::scalar(64)}, {Copies[0]});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
- LegalizerHelper Helper(*MF, Info, Observer);
+ LegalizerHelper Helper(*MF, Info, Observer, B);
// Perform Legalization
ASSERT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
LegalizerHelper::LegalizeResult::Legalized);
@@ -51,7 +52,7 @@
}
// CTTZ expansion in terms of CTLZ
-TEST_F(LegalizerHelperTest, LowerBitCountingCTTZ1) {
+TEST_F(GISelMITest, LowerBitCountingCTTZ1) {
if (!TM)
return;
@@ -63,7 +64,7 @@
B.buildInstr(TargetOpcode::G_CTTZ, {LLT::scalar(64)}, {Copies[0]});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
- LegalizerHelper Helper(*MF, Info, Observer);
+ LegalizerHelper Helper(*MF, Info, Observer, B);
// Perform Legalization
ASSERT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
LegalizerHelper::LegalizeResult::Legalized);
@@ -83,7 +84,7 @@
}
// CTTZ expansion in terms of CTPOP
-TEST_F(LegalizerHelperTest, LowerBitCountingCTTZ2) {
+TEST_F(GISelMITest, LowerBitCountingCTTZ2) {
if (!TM)
return;
@@ -95,7 +96,7 @@
B.buildInstr(TargetOpcode::G_CTTZ, {LLT::scalar(64)}, {Copies[0]});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
- LegalizerHelper Helper(*MF, Info, Observer);
+ LegalizerHelper Helper(*MF, Info, Observer, B);
ASSERT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
LegalizerHelper::LegalizeResult::Legalized);
@@ -112,7 +113,7 @@
}
// CTTZ_ZERO_UNDEF expansion in terms of CTTZ
-TEST_F(LegalizerHelperTest, LowerBitCountingCTTZ3) {
+TEST_F(GISelMITest, LowerBitCountingCTTZ3) {
if (!TM)
return;
@@ -124,7 +125,7 @@
{LLT::scalar(64)}, {Copies[0]});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
- LegalizerHelper Helper(*MF, Info, Observer);
+ LegalizerHelper Helper(*MF, Info, Observer, B);
ASSERT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) ==
LegalizerHelper::LegalizeResult::Legalized);
@@ -137,7 +138,7 @@
}
// CTLZ expansion in terms of CTLZ_ZERO_UNDEF
-TEST_F(LegalizerHelperTest, LowerBitCountingCTLZ0) {
+TEST_F(GISelMITest, LowerBitCountingCTLZ0) {
if (!TM)
return;
@@ -149,7 +150,7 @@
B.buildInstr(TargetOpcode::G_CTLZ, {LLT::scalar(64)}, {Copies[0]});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
- LegalizerHelper Helper(*MF, Info, Observer);
+ LegalizerHelper Helper(*MF, Info, Observer, B);
ASSERT_TRUE(Helper.lower(*MIBCTLZ, 0, LLT::scalar(64)) ==
LegalizerHelper::LegalizeResult::Legalized);
@@ -166,7 +167,7 @@
}
// CTLZ expansion in terms of CTLZ_ZERO_UNDEF if the latter is a libcall
-TEST_F(LegalizerHelperTest, LowerBitCountingCTLZLibcall) {
+TEST_F(GISelMITest, LowerBitCountingCTLZLibcall) {
if (!TM)
return;
@@ -178,7 +179,7 @@
B.buildInstr(TargetOpcode::G_CTLZ, {LLT::scalar(64)}, {Copies[0]});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
- LegalizerHelper Helper(*MF, Info, Observer);
+ LegalizerHelper Helper(*MF, Info, Observer, B);
ASSERT_TRUE(Helper.lower(*MIBCTLZ, 0, LLT::scalar(64)) ==
LegalizerHelper::LegalizeResult::Legalized);
@@ -195,7 +196,7 @@
}
// CTLZ expansion
-TEST_F(LegalizerHelperTest, LowerBitCountingCTLZ1) {
+TEST_F(GISelMITest, LowerBitCountingCTLZ1) {
if (!TM)
return;
@@ -209,7 +210,7 @@
auto MIBCTLZ = B.buildInstr(TargetOpcode::G_CTLZ, {s8}, {MIBTrunc});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
- LegalizerHelper Helper(*MF, Info, Observer);
+ LegalizerHelper Helper(*MF, Info, Observer, B);
ASSERT_TRUE(Helper.lower(*MIBCTLZ, 0, s8) ==
LegalizerHelper::LegalizeResult::Legalized);
@@ -234,7 +235,7 @@
}
// CTLZ widening.
-TEST_F(LegalizerHelperTest, WidenBitCountingCTLZ) {
+TEST_F(GISelMITest, WidenBitCountingCTLZ) {
if (!TM)
return;
@@ -249,7 +250,7 @@
auto MIBCTLZ = B.buildInstr(TargetOpcode::G_CTLZ, {s8}, {MIBTrunc});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
- LegalizerHelper Helper(*MF, Info, Observer);
+ LegalizerHelper Helper(*MF, Info, Observer, B);
ASSERT_TRUE(Helper.widenScalar(*MIBCTLZ, 0, s16) ==
LegalizerHelper::LegalizeResult::Legalized);
@@ -267,7 +268,7 @@
}
// CTLZ_ZERO_UNDEF widening.
-TEST_F(LegalizerHelperTest, WidenBitCountingCTLZZeroUndef) {
+TEST_F(GISelMITest, WidenBitCountingCTLZZeroUndef) {
if (!TM)
return;
@@ -283,7 +284,7 @@
B.buildInstr(TargetOpcode::G_CTLZ_ZERO_UNDEF, {s8}, {MIBTrunc});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
- LegalizerHelper Helper(*MF, Info, Observer);
+ LegalizerHelper Helper(*MF, Info, Observer, B);
ASSERT_TRUE(Helper.widenScalar(*MIBCTLZ_ZU, 0, s16) ==
LegalizerHelper::LegalizeResult::Legalized);
@@ -301,7 +302,7 @@
}
// CTPOP widening.
-TEST_F(LegalizerHelperTest, WidenBitCountingCTPOP) {
+TEST_F(GISelMITest, WidenBitCountingCTPOP) {
if (!TM)
return;
@@ -316,7 +317,7 @@
auto MIBCTPOP = B.buildInstr(TargetOpcode::G_CTPOP, {s8}, {MIBTrunc});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
- LegalizerHelper Helper(*MF, Info, Observer);
+ LegalizerHelper Helper(*MF, Info, Observer, B);
ASSERT_TRUE(Helper.widenScalar(*MIBCTPOP, 0, s16) ==
LegalizerHelper::LegalizeResult::Legalized);
@@ -332,7 +333,7 @@
}
// CTTZ_ZERO_UNDEF widening.
-TEST_F(LegalizerHelperTest, WidenBitCountingCTTZ_ZERO_UNDEF) {
+TEST_F(GISelMITest, WidenBitCountingCTTZ_ZERO_UNDEF) {
if (!TM)
return;
@@ -348,7 +349,7 @@
B.buildInstr(TargetOpcode::G_CTTZ_ZERO_UNDEF, {s8}, {MIBTrunc});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
- LegalizerHelper Helper(*MF, Info, Observer);
+ LegalizerHelper Helper(*MF, Info, Observer, B);
ASSERT_TRUE(Helper.widenScalar(*MIBCTTZ_ZERO_UNDEF, 0, s16) ==
LegalizerHelper::LegalizeResult::Legalized);
@@ -364,7 +365,7 @@
}
// CTTZ widening.
-TEST_F(LegalizerHelperTest, WidenBitCountingCTTZ) {
+TEST_F(GISelMITest, WidenBitCountingCTTZ) {
if (!TM)
return;
@@ -379,7 +380,7 @@
auto MIBCTTZ = B.buildInstr(TargetOpcode::G_CTTZ, {s8}, {MIBTrunc});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
- LegalizerHelper Helper(*MF, Info, Observer);
+ LegalizerHelper Helper(*MF, Info, Observer, B);
ASSERT_TRUE(Helper.widenScalar(*MIBCTTZ, 0, s16) ==
LegalizerHelper::LegalizeResult::Legalized);
@@ -396,7 +397,7 @@
ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
}
// UADDO widening.
-TEST_F(LegalizerHelperTest, WidenUADDO) {
+TEST_F(GISelMITest, WidenUADDO) {
if (!TM)
return;
@@ -413,7 +414,7 @@
B.buildInstr(TargetOpcode::G_UADDO, {s8, CarryReg}, {MIBTrunc, MIBTrunc});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
- LegalizerHelper Helper(*MF, Info, Observer);
+ LegalizerHelper Helper(*MF, Info, Observer, B);
ASSERT_TRUE(Helper.widenScalar(*MIBUAddO, 0, s16) ==
LegalizerHelper::LegalizeResult::Legalized);
@@ -433,7 +434,7 @@
}
// USUBO widening.
-TEST_F(LegalizerHelperTest, WidenUSUBO) {
+TEST_F(GISelMITest, WidenUSUBO) {
if (!TM)
return;
@@ -450,7 +451,7 @@
B.buildInstr(TargetOpcode::G_USUBO, {s8, CarryReg}, {MIBTrunc, MIBTrunc});
AInfo Info(MF->getSubtarget());
DummyGISelObserver Observer;
- LegalizerHelper Helper(*MF, Info, Observer);
+ LegalizerHelper Helper(*MF, Info, Observer, B);
ASSERT_TRUE(Helper.widenScalar(*MIBUSUBO, 0, s16) ==
LegalizerHelper::LegalizeResult::Legalized);