[TargetLowering] Remove unused basic block parameter from `getMaxPermittedBytesForAlignment` (NFC)

[chill]

Summary

The MachineBlockPlacement computes and sets the alignment and the
maximum allowed padding for each basic block. It makes no sense to
split these parts of computation that depend on the specific basic
block across different components of the compiler.

llvm/include/llvm/CodeGen/TargetLowering.h

#include "llvm/IR/ConstrainedOps.def"
   /// Return the preferred function alignment.
   Align getPrefFunctionAlignment() const { return PrefFunctionAlignment; }
 
   /// Return the preferred loop alignment.
   virtual Align getPrefLoopAlignment(MachineLoop *ML = nullptr) const;
 
   /// Return the maximum amount of bytes allowed to be emitted when padding for
   /// alignment
-  virtual unsigned
-  getMaxPermittedBytesForAlignment(MachineBasicBlock *MBB) const;
+  virtual unsigned getMaxPermittedBytesForAlignment() const;
 
   /// Should loops be aligned even when the function is marked OptSize (but not
   /// MinSize).
   virtual bool alignLoopsWithOptSize() const { return false; }
 
   /// If the target has a standard location for the stack protector guard,
   /// returns the address of that location. Otherwise, returns nullptr.
   /// DEPRECATED: please override useLoadStackGuardNode and customize

llvm/lib/CodeGen/MachineBlockPlacement.cpp

class MachineBlockPlacement : public MachineFunctionPass {
   /// A handle to the target's lowering info.
   const TargetLoweringBase *TLI = nullptr;
 
   /// A handle to the post dominator tree.
   MachinePostDominatorTree *MPDT = nullptr;
 
   ProfileSummaryInfo *PSI = nullptr;
 
+  unsigned MaxBytesForAlignment = 0;
+
   /// Duplicator used to duplicate tails during placement.
   ///
   /// Placement decisions can open up new tail duplication opportunities, but
   /// since tail duplication affects placement decisions of later blocks, it
   /// must be done inline.
   TailDuplicator TailDup;
 
   /// Partial tail duplication threshold.
if (llvm::shouldOptimizeForSize(ChainBB, PSI, MBFI.get()) &&
         !TLI->alignLoopsWithOptSize())
       continue;
 
     // Check for the existence of a non-layout predecessor which would benefit
     // from aligning this block.
     MachineBasicBlock *LayoutPred =
         &*std::prev(MachineFunction::iterator(ChainBB));
 
-    auto DetermineMaxAlignmentPadding = [&]() {
-      // Set the maximum bytes allowed to be emitted for alignment.
-      unsigned MaxBytes;
-      if (MaxBytesForAlignmentOverride.getNumOccurrences() > 0)
-        MaxBytes = MaxBytesForAlignmentOverride;
-      else
-        MaxBytes = TLI->getMaxPermittedBytesForAlignment(ChainBB);
-      ChainBB->setMaxBytesForAlignment(MaxBytes);
-    };
-
     // Force alignment if all the predecessors are jumps. We already checked
     // that the block isn't cold above.
     if (!LayoutPred->isSuccessor(ChainBB)) {
-      ChainBB->setAlignment(Align);
-      DetermineMaxAlignmentPadding();
+      ChainBB->setAlignment(Align, MaxBytesForAlignment);
       continue;
     }
 
     // Align this block if the layout predecessor's edge into this block is
     // cold relative to the block. When this is true, other predecessors make up
     // all of the hot entries into the block and thus alignment is likely to be
     // important.
     BranchProbability LayoutProb =
         MBPI->getEdgeProbability(LayoutPred, ChainBB);
     BlockFrequency LayoutEdgeFreq = MBFI->getBlockFreq(LayoutPred) * LayoutProb;
-    if (LayoutEdgeFreq <= (Freq * ColdProb)) {
-      ChainBB->setAlignment(Align);
-      DetermineMaxAlignmentPadding();
-    }
+    if (LayoutEdgeFreq <= (Freq * ColdProb))
+      ChainBB->setAlignment(Align, MaxBytesForAlignment);
   }
 }
 
 /// Tail duplicate \p BB into (some) predecessors if profitable, repeating if
 /// it was duplicated into its chain predecessor and removed.
 /// \p BB    - Basic block that may be duplicated.
 ///
 /// \p LPred - Chosen layout predecessor of \p BB.
bool MachineBlockPlacement::runOnMachineFunction(MachineFunction &MF) {
   MBFI = std::make_unique<MBFIWrapper>(
       getAnalysis<MachineBlockFrequencyInfo>());
   MLI = &getAnalysis<MachineLoopInfo>();
   TII = MF.getSubtarget().getInstrInfo();
   TLI = MF.getSubtarget().getTargetLowering();
   MPDT = nullptr;
   PSI = &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
 
+  // Set the maximum bytes allowed to be emitted for alignment.
+  if (MaxBytesForAlignmentOverride.getNumOccurrences() > 0)
+    MaxBytesForAlignment = MaxBytesForAlignmentOverride;
+  else
+    MaxBytesForAlignment = TLI->getMaxPermittedBytesForAlignment();
+
   initDupThreshold();
 
   // Initialize PreferredLoopExit to nullptr here since it may never be set if
   // there are no MachineLoops.
   PreferredLoopExit = nullptr;
 
   assert(BlockToChain.empty() &&
          "BlockToChain map should be empty before starting placement.");

llvm/lib/CodeGen/TargetLoweringBase.cpp

 }
 
 Align TargetLoweringBase::getPrefLoopAlignment(MachineLoop *ML) const {
   if (TM.Options.LoopAlignment)
     return Align(TM.Options.LoopAlignment);
   return PrefLoopAlignment;
 }
 
-unsigned TargetLoweringBase::getMaxPermittedBytesForAlignment(
-    MachineBasicBlock *MBB) const {
+unsigned TargetLoweringBase::getMaxPermittedBytesForAlignment() const {
   return MaxBytesForAlignment;
 }
 
 //===----------------------------------------------------------------------===//
 //  Reciprocal Estimates
 //===----------------------------------------------------------------------===//
 
 /// Get the reciprocal estimate attribute string for a function that will