mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-13 20:32:21 +00:00
5a9cd4d44e
a cache of assumptions for a single function, and an immutable pass that manages those caches. The motivation for this change is two fold. Immutable analyses are really hacks around the current pass manager design and don't exist in the new design. This is usually OK, but it requires that the core logic of an immutable pass be reasonably partitioned off from the pass logic. This change does precisely that. As a consequence it also paves the way for the *many* utility functions that deal in the assumptions to live in both pass manager worlds by creating an separate non-pass object with its own independent API that they all rely on. Now, the only bits of the system that deal with the actual pass mechanics are those that actually need to deal with the pass mechanics. Once this separation is made, several simplifications become pretty obvious in the assumption cache itself. Rather than using a set and callback value handles, it can just be a vector of weak value handles. The callers can easily skip the handles that are null, and eventually we can wrap all of this up behind a filter iterator. For now, this adds boiler plate to the various passes, but this kind of boiler plate will end up making it possible to port these passes to the new pass manager, and so it will end up factored away pretty reasonably. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@225131 91177308-0d34-0410-b5e6-96231b3b80d8
118 lines
4.0 KiB
C++
118 lines
4.0 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.h"
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
|
#include "llvm/Analysis/AssumptionCache.h"
|
|
#include "llvm/Analysis/CallGraph.h"
|
|
#include "llvm/Analysis/InlineCost.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"
|
|
|
|
using namespace llvm;
|
|
|
|
#define DEBUG_TYPE "inline"
|
|
|
|
namespace {
|
|
|
|
/// \brief Inliner pass which only handles "always inline" functions.
|
|
class AlwaysInliner : public Inliner {
|
|
InlineCostAnalysis *ICA;
|
|
|
|
public:
|
|
// Use extremely low threshold.
|
|
AlwaysInliner() : Inliner(ID, -2000000000, /*InsertLifetime*/ true),
|
|
ICA(nullptr) {
|
|
initializeAlwaysInlinerPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
AlwaysInliner(bool InsertLifetime)
|
|
: Inliner(ID, -2000000000, InsertLifetime), ICA(nullptr) {
|
|
initializeAlwaysInlinerPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
static char ID; // Pass identification, replacement for typeid
|
|
|
|
InlineCost getInlineCost(CallSite CS) override;
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override;
|
|
bool runOnSCC(CallGraphSCC &SCC) override;
|
|
|
|
using llvm::Pass::doFinalization;
|
|
bool doFinalization(CallGraph &CG) override {
|
|
return removeDeadFunctions(CG, /*AlwaysInlineOnly=*/ true);
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
char AlwaysInliner::ID = 0;
|
|
INITIALIZE_PASS_BEGIN(AlwaysInliner, "always-inline",
|
|
"Inliner for always_inline functions", false, false)
|
|
INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
|
|
INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
|
|
INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
|
|
INITIALIZE_PASS_DEPENDENCY(InlineCostAnalysis)
|
|
INITIALIZE_PASS_END(AlwaysInliner, "always-inline",
|
|
"Inliner for always_inline functions", false, false)
|
|
|
|
Pass *llvm::createAlwaysInlinerPass() { return new AlwaysInliner(); }
|
|
|
|
Pass *llvm::createAlwaysInlinerPass(bool InsertLifetime) {
|
|
return new AlwaysInliner(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 AlwaysInliner::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) &&
|
|
ICA->isInlineViable(*Callee))
|
|
return InlineCost::getAlways();
|
|
|
|
return InlineCost::getNever();
|
|
}
|
|
|
|
bool AlwaysInliner::runOnSCC(CallGraphSCC &SCC) {
|
|
ICA = &getAnalysis<InlineCostAnalysis>();
|
|
return Inliner::runOnSCC(SCC);
|
|
}
|
|
|
|
void AlwaysInliner::getAnalysisUsage(AnalysisUsage &AU) const {
|
|
AU.addRequired<InlineCostAnalysis>();
|
|
Inliner::getAnalysisUsage(AU);
|
|
}
|