Members/tobaru/cbc/CbC_llvm: lib/Transforms/IPO/Inliner.cpp comparison

comparison lib/Transforms/IPO/Inliner.cpp @ 80:67baa08a3894

update to LLVM 3.6

author	Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date	Thu, 25 Sep 2014 16:56:18 +0900
parents	54457678186b
children	60c9769439b8

comparison

equal deleted inserted replaced

-:9e74acfe8c42
+:67baa08a3894
 // missing any calls and updating the call graph.  The decisions of which calls
 // are profitable to inline are implemented elsewhere.
 //
 //===----------------------------------------------------------------------===//
-#define DEBUG_TYPE "inline"
 #include "llvm/Transforms/IPO/InlinerPass.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/Analysis/AssumptionTracker.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/InlineCost.h"
+#include "llvm/IR/CallSite.h"
 #include "llvm/IR/DataLayout.h"
+#include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
-#include "llvm/Support/CallSite.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetLibraryInfo.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Transforms/Utils/Local.h"
 using namespace llvm;
+#define DEBUG_TYPE "inline"
 STATISTIC(NumInlined, "Number of functions inlined");
 STATISTIC(NumCallsDeleted, "Number of call sites deleted, not inlined");
 STATISTIC(NumDeleted, "Number of functions deleted because all callers found");
 STATISTIC(NumMergedAllocas, "Number of allocas merged together");
 static cl::opt<int>
 HintThreshold("inlinehint-threshold", cl::Hidden, cl::init(325),
 cl::desc("Threshold for inlining functions with inline hint"));
+// We instroduce this threshold to help performance of instrumentation based
+// PGO before we actually hook up inliner with analysis passes such as BPI and
+// BFI.
+static cl::opt<int>
+ColdThreshold("inlinecold-threshold", cl::Hidden, cl::init(225),
+cl::desc("Threshold for inlining functions with cold attribute"));
 // Threshold to use when optsize is specified (and there is no -inline-limit).
 const int OptSizeThreshold = 75;
 Inliner::Inliner(char &ID)
 : CallGraphSCCPass(ID), InlineThreshold(InlineLimit), InsertLifetime(true) {}
 /// getAnalysisUsage - For this class, we declare that we require and preserve
 /// the call graph.  If the derived class implements this method, it should
 /// always explicitly call the implementation here.
 void Inliner::getAnalysisUsage(AnalysisUsage &AU) const {
+AU.addRequired<AliasAnalysis>();
+AU.addRequired<AssumptionTracker>();
 CallGraphSCCPass::getAnalysisUsage(AU);
 }
 typedef DenseMap<ArrayType*, std::vector<AllocaInst*> >
 /// inline this call site we attempt to reuse already available allocas or add
 /// any new allocas to the set if not possible.
 static bool InlineCallIfPossible(CallSite CS, InlineFunctionInfo &IFI,
 InlinedArrayAllocasTy &InlinedArrayAllocas,
 int InlineHistory, bool InsertLifetime,
-const DataLayout *TD) {
+const DataLayout *DL) {
 Function *Callee = CS.getCalledFunction();
 Function *Caller = CS.getCaller();
 // Try to inline the function.  Get the list of static allocas that were
 // inlined.
 // Don't bother trying to merge array allocations (they will usually be
 // canonicalized to be an allocation *of* an array), or allocations whose
 // type is not itself an array (because we're afraid of pessimizing SRoA).
 ArrayType *ATy = dyn_cast<ArrayType>(AI->getAllocatedType());
-if (ATy == 0 || AI->isArrayAllocation())
+if (!ATy || AI->isArrayAllocation())
 continue;
 // Get the list of all available allocas for this array type.
 std::vector<AllocaInst*> &AllocasForType = InlinedArrayAllocas[ATy];
 unsigned Align1 = AI->getAlignment(),
 Align2 = AvailableAlloca->getAlignment();
 // If we don't have data layout information, and only one alloca is using
 // the target default, then we can't safely merge them because we can't
 // pick the greater alignment.
-if (!TD && (!Align1 || !Align2) && Align1 != Align2)
+if (!DL && (!Align1 || !Align2) && Align1 != Align2)
 continue;
 // The available alloca has to be in the right function, not in some other
 // function in this SCC.
 if (AvailableAlloca->getParent() != AI->getParent())
 AI->replaceAllUsesWith(AvailableAlloca);
 if (Align1 != Align2) {
 if (!Align1 || !Align2) {
-assert(TD && "DataLayout required to compare default alignments");
+assert(DL && "DataLayout required to compare default alignments");
-unsigned TypeAlign = TD->getABITypeAlignment(AI->getAllocatedType());
+unsigned TypeAlign = DL->getABITypeAlignment(AI->getAllocatedType());
 Align1 = Align1 ? Align1 : TypeAlign;
 Align2 = Align2 ? Align2 : TypeAlign;
 }
 }
 AI->eraseFromParent();
 MergedAwayAlloca = true;
 ++NumMergedAllocas;
-IFI.StaticAllocas[AllocaNo] = 0;
+IFI.StaticAllocas[AllocaNo] = nullptr;
 break;
 }
 // If we already nuked the alloca, we're done with it.
 if (MergedAwayAlloca)
 if (InlineHint && HintThreshold > thres
 && !Caller->getAttributes().hasAttribute(AttributeSet::FunctionIndex,
 Attribute::MinSize))
 thres = HintThreshold;
