New interface to enable shrink wrapping

[kbarton]

Summary

This patch changes the interface to enable the shrink wrapping optimization.
It adds a new constructor, which takes a std::function predicate function that is run at the beginning of shrink wrapping to determine whether the optimization should run on the given machine function. The std::function can be overridden by each target, allowing target-specific decisions to be made on each machine function.

This is necessary for PowerPC, as the decision to run shrink wrapping is partially based on the ABI. Futhermore, this operates nicely with the GCC iFunc capability, which allows option overrides on a per-function basis.

[nemanjai]

lib/CodeGen/ShrinkWrap.cpp

323

Does this mean that shrink wrapping will run on a passed function if the PredicateFtor is not callable? Although as currently set-up, this cannot happen.

[kbarton]

lib/CodeGen/ShrinkWrap.cpp

323

Yes, that is true.
I could not remove the default constructor, as it is needed somewhere else.
I could change this logic to disable Shrink Wrapping if PredicateFtor has not been set if there is a concern about this.

[kbarton]

lib/CodeGen/Passes.cpp

539–540

This will add shrink wrapping all the time. I think it makes more sense to guard this by (getOptLevel() != CodeGenOpt::None), as is done below for addMachineLateOptimization().
I will make this change in the next revision.

[wschmidt]

lib/CodeGen/Passes.cpp

539–540

Depending on the computational complexity of shrink wrapping, you may want to enable this at -O2 and up rather than -O1. I haven't looked at the code, but I assume Quentin can advise.

[hfinkel]

This is necessary for PowerPC, as the decision to run shrink wrapping is partially based on the ABI.

How do you imagine this working such that we can still turn off shrink wrapping on PowerPC using the command-line option?

lib/CodeGen/Passes.cpp

539–540

Two comments here:

The pass should always be added, but it should contain a check for:

if (skipOptnoneFunction(*MF.getFunction()))

and, if it does not, we should fix that.

Second, regarding complexity, it does not seem as though it should be significantly more expensive than MachineLICM, etc. that are used at -O1, so I think that leaving it always enabled if (getOptLevel() != CodeGenOpt::None) should be fine.

lib/CodeGen/ShrinkWrap.cpp

323

This seems reasonable. If you somehow were able to invoke the pass manually from the command line using the default constructor, you'd expect it to run.

[kbarton]

Two changes since last revision:

1. Do not add shrink wrap pass for noopt
2. Check the skipOptnoneFunction method at beginning of shrink wrapping

[kbarton]

In D11421#212046, @hfinkel wrote:

This is necessary for PowerPC, as the decision to run shrink wrapping is partially based on the ABI.

How do you imagine this working such that we can still turn off shrink wrapping on PowerPC using the command-line option?

I ended up adding a new command line option to disable it for PPC, but it should be doable with the existing option of -enable-shrink-wrap=false if we don't want to add a new option. I think you can build this check into the checks for the ABI on a per-function bases and achieve the desired behaviour.
Or, I misunderstand the question.

[qcolombet]

Hi Kit,

LGTM with Hal’s comments addressed.

Thanks,
Q.

lib/CodeGen/Passes.cpp

539–540

Like Hal said, having it running at O1 should be fine.

lib/CodeGen/ShrinkWrap.cpp

191

Period at end of comments.

[kbarton]

Committed revision 244235.

include/llvm/CodeGen/Passes.h

protected:
   // Target Pass Options
   // Targets provide a default setting, user flags override.
   //
   bool DisableVerify;
 
   /// Default setting for -enable-tail-merge on this target.
   bool EnableTailMerge;
 
-  /// Default setting for -enable-shrink-wrap on this target.
-  bool EnableShrinkWrap;
-
 public:
   TargetPassConfig(TargetMachine *tm, PassManagerBase &pm);
   // Dummy constructor.
   TargetPassConfig();
 
   ~TargetPassConfig() override;
 
   static char ID;
public:
 
   /// Return the pass substituted for StandardID by the target.
   /// If no substitution exists, return StandardID.
   IdentifyingPassPtr getPassSubstitution(AnalysisID StandardID) const;
 
   /// Return true if the optimized regalloc pipeline is enabled.
   bool getOptimizeRegAlloc() const;
 
-  /// Return true if shrink wrapping is enabled.
-  bool getEnableShrinkWrap() const;
-
   /// Return true if the default global register allocator is in use and
   /// has not be overriden on the command line with '-regalloc=...'
   bool usingDefaultRegAlloc() const;
 
   /// Add common target configurable passes that perform LLVM IR to IR
   /// transforms following machine independent optimization.
   virtual void addIRPasses();
 
protected:
   void printAndVerify(const std::string &Banner);
 
   /// Add a pass to print the machine function if printing is enabled.
   void addPrintPass(const std::string &Banner);
 
   /// Add a pass to perform basic verification of the machine function if
   /// verification is enabled.
   void addVerifyPass(const std::string &Banner);
