[MachineLICM] NFC - add a target hook shouldHoistCheapInstructions for machine licm to hoist cheap instruction

[shchenz]

Summary

Currently, Machine LICM always doesn't hoist cheap instruction. This is not true for some targets, like PowerPC.
On PowerPC, if register pressure is allowed, we prefer to hoist even cheap instruction outside of loop.
This patch is to add a hook for the target to choose hoisting policy for cheap instructions.

[shchenz]

This comment was removed by shchenz.

[shchenz]

we decide to use another solution in https://reviews.llvm.org/D82709, so this NFC should not need any more.

llvm/include/llvm/CodeGen/TargetInstrInfo.h

public:
   }
 
   /// Compute operand latency of a def of 'Reg'. Return true
   /// if the target considered it 'low'.
   virtual bool hasLowDefLatency(const TargetSchedModel &SchedModel,
                                 const MachineInstr &DefMI,
                                 unsigned DefIdx) const;
 
+  /// Specify whether a target should hoist cheap instructions based on
+  /// register pressure.
+  virtual bool shouldHoistCheapInstructions() const { return false; }
+
   /// Perform target-specific instruction verification.
   virtual bool verifyInstruction(const MachineInstr &MI,
                                  StringRef &ErrInfo) const {
     return true;
   }
 
   /// Return the current execution domain and bit mask of
   /// possible domains for instruction.

llvm/lib/CodeGen/MachineLICM.cpp

MachineLICMBase::CanCauseHighRegPressure(const DenseMap<unsigned, int>& Cost,
                                          bool CheapInstr) {
   for (const auto &RPIdAndCost : Cost) {
     if (RPIdAndCost.second <= 0)
       continue;
 
     unsigned Class = RPIdAndCost.first;
     int Limit = RegLimit[Class];
 
-    // Don't hoist cheap instructions if they would increase register pressure,
-    // even if we're under the limit.
-    if (CheapInstr && !HoistCheapInsts)
+    // If target prefers not to hoist cheap instructions, don't hoist them, even
+    // if we're under the limit.
+    if (CheapInstr && !HoistCheapInsts && !TII->shouldHoistCheapInstructions())
       return true;
 
     for (const auto &RP : BackTrace)
       if (static_cast<int>(RP[Class]) + RPIdAndCost.second >= Limit)
         return true;
   }
 
   return false;