+// Listen to the cold attribute when it would decrease the threshold.
+bool ColdCallee = Callee && !Callee->isDeclaration() &&
+Callee->getAttributes().hasAttribute(AttributeSet::FunctionIndex,
+Attribute::Cold);
+// Command line argument for InlineLimit will override the default
+// ColdThreshold. If we have -inline-threshold but no -inlinecold-threshold,
+// do not use the default cold threshold even if it is smaller.
+if ((InlineLimit.getNumOccurrences() == 0 ||
+ColdThreshold.getNumOccurrences() > 0) && ColdCallee &&
+ColdThreshold < thres)
+thres = ColdThreshold;
 return thres;
+}
+static void emitAnalysis(CallSite CS, const Twine &Msg) {
+Function *Caller = CS.getCaller();
+LLVMContext &Ctx = Caller->getContext();
+DebugLoc DLoc = CS.getInstruction()->getDebugLoc();
+emitOptimizationRemarkAnalysis(Ctx, DEBUG_TYPE, *Caller, DLoc, Msg);
 }
 /// shouldInline - Return true if the inliner should attempt to inline
 /// at the given CallSite.
 bool Inliner::shouldInline(CallSite CS) {
 InlineCost IC = getInlineCost(CS);
 if (IC.isAlways()) {
 DEBUG(dbgs() << "    Inlining: cost=always"
 << ", Call: " << *CS.getInstruction() << "\n");
+emitAnalysis(CS, Twine(CS.getCalledFunction()->getName()) +
+" should always be inlined (cost=always)");
 return true;
 }
 if (IC.isNever()) {
 DEBUG(dbgs() << "    NOT Inlining: cost=never"
 << ", Call: " << *CS.getInstruction() << "\n");
+emitAnalysis(CS, Twine(CS.getCalledFunction()->getName() +
+" should never be inlined (cost=never)"));
 return false;
 }
 Function *Caller = CS.getCaller();
 if (!IC) {
 DEBUG(dbgs() << "    NOT Inlining: cost=" << IC.getCost()
 << ", thres=" << (IC.getCostDelta() + IC.getCost())
 << ", Call: " << *CS.getInstruction() << "\n");
+emitAnalysis(CS, Twine(CS.getCalledFunction()->getName() +
+" too costly to inline (cost=") +
+Twine(IC.getCost()) + ", threshold=" +
+Twine(IC.getCostDelta() + IC.getCost()) + ")");
 return false;
 }
 // Try to detect the case where the current inlining candidate caller (call
 // it B) is a static or linkonce-ODR function and is an inlining candidate
 // and templates in C++.
 //
 // FIXME: All of this logic should be sunk into getInlineCost. It relies on
 // the internal implementation of the inline cost metrics rather than
 // treating them as truly abstract units etc.
-if (Caller->hasLocalLinkage() ||
+if (Caller->hasLocalLinkage() || Caller->hasLinkOnceODRLinkage()) {
-Caller->getLinkage() == GlobalValue::LinkOnceODRLinkage) {
 int TotalSecondaryCost = 0;
 // The candidate cost to be imposed upon the current function.
 int CandidateCost = IC.getCost() - (InlineConstants::CallPenalty + 1);
 // This bool tracks what happens if we do NOT inline C into B.
 bool callerWillBeRemoved = Caller->hasLocalLinkage();
 // This bool tracks what happens if we DO inline C into B.
 bool inliningPreventsSomeOuterInline = false;
-for (Value::use_iterator I = Caller->use_begin(), E =Caller->use_end();
+for (User *U : Caller->users()) {
-I != E; ++I) {
+CallSite CS2(U);
-CallSite CS2(*I);
 // If this isn't a call to Caller (it could be some other sort
 // of reference) skip it.  Such references will prevent the caller
 // from being removed.
 if (!CS2 || CS2.getCalledFunction() != Caller) {
 }
 // If all outer calls to Caller would get inlined, the cost for the last
 // one is set very low by getInlineCost, in anticipation that Caller will
 // be removed entirely.  We did not account for this above unless there
 // is only one caller of Caller.
-if (callerWillBeRemoved && Caller->use_begin() != Caller->use_end())
+if (callerWillBeRemoved && !Caller->use_empty())
 TotalSecondaryCost += InlineConstants::LastCallToStaticBonus;
 if (inliningPreventsSomeOuterInline && TotalSecondaryCost < IC.getCost()) {
 DEBUG(dbgs() << "    NOT Inlining: " << *CS.getInstruction() <<
 " Cost = " << IC.getCost() <<
 ", outer Cost = " << TotalSecondaryCost << '\n');
+emitAnalysis(
+CS, Twine("Not inlining. Cost of inlining " +
+CS.getCalledFunction()->getName() +
+" increases the cost of inlining " +
+CS.getCaller()->getName() + " in other contexts"));
 return false;
 }
 }
 DEBUG(dbgs() << "    Inlining: cost=" << IC.getCost()
 << ", thres=" << (IC.getCostDelta() + IC.getCost())
 << ", Call: " << *CS.getInstruction() << '\n');
+emitAnalysis(
+CS, CS.getCalledFunction()->getName() + Twine(" can be inlined into ") +
+CS.getCaller()->getName() + " with cost=" + Twine(IC.getCost()) +
+" (threshold=" + Twine(IC.getCostDelta() + IC.getCost()) + ")");
 return true;
 }
 /// InlineHistoryIncludes - Return true if the specified inline history ID
 /// indicates an inline history that includes the specified function.
 return false;
 }
 bool Inliner::runOnSCC(CallGraphSCC &SCC) {
 CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
-const DataLayout *TD = getAnalysisIfAvailable<DataLayout>();
+AssumptionTracker *AT = &getAnalysis<AssumptionTracker>();
+DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
+const DataLayout *DL = DLP ? &DLP->getDataLayout() : nullptr;
 const TargetLibraryInfo *TLI = getAnalysisIfAvailable<TargetLibraryInfo>();
+AliasAnalysis *AA = &getAnalysis<AliasAnalysis>();
 SmallPtrSet<Function*, 8> SCCFunctions;
 DEBUG(dbgs() << "Inliner visiting SCC:");
 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
 Function *F = (*I)->getFunction();
 if (SCCFunctions.count(F))
 std::swap(CallSites[i--], CallSites[--FirstCallInSCC]);
 InlinedArrayAllocasTy InlinedArrayAllocas;
-InlineFunctionInfo InlineInfo(&CG, TD);
+InlineFunctionInfo InlineInfo(&CG, DL, AA, AT);
 // Now that we have all of the call sites, loop over them and inline them if
 // it looks profitable to do so.
 bool Changed = false;
 bool LocalChange;
 CG[Caller]->removeCallEdgeFor(CS);
 CS.getInstruction()->eraseFromParent();
 ++NumCallsDeleted;
 } else {
 // We can only inline direct calls to non-declarations.
-if (Callee == 0 || Callee->isDeclaration()) continue;
+if (!Callee || Callee->isDeclaration()) continue;
 // If this call site was obtained by inlining another function, verify
 // that the include path for the function did not include the callee
 // itself.  If so, we'd be recursively inlining the same function,
 // which would provide the same callsites, which would cause us to
 int InlineHistoryID = CallSites[CSi].second;
 if (InlineHistoryID != -1 &&
 InlineHistoryIncludes(Callee, InlineHistoryID, InlineHistory))
 continue;
+LLVMContext &CallerCtx = Caller->getContext();
+// Get DebugLoc to report. CS will be invalid after Inliner.
+DebugLoc DLoc = CS.getInstruction()->getDebugLoc();
 // If the policy determines that we should inline this function,
 // try to do so.
-if (!shouldInline(CS))
+if (!shouldInline(CS)) {
+emitOptimizationRemarkMissed(CallerCtx, DEBUG_TYPE, *Caller, DLoc,
+Twine(Callee->getName() +
+" will not be inlined into " +
+Caller->getName()));
 continue;
+}
 // Attempt to inline the function.
 if (!InlineCallIfPossible(CS, InlineInfo, InlinedArrayAllocas,
-InlineHistoryID, InsertLifetime, TD))
+InlineHistoryID, InsertLifetime, DL)) {
+emitOptimizationRemarkMissed(CallerCtx, DEBUG_TYPE, *Caller, DLoc,
+Twine(Callee->getName() +
+" will not be inlined into " +
+Caller->getName()));
 continue;
+}
 ++NumInlined;
+// Report the inline decision.
+emitOptimizationRemark(
+CallerCtx, DEBUG_TYPE, *Caller, DLoc,
+Twine(Callee->getName() + " inlined into " + Caller->getName()));
 // If inlining this function gave us any new call sites, throw them
 // onto our worklist to process.  They are useful inline candidates.
 if (!InlineInfo.InlinedCalls.empty()) {
 // Create a new inline history entry for this, so that we remember
 // that these new callsites came about due to inlining Callee.

Mercurial > hg > Members > tobaru > cbc > CbC_llvm

comparison lib/Transforms/IPO/Inliner.cpp @ 80:67baa08a3894