mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-07-21 18:29:45 +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
106 lines
3.2 KiB
C++
106 lines
3.2 KiB
C++
//===- InlineSimple.cpp - Code to perform simple function inlining --------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements bottom-up inlining of functions into callees.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Transforms/IPO.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 Actual inliner pass implementation.
|
|
///
|
|
/// The common implementation of the inlining logic is shared between this
|
|
/// inliner pass and the always inliner pass. The two passes use different cost
|
|
/// analyses to determine when to inline.
|
|
class SimpleInliner : public Inliner {
|
|
InlineCostAnalysis *ICA;
|
|
|
|
public:
|
|
SimpleInliner() : Inliner(ID), ICA(nullptr) {
|
|
initializeSimpleInlinerPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
SimpleInliner(int Threshold)
|
|
: Inliner(ID, Threshold, /*InsertLifetime*/ true), ICA(nullptr) {
|
|
initializeSimpleInlinerPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
static char ID; // Pass identification, replacement for typeid
|
|
|
|
InlineCost getInlineCost(CallSite CS) override {
|
|
return ICA->getInlineCost(CS, getInlineThreshold(CS));
|
|
}
|
|
|
|
bool runOnSCC(CallGraphSCC &SCC) override;
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override;
|
|
};
|
|
|
|
static int computeThresholdFromOptLevels(unsigned OptLevel,
|
|
unsigned SizeOptLevel) {
|
|
if (OptLevel > 2)
|
|
return 275;
|
|
if (SizeOptLevel == 1) // -Os
|
|
return 75;
|
|
if (SizeOptLevel == 2) // -Oz
|
|
return 25;
|
|
return 225;
|
|
}
|
|
|
|
} // end anonymous namespace
|
|
|
|
char SimpleInliner::ID = 0;
|
|
INITIALIZE_PASS_BEGIN(SimpleInliner, "inline",
|
|
"Function Integration/Inlining", false, false)
|
|
INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
|
|
INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
|
|
INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
|
|
INITIALIZE_PASS_DEPENDENCY(InlineCostAnalysis)
|
|
INITIALIZE_PASS_END(SimpleInliner, "inline",
|
|
"Function Integration/Inlining", false, false)
|
|
|
|
Pass *llvm::createFunctionInliningPass() { return new SimpleInliner(); }
|
|
|
|
Pass *llvm::createFunctionInliningPass(int Threshold) {
|
|
return new SimpleInliner(Threshold);
|
|
}
|
|
|
|
Pass *llvm::createFunctionInliningPass(unsigned OptLevel,
|
|
unsigned SizeOptLevel) {
|
|
return new SimpleInliner(
|
|
computeThresholdFromOptLevels(OptLevel, SizeOptLevel));
|
|
}
|
|
|
|
bool SimpleInliner::runOnSCC(CallGraphSCC &SCC) {
|
|
ICA = &getAnalysis<InlineCostAnalysis>();
|
|
return Inliner::runOnSCC(SCC);
|
|
}
|
|
|
|
void SimpleInliner::getAnalysisUsage(AnalysisUsage &AU) const {
|
|
AU.addRequired<InlineCostAnalysis>();
|
|
Inliner::getAnalysisUsage(AU);
|
|
}
|