Add unittest; Make SetVector small; Rebase to fix CI

Author: tobias-stadler

llvm/include/llvm/CodeGen/GlobalISel/InstructionSelect.h

@@ -21,6 +21,7 @@
 namespace llvm {
 
 class InstructionSelector;
+class GISelKnownBits;
 class BlockFrequencyInfo;
 class ProfileSummaryInfo;
 
@@ -54,17 +55,20 @@ class InstructionSelect : public MachineFunctionPass {
   InstructionSelect();
 
   bool runOnMachineFunction(MachineFunction &MF) override;
+  bool selectMachineFunction(MachineFunction &MF);
+  void setInstructionSelector(InstructionSelector *NewISel) { ISel = NewISel; }
 
 protected:
   class MIIteratorMaintainer;
 
   InstructionSelector *ISel = nullptr;
+  GISelKnownBits *KB = nullptr;
   BlockFrequencyInfo *BFI = nullptr;
   ProfileSummaryInfo *PSI = nullptr;
 
   CodeGenOptLevel OptLevel = CodeGenOptLevel::None;
 
-  bool select(MachineInstr &MI);
+  bool selectInstr(MachineInstr &MI);
 };
 } // End namespace llvm.
 

llvm/include/llvm/CodeGen/GlobalISel/InstructionSelector.h

@@ -32,12 +32,9 @@ class InstructionSelector : public GIMatchTableExecutor {
   ///       !isPreISelGenericOpcode(I.getOpcode())
   virtual bool select(MachineInstr &I) = 0;
 
-  void setTargetPassConfig(const TargetPassConfig *T) { TPC = T; }
-
-  void setRemarkEmitter(MachineOptimizationRemarkEmitter *M) { MORE = M; }
-
-protected:
+  // FIXME: Eliminate dependency on TargetPassConfig for NewPM transition
   const TargetPassConfig *TPC = nullptr;
+
   MachineOptimizationRemarkEmitter *MORE = nullptr;
 };
 } // namespace llvm

llvm/lib/CodeGen/GlobalISel/InstructionSelect.cpp

