[GlobalISel] Add hasPostISelHook handling.

[abinavpp]

Summary

SelectionDAG handles MachineInstr's MCID::hasPostISelHook using
TargetLowering::AdjustInstrPostInstrSelection() which depends on SDNode.
This change adds the global-isel version in TargetLoweringBase.

[arsenm]

Is this still necessary?

[abinavpp]

D115130 is abandoned

llvm/include/llvm/CodeGen/TargetLowering.h

public:
   virtual void finalizeLowering(MachineFunction &MF) const;
 
   //===----------------------------------------------------------------------===//
   //  GlobalISel Hooks
   //===----------------------------------------------------------------------===//
   /// Check whether or not \p MI needs to be moved close to its uses.
   virtual bool shouldLocalize(const MachineInstr &MI, const TargetTransformInfo *TTI) const;
 
+  /// GlobalISel version of TargetLowering::AdjustInstrPostInstrSelection.
+  /// Returns true if the MIR was modified.
+  virtual bool adjustInstrPostGISel(MachineInstr &MI) const;
 
 private:
   const TargetMachine &TM;
 
   /// Tells the code generator that the target has multiple (allocatable)
   /// condition registers that can be used to store the results of comparisons
   /// for use by selects and conditional branches. With multiple condition
   /// registers, the code generator will not aggressively sink comparisons into

llvm/lib/CodeGen/GlobalISel/InstructionSelect.cpp

if (!DisableGISelLegalityCheck)
     }
   // FIXME: We could introduce new blocks and will need to fix the outer loop.
   // Until then, keep track of the number of blocks to assert that we don't.
   const size_t NumBlocks = MF.size();
 #endif
   // Keep track of selected blocks, so we can delete unreachable ones later.
   DenseSet<MachineBasicBlock *> SelectedBlocks;
 
+  // List of newly added MachineInstrs during selection.
+  SmallVector<MachineInstr *, 8> InsertedMIs;
+
   for (MachineBasicBlock *MBB : post_order(&MF)) {
     ISel->CurMBB = MBB;
     SelectedBlocks.insert(MBB);
     if (MBB->empty())
       continue;
 
     // Select instructions in reverse block order. We permit erasing so have
     // to resort to manually iterating and recognizing the begin (rend) case.
     bool ReachedBegin = false;
     for (auto MII = std::prev(MBB->end()), Begin = MBB->begin();
          !ReachedBegin;) {
-#ifndef NDEBUG
-      // Keep track of the insertion range for debug printing.
+
       const auto AfterIt = std::next(MII);
-#endif
       // Select this instruction.
       MachineInstr &MI = *MII;
 
       // And have our iterator point to the next instruction, if there is one.
       if (MII == Begin)
         ReachedBegin = true;
       else
         --MII;
for (auto MII = std::prev(MBB->end()), Begin = MBB->begin();
 
       if (!ISel->select(MI)) {
         // FIXME: It would be nice to dump all inserted instructions.  It's
         // not obvious how, esp. considering select() can insert after MI.
         reportGISelFailure(MF, TPC, MORE, "gisel-select", "cannot select", MI);
         return false;
       }
 
-      // Dump the range of instructions that MI expanded into.
-      LLVM_DEBUG({
-        auto InsertedBegin = ReachedBegin ? MBB->begin() : std::next(MII);
-        dbgs() << "Into:\n";
-        for (auto &InsertedMI : make_range(InsertedBegin, AfterIt))
-          dbgs() << "  " << InsertedMI;
-        dbgs() << '\n';
-      });
+      LLVM_DEBUG(dbgs() << "Into:\n");
+      for (auto &InsertedMI : make_range(InsertedBegin, AfterIt)) {
+        InsertedMIs.push_back(&InsertedMI);
+        LLVM_DEBUG(dbgs() << "  " << InsertedMI);
+      }
+      LLVM_DEBUG(dbgs() << '\n');
     }
   }
 
   for (MachineBasicBlock &MBB : MF) {
     if (MBB.empty())
       continue;
 
     if (!SelectedBlocks.contains(&MBB)) {
for (const auto &MI : MBB) {
         MF.setHasInlineAsm(true);
     }
   }
 
   // FIXME: FinalizeISel pass calls finalizeLowering, so it's called twice.
   auto &TLI = *MF.getSubtarget().getTargetLowering();
   TLI.finalizeLowering(MF);
 
+  for (MachineInstr *MI : InsertedMIs) {
+    if (MI->hasPostISelHook()) {
+      LLVM_DEBUG(dbgs() << "hasPostISelHook handling of:\n  " << *MI);
+      bool Modified = TLI.adjustInstrPostGISel(*MI);
+      (void)Modified;
+      LLVM_DEBUG(if (Modified) dbgs() << "Modified To:\n  " << *MI;
+                 else dbgs() << "Didn't modify\n";);
+    }
+  }
+
   LLVM_DEBUG({
     dbgs() << "Rules covered by selecting function: " << MF.getName() << ":";
     for (auto RuleID : CoverageInfo.covered())
       dbgs() << " id" << RuleID;
     dbgs() << "\n\n";
   });
   CoverageInfo.emit(CoveragePrefix,
                     TLI.getTargetMachine().getTarget().getBackendName());

llvm/lib/CodeGen/TargetLoweringBase.cpp

case TargetOpcode::G_GLOBAL_VALUE: {
     unsigned MaxUses = maxUses(RematCost);
     if (MaxUses == UINT_MAX)
       return true; // Remats are "free" so always localize.
     bool B = isUsesAtMost(Reg, MaxUses);
     return B;
   }
   }
 }
+
+bool TargetLoweringBase::adjustInstrPostGISel(MachineInstr &MI) const {
+  // TODO: Add assertion for MI.hasPostISelHook() once every global-isel target
+  // overrides this function.
+  return false;
+}