+
+  /// Create an instance of ShrinkWrap using the runShrinkWrap predicate
+  /// function.  
+  FunctionPass *createShrinkWrapPass();
+  
+  /// Predicate function passed to a ShrinkWrap object to determine if shrink
+  /// wrapping should be run on a MachineFunction.
+  virtual bool runShrinkWrap(const MachineFunction &Fn) const;
 };
 } // namespace llvm
 
 /// List of target independent CodeGen pass IDs.
 namespace llvm {
   FunctionPass *createAtomicExpandPass(const TargetMachine *TM);
 
   /// createUnreachableBlockEliminationPass - The LLVM code generator does not

lib/CodeGen/Passes.cpp

 static cl::opt<bool> DisableMachineDCE("disable-machine-dce", cl::Hidden,
     cl::desc("Disable Machine Dead Code Elimination"));
 static cl::opt<bool> DisableEarlyIfConversion("disable-early-ifcvt", cl::Hidden,
     cl::desc("Disable Early If-conversion"));
 static cl::opt<bool> DisableMachineLICM("disable-machine-licm", cl::Hidden,
     cl::desc("Disable Machine LICM"));
 static cl::opt<bool> DisableMachineCSE("disable-machine-cse", cl::Hidden,
     cl::desc("Disable Machine Common Subexpression Elimination"));
-static cl::opt<cl::boolOrDefault>
-    EnableShrinkWrapOpt("enable-shrink-wrap", cl::Hidden,
-                        cl::desc("enable the shrink-wrapping pass"));
 static cl::opt<cl::boolOrDefault> OptimizeRegAlloc(
     "optimize-regalloc", cl::Hidden,
     cl::desc("Enable optimized register allocation compilation path."));
 static cl::opt<bool> DisablePostRAMachineLICM("disable-postra-machine-licm",
     cl::Hidden,
     cl::desc("Disable Machine LICM"));
 static cl::opt<bool> DisableMachineSink("disable-machine-sink", cl::Hidden,
     cl::desc("Disable Machine Sinking"));

 }
 
 // Out of line constructor provides default values for pass options and
 // registers all common codegen passes.
 TargetPassConfig::TargetPassConfig(TargetMachine *tm, PassManagerBase &pm)
     : ImmutablePass(ID), PM(&pm), StartBefore(nullptr), StartAfter(nullptr),
       StopAfter(nullptr), Started(true), Stopped(false),
       AddingMachinePasses(false), TM(tm), Impl(nullptr), Initialized(false),