@@ -75,7 +75,9 @@ INITIALIZE_PASS_END(InstructionSelect, DEBUG_TYPE,
 class InstructionSelect::MIIteratorMaintainer
     : public MachineFunction::Delegate {
 #ifndef NDEBUG
-  SetVector<const MachineInstr *> CreatedInstrs;
+  SetVector<const MachineInstr *, SmallVector<const MachineInstr *, 8>,
+            DenseSet<const MachineInstr *>, 8>
+      CreatedInstrs;
 #endif
 public:
   MachineBasicBlock::reverse_iterator MII;
@@ -138,31 +140,36 @@ bool InstructionSelect::runOnMachineFunction(MachineFunction &MF) {
           MachineFunctionProperties::Property::FailedISel))
     return false;
 
-  LLVM_DEBUG(dbgs() << "Selecting function: " << MF.getName() << '\n');
-
-  const TargetPassConfig &TPC = getAnalysis<TargetPassConfig>();
   ISel = MF.getSubtarget().getInstructionSelector();
-  ISel->setTargetPassConfig(&TPC);
+  ISel->TPC = &getAnalysis<TargetPassConfig>();
 
+  // FIXME: Properly override OptLevel in TargetMachine. See OptLevelChanger
   CodeGenOptLevel OldOptLevel = OptLevel;
   auto RestoreOptLevel = make_scope_exit([=]() { OptLevel = OldOptLevel; });
   OptLevel = MF.getFunction().hasOptNone() ? CodeGenOptLevel::None
                                            : MF.getTarget().getOptLevel();
 
-  GISelKnownBits *KB = &getAnalysis<GISelKnownBitsAnalysis>().get(MF);
+  KB = &getAnalysis<GISelKnownBitsAnalysis>().get(MF);
   if (OptLevel != CodeGenOptLevel::None) {
     PSI = &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
     if (PSI && PSI->hasProfileSummary())
       BFI = &getAnalysis<LazyBlockFrequencyInfoPass>().getBFI();
   }
 
-  CodeGenCoverage CoverageInfo;
+  return selectMachineFunction(MF);
+}
+
+bool InstructionSelect::selectMachineFunction(MachineFunction &MF) {
+  LLVM_DEBUG(dbgs() << "Selecting function: " << MF.getName() << '\n');
   assert(ISel && "Cannot work without InstructionSelector");
+
+  const TargetPassConfig &TPC = *ISel->TPC;
+  CodeGenCoverage CoverageInfo;
   ISel->setupMF(MF, KB, &CoverageInfo, PSI, BFI);
 
   // An optimization remark emitter. Used to report failures.
   MachineOptimizationRemarkEmitter MORE(MF, /*MBFI=*/nullptr);
-  ISel->setRemarkEmitter(&MORE);
+  ISel->MORE = &MORE;
 
   // FIXME: There are many other MF/MFI fields we need to initialize.
 
@@ -206,7 +213,7 @@ bool InstructionSelect::runOnMachineFunction(MachineFunction &MF) {
         ++MIIMaintainer.MII;
 
         LLVM_DEBUG(dbgs() << "\nSelect:  " << MI);
-        if (!select(MI)) {
+        if (!selectInstr(MI)) {
           LLVM_DEBUG(dbgs() << "Selection failed!\n";
                      MIIMaintainer.reportFullyCreatedInstrs());
           reportGISelFailure(MF, TPC, MORE, "gisel-select", "cannot select",
@@ -341,7 +348,7 @@ bool InstructionSelect::runOnMachineFunction(MachineFunction &MF) {
   return true;
 }
 
-bool InstructionSelect::select(MachineInstr &MI) {
+bool InstructionSelect::selectInstr(MachineInstr &MI) {
   MachineRegisterInfo &MRI = ISel->MF->getRegInfo();
 
   // We could have folded this instruction away already, making it dead.

llvm/unittests/CodeGen/GlobalISel/CMakeLists.txt

@@ -28,4 +28,5 @@ add_llvm_unittest(GlobalISelTests
   GISelUtilsTest.cpp
   GISelAliasTest.cpp
   CallLowering.cpp
+  InstructionSelectTest.cpp
   )

llvm/unittests/CodeGen/GlobalISel/InstructionSelectTest.cpp

@@ -0,0 +1,72 @@
+#include "GISelMITest.h"
+#include "llvm/CodeGen/GlobalISel/InstructionSelect.h"
+#include "llvm/CodeGen/GlobalISel/InstructionSelector.h"
+#include "llvm/CodeGen/TargetPassConfig.h"
+#include "llvm/IR/LegacyPassManager.h"
+
+class EraseMockInstructionSelector : public InstructionSelector {
+public:
+  int NumSelected = 0;
+  SmallVector<MachineInstr *> MIs;
+
+  bool select(MachineInstr &MI) override {
+    ++NumSelected;
+    switch (NumSelected) {
+    case 1:
+      EXPECT_EQ(&MI, MIs[8]);
+      // Erase previous instructions
+      MIs[7]->eraseFromParent();
+      MIs[6]->eraseFromParent();
+      // Don't erase this MI before step 3 to prevent DCE
+      return true;
+    case 2:
+      EXPECT_EQ(&MI, MIs[5]);
+      // Erase previous instructions reversed
+      MIs[3]->eraseFromParent();
+      MIs[4]->eraseFromParent();
+      MI.eraseFromParent();
+      return true;
+    case 3:
+      EXPECT_EQ(&MI, MIs[2]);
+      MIs[8]->eraseFromParent();
+      // Erase first instructions
+      MIs[0]->eraseFromParent();
+      MIs[1]->eraseFromParent();
+      MI.eraseFromParent();
+      return true;
+    default:
+      ADD_FAILURE();
+      return false;
+    }
+  }
+
+  void setupGeneratedPerFunctionState(MachineFunction &MF) override {}
+};
+
+TEST_F(AArch64GISelMITest, TestInstructionSelectErase) {
+  StringRef MIRString = R"(
+   $x0 = COPY %2(s64)
+   $x0 = COPY %2(s64)
+   $x0 = COPY %2(s64)
+   $x0 = COPY %2(s64)
+   $x0 = COPY %2(s64)
+   $x0 = COPY %2(s64)
+)";
+  setUp(MIRString);
+  if (!TM)
+    GTEST_SKIP();
+
+  legacy::PassManager PM;
+  std::unique_ptr<TargetPassConfig> TPC(TM->createPassConfig(PM));
+
+  EraseMockInstructionSelector ISel;
+  ISel.TPC = TPC.get();
+  for (auto &MI : *EntryMBB) {
+    ISel.MIs.push_back(&MI);
+  }
+
+  InstructionSelect ISelPass;
+  ISelPass.setInstructionSelector(&ISel);
+  ISelPass.selectMachineFunction(*MF);
+  EXPECT_EQ(ISel.NumSelected, 3);
+}