From: Kit Barton Date: Fri, 14 Aug 2015 16:54:32 +0000 (+0000) Subject: Reverting patch r244235. X-Git-Tag: android-x86-7.1-r4~44591 X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=e4ca1fb9f85a05bf5c496f8a93bbfe8b3a92234b;p=android-x86%2Fexternal-llvm.git Reverting patch r244235. This patch will be redone in a different way. See http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20150810/292978.html for more details. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@245071 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/CodeGen/Passes.h b/include/llvm/CodeGen/Passes.h index 8301dbe0664..5d829217447 100644 --- a/include/llvm/CodeGen/Passes.h +++ b/include/llvm/CodeGen/Passes.h @@ -120,6 +120,9 @@ protected: /// 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. @@ -187,6 +190,9 @@ public: /// 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; @@ -355,14 +361,6 @@ protected: /// 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 diff --git a/lib/CodeGen/Passes.cpp b/lib/CodeGen/Passes.cpp index f3a81e8dc0f..4e68cbdd7f5 100644 --- a/lib/CodeGen/Passes.cpp +++ b/lib/CodeGen/Passes.cpp @@ -56,6 +56,9 @@ static cl::opt DisableMachineLICM("disable-machine-licm", cl::Hidden, cl::desc("Disable Machine LICM")); static cl::opt DisableMachineCSE("disable-machine-cse", cl::Hidden, cl::desc("Disable Machine Common Subexpression Elimination")); +static cl::opt + EnableShrinkWrapOpt("enable-shrink-wrap", cl::Hidden, + cl::desc("enable the shrink-wrapping pass")); static cl::opt OptimizeRegAlloc( "optimize-regalloc", cl::Hidden, cl::desc("Enable optimized register allocation compilation path.")); @@ -218,7 +221,7 @@ 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) { + DisableVerify(false), EnableTailMerge(true), EnableShrinkWrap(false) { Impl = new PassConfigImpl(); @@ -540,8 +543,8 @@ void TargetPassConfig::addMachinePasses() { addPostRegAlloc(); // Insert prolog/epilog code. Eliminate abstract frame index references... - if (getOptLevel() != CodeGenOpt::None) - addPass(createShrinkWrapPass()); + if (getEnableShrinkWrap()) + addPass(&ShrinkWrapID); addPass(&PrologEpilogCodeInserterID); /// Add passes that optimize machine instructions after register allocation. @@ -620,6 +623,21 @@ void TargetPassConfig::addMachineSSAOptimization() { 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 //===---------------------------------------------------------------------===// diff --git a/lib/CodeGen/ShrinkWrap.cpp b/lib/CodeGen/ShrinkWrap.cpp index 43b39e934c4..8af859f6bc7 100644 --- a/lib/CodeGen/ShrinkWrap.cpp +++ b/lib/CodeGen/ShrinkWrap.cpp @@ -68,16 +68,11 @@ #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 - 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, @@ -159,11 +154,6 @@ public: ShrinkWrap() : MachineFunctionPass(ID) { initializeShrinkWrapPass(*PassRegistry::getPassRegistry()); } - - ShrinkWrap(std::function Ftor) : - MachineFunctionPass(ID), PredicateFtor(Ftor) { - initializeShrinkWrapPass(*PassRegistry::getPassRegistry()); - } void getAnalysisUsage(AnalysisUsage &AU) const override { AU.setPreservesAll(); @@ -181,15 +171,6 @@ public: /// \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. - /// \arg MF The MachineFunction to run shrink wrapping on. - /// It returns true if shrink wrapping should be run, false otherwise. - std::function PredicateFtor; }; } // End anonymous namespace. @@ -338,12 +319,8 @@ void ShrinkWrap::updateSaveRestorePoints(MachineBasicBlock &MBB) { } bool ShrinkWrap::runOnMachineFunction(MachineFunction &MF) { - if (PredicateFtor && !PredicateFtor(MF)) + if (MF.empty()) return false; - - if (MF.empty() || skipOptnoneFunction(*MF.getFunction())) - return false; - DEBUG(dbgs() << "**** Analysing " << MF.getName() << '\n'); init(MF); @@ -427,26 +404,3 @@ bool ShrinkWrap::runOnMachineFunction(MachineFunction &MF) { ++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 Ftor = - std::bind(&TargetPassConfig::runShrinkWrap, this, std::placeholders::_1); - return new ShrinkWrap(Ftor); -}