-      DisableVerify(false), EnableTailMerge(true), EnableShrinkWrap(false) {
+      DisableVerify(false), EnableTailMerge(true) {
 
   Impl = new PassConfigImpl();
 
   // Register all target independent codegen passes to activate their PassIDs,
   // including this pass itself.
   initializeCodeGen(*PassRegistry::getPassRegistry());
 
   // Substitute Pseudo Pass IDs for real ones.
if (getOptimizeRegAlloc())
     addOptimizedRegAlloc(createRegAllocPass(true));
   else
     addFastRegAlloc(createRegAllocPass(false));
 
   // Run post-ra passes.
   addPostRegAlloc();
 
   // Insert prolog/epilog code.  Eliminate abstract frame index references...
-  if (getEnableShrinkWrap())
-    addPass(&ShrinkWrapID);
+  if (getOptLevel() != CodeGenOpt::None)
+    addPass(createShrinkWrapPass());
   addPass(&PrologEpilogCodeInserterID);
 
   /// Add passes that optimize machine instructions after register allocation.
   if (getOptLevel() != CodeGenOpt::None)
     addMachineLateOptimization();
 
   // Expand pseudo instructions before second scheduling pass.
   addPass(&ExpandPostRAPseudosID);
void TargetPassConfig::addMachineSSAOptimization() {
   addPass(&MachineSinkingID);
 
   addPass(&PeepholeOptimizerID, false);
   // Clean-up the dead code that may have been generated by peephole
   // rewriting.
   addPass(&DeadMachineInstructionElimID);
 }
 
-bool TargetPassConfig::getEnableShrinkWrap() const {
-  switch (EnableShrinkWrapOpt) {
-  case cl::BOU_UNSET:
-    return EnableShrinkWrap && getOptLevel() != CodeGenOpt::None;
-  // If EnableShrinkWrap is set, it takes precedence on whatever the
-  // target sets. The rational is that we assume we want to test
-  // something related to shrink-wrapping.
-  case cl::BOU_TRUE:
-    return true;
-  case cl::BOU_FALSE:
-    return false;
-  }
-  llvm_unreachable("Invalid shrink-wrapping state");
-}
-
 //===---------------------------------------------------------------------===//
 /// Register Allocation Pass Configuration
 //===---------------------------------------------------------------------===//
 
 bool TargetPassConfig::getOptimizeRegAlloc() const {
   switch (OptimizeRegAlloc) {
   case cl::BOU_UNSET: return getOptLevel() != CodeGenOpt::None;
   case cl::BOU_TRUE:  return true;

lib/CodeGen/ShrinkWrap.cpp

 #include "llvm/CodeGen/RegisterClassInfo.h"
 #include "llvm/Support/Debug.h"
 // To query the target about frame lowering.
 #include "llvm/Target/TargetFrameLowering.h"
 // To know about frame setup operation.
 #include "llvm/Target/TargetInstrInfo.h"
 // To access TargetInstrInfo.
 #include "llvm/Target/TargetSubtargetInfo.h"
+#include "llvm/Support/CommandLine.h"
 
 #define DEBUG_TYPE "shrink-wrap"
 
 using namespace llvm;
 
+static cl::opt<cl::boolOrDefault>
+    EnableShrinkWrapOpt("enable-shrink-wrap", cl::Hidden,
+                        cl::desc("enable the shrink-wrapping pass"));
+
 STATISTIC(NumFunc, "Number of functions");
 STATISTIC(NumCandidates, "Number of shrink-wrapping candidates");
 STATISTIC(NumCandidatesDropped,
           "Number of shrink-wrapping candidates dropped because of frequency");
 
 namespace {
 /// \brief Class to determine where the safe point to insert the
 /// prologue and epilogue are.
class ShrinkWrap : public MachineFunctionPass {
   bool ArePointsInteresting() const { return Save != Entry && Save && Restore; }
 
 public:
   static char ID;
 
   ShrinkWrap() : MachineFunctionPass(ID) {
     initializeShrinkWrapPass(*PassRegistry::getPassRegistry());
   }
   
+  ShrinkWrap(std::function<bool(const MachineFunction &)> Ftor) :
+      MachineFunctionPass(ID), PredicateFtor(Ftor) {
+    initializeShrinkWrapPass(*PassRegistry::getPassRegistry());
+  }
+
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
     AU.addRequired<MachineBlockFrequencyInfo>();
     AU.addRequired<MachineDominatorTree>();
     AU.addRequired<MachinePostDominatorTree>();
     AU.addRequired<MachineLoopInfo>();
     MachineFunctionPass::getAnalysisUsage(AU);
   }
 
   const char *getPassName() const override {
     return "Shrink Wrapping analysis";
   }
 
   /// \brief Perform the shrink-wrapping analysis and update
   /// the MachineFrameInfo attached to \p MF with the results.
   bool runOnMachineFunction(MachineFunction &MF) override;
+
+private:
+  /// \brief Predicate function to determine if shrink wrapping should run
+  ///
+  /// This function will be run at the beginning of shrink wrapping and
+  /// determine whether shrink wrapping should run on the given MachineFunction
+  /// \param[in] MF The MachineFunction to run shrink wrapping on
+  /// \return true if shrink wrapping should be run, false otherwise
+  std::function<bool(const MachineFunction &MF)> PredicateFtor;
 };
 } // End anonymous namespace.
 
 char ShrinkWrap::ID = 0;
 char &llvm::ShrinkWrapID = ShrinkWrap::ID;
 
 INITIALIZE_PASS_BEGIN(ShrinkWrap, "shrink-wrap", "Shrink Wrap Pass", false,
                       false)
if (Save && Restore && Save != Restore &&
       else
         // Push Restore outside of this loop.
         Restore = FindIDom<>(*Restore, Restore->successors(), *MPDT);
     }
   }
 }
 
 bool ShrinkWrap::runOnMachineFunction(MachineFunction &MF) {
-  if (MF.empty())
+  if (PredicateFtor && !PredicateFtor(MF)) 
+    return false;
+  
+  if (MF.empty() || skipOptnoneFunction(*MF.getFunction()))
     return false;
+
   DEBUG(dbgs() << "**** Analysing " << MF.getName() << '\n');
 
   init(MF);
 
   for (MachineBasicBlock &MBB : MF) {
     DEBUG(dbgs() << "Look into: " << MBB.getNumber() << ' ' << MBB.getName()
                  << '\n');
 
DEBUG(dbgs() << "Final shrink wrap candidates:\nSave: " << Save->getNumber()
                << Restore->getNumber() << ' ' << Restore->getName() << '\n');
 
   MachineFrameInfo *MFI = MF.getFrameInfo();
   MFI->setSavePoint(Save);
   MFI->setRestorePoint(Restore);
   ++NumCandidates;
   return false;
 }
+
+/// If EnableShrinkWrap is set run shrink wrapping on the given Machine
+/// Function. Otherwise, shrink wrapping is disabled.
+/// This function can be overridden in each target-specific TargetPassConfig
+/// class to allow different predicate logic for each target. 
+bool TargetPassConfig::runShrinkWrap(const MachineFunction &Fn) const {
+  switch (EnableShrinkWrapOpt) {
+  case cl::BOU_TRUE:
+    return true;
+  case cl::BOU_UNSET:
+  case cl::BOU_FALSE:
+    return false;
+  }
+  llvm_unreachable("Invalid shrink-wrapping state");
+}
+
+/// Create a ShrinkWrap FunctionPass using the runShrinkWrap predicate
+/// function.
+FunctionPass *TargetPassConfig::createShrinkWrapPass() {
+  std::function<bool(const MachineFunction &Fn)> Ftor =
+    std::bind(&TargetPassConfig::runShrinkWrap, this, std::placeholders::_1);
+  return new ShrinkWrap(Ftor);
+}