mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-22 04:22:57 +02:00
90665f11d7
minimal and boring form than the old pass manager's version. This pass does the very minimal amount of work necessary to inline functions declared as always-inline. It doesn't support a wide array of things that the legacy pass manager did support, but is alse ... about 20 lines of code. So it has that going for it. Notably things this doesn't support: - Array alloca merging - To support the above, bottom-up inlining with careful history tracking and call graph updates - DCE of the functions that become dead after this inlining. - Inlining through call instructions with the always_inline attribute. Instead, it focuses on inlining functions with that attribute. The first I've omitted because I'm hoping to just turn it off for the primary pass manager. If that doesn't pan out, I can add it here but it will be reasonably expensive to do so. The second should really be handled by running global-dce after the inliner. I don't want to re-implement the non-trivial logic necessary to do comdat-correct DCE of functions. This means the -O0 pipeline will have to be at least 'always-inline,global-dce', but that seems reasonable to me. If others are seriously worried about this I'd like to hear about it and understand why. Again, this is all solveable by factoring that logic into a utility and calling it here, but I'd like to wait to do that until there is a clear reason why the existing pass-based factoring won't work. The final point is a serious one. I can fairly easily add support for this, but it seems both costly and a confusing construct for the use case of the always inliner running at -O0. This attribute can of course still impact the normal inliner easily (although I find that a questionable re-use of the same attribute). I've started a discussion to sort out what semantics we want here and based on that can figure out if it makes sense ta have this complexity at O0 or not. One other advantage of this design is that it should be quite a bit faster due to checking for whether the function is a viable candidate for inlining exactly once per function instead of doing it for each call site. Anyways, hopefully a reasonable starting point for this pass. Differential Revision: https://reviews.llvm.org/D23299 llvm-svn: 278896
128 lines
4.7 KiB
C++
128 lines
4.7 KiB
C++
//===- InlineAlways.cpp - Code to inline always_inline functions ----------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements a custom inliner that handles only functions that
|
|
// are marked as "always inline".
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Transforms/IPO/AlwaysInliner.h"
|
|
#include "llvm/ADT/SetVector.h"
|
|
#include "llvm/Analysis/AssumptionCache.h"
|
|
#include "llvm/Analysis/CallGraph.h"
|
|
#include "llvm/Analysis/InlineCost.h"
|
|
#include "llvm/Analysis/ProfileSummaryInfo.h"
|
|
#include "llvm/Analysis/TargetLibraryInfo.h"
|
|
#include "llvm/IR/CallSite.h"
|
|
#include "llvm/IR/CallingConv.h"
|
|
#include "llvm/IR/DataLayout.h"
|
|
#include "llvm/IR/Instructions.h"
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/IR/Type.h"
|
|
#include "llvm/Transforms/IPO/InlinerPass.h"
|
|
#include "llvm/Transforms/Utils/Cloning.h"
|
|
|
|
using namespace llvm;
|
|
|
|
#define DEBUG_TYPE "inline"
|
|
|
|
PreservedAnalyses AlwaysInlinerPass::run(Module &M, ModuleAnalysisManager &) {
|
|
InlineFunctionInfo IFI;
|
|
SmallSetVector<CallSite, 16> Calls;
|
|
bool Changed = false;
|
|
for (Function &F : M)
|
|
if (!F.isDeclaration() && F.hasFnAttribute(Attribute::AlwaysInline) &&
|
|
isInlineViable(F)) {
|
|
Calls.clear();
|
|
|
|
for (User *U : F.users())
|
|
if (auto CS = CallSite(U))
|
|
if (CS.getCalledFunction() == &F)
|
|
Calls.insert(CS);
|
|
|
|
for (CallSite CS : Calls)
|
|
// FIXME: We really shouldn't be able to fail to inline at this point!
|
|
// We should do something to log or check the inline failures here.
|
|
Changed |= InlineFunction(CS, IFI);
|
|
}
|
|
|
|
return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
|
|
}
|
|
|
|
namespace {
|
|
|
|
/// Inliner pass which only handles "always inline" functions.
|
|
///
|
|
/// Unlike the \c AlwaysInlinerPass, this uses the more heavyweight \c Inliner
|
|
/// base class to provide several facilities such as array alloca merging.
|
|
class AlwaysInlinerLegacyPass : public Inliner {
|
|
|
|
public:
|
|
AlwaysInlinerLegacyPass() : Inliner(ID, /*InsertLifetime*/ true) {
|
|
initializeAlwaysInlinerLegacyPassPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
AlwaysInlinerLegacyPass(bool InsertLifetime) : Inliner(ID, InsertLifetime) {
|
|
initializeAlwaysInlinerLegacyPassPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
/// Main run interface method. We override here to avoid calling skipSCC().
|
|
bool runOnSCC(CallGraphSCC &SCC) override { return inlineCalls(SCC); }
|
|
|
|
static char ID; // Pass identification, replacement for typeid
|
|
|
|
InlineCost getInlineCost(CallSite CS) override;
|
|
|
|
using llvm::Pass::doFinalization;
|
|
bool doFinalization(CallGraph &CG) override {
|
|
return removeDeadFunctions(CG, /*AlwaysInlineOnly=*/true);
|
|
}
|
|
};
|
|
}
|
|
|
|
char AlwaysInlinerLegacyPass::ID = 0;
|
|
INITIALIZE_PASS_BEGIN(AlwaysInlinerLegacyPass, "always-inline",
|
|
"Inliner for always_inline functions", false, false)
|
|
INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
|
|
INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
|
|
INITIALIZE_PASS_DEPENDENCY(ProfileSummaryInfoWrapperPass)
|
|
INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
|
|
INITIALIZE_PASS_END(AlwaysInlinerLegacyPass, "always-inline",
|
|
"Inliner for always_inline functions", false, false)
|
|
|
|
Pass *llvm::createAlwaysInlinerLegacyPass(bool InsertLifetime) {
|
|
return new AlwaysInlinerLegacyPass(InsertLifetime);
|
|
}
|
|
|
|
/// \brief Get the inline cost for the always-inliner.
|
|
///
|
|
/// The always inliner *only* handles functions which are marked with the
|
|
/// attribute to force inlining. As such, it is dramatically simpler and avoids
|
|
/// using the powerful (but expensive) inline cost analysis. Instead it uses
|
|
/// a very simple and boring direct walk of the instructions looking for
|
|
/// impossible-to-inline constructs.
|
|
///
|
|
/// Note, it would be possible to go to some lengths to cache the information
|
|
/// computed here, but as we only expect to do this for relatively few and
|
|
/// small functions which have the explicit attribute to force inlining, it is
|
|
/// likely not worth it in practice.
|
|
InlineCost AlwaysInlinerLegacyPass::getInlineCost(CallSite CS) {
|
|
Function *Callee = CS.getCalledFunction();
|
|
|
|
// Only inline direct calls to functions with always-inline attributes
|
|
// that are viable for inlining. FIXME: We shouldn't even get here for
|
|
// declarations.
|
|
if (Callee && !Callee->isDeclaration() &&
|
|
CS.hasFnAttr(Attribute::AlwaysInline) && isInlineViable(*Callee))
|
|
return InlineCost::getAlways();
|
|
|
|
return InlineCost::getNever();
|
|
}
|