llvm-6502/include/llvm/Transforms/IPO/InlinerPass.h
Chandler Carruth 45de584b4f Remove a bunch of empty, dead, and no-op methods from all of these
interfaces. These methods were used in the old inline cost system where
there was a persistent cache that had to be updated, invalidated, and
cleared. We're now doing more direct computations that don't require
this intricate dance. Even if we resume some level of caching, it would
almost certainly have a simpler and more narrow interface than this.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@153813 91177308-0d34-0410-b5e6-96231b3b80d8
2012-03-31 12:48:08 +00:00

91 lines
3.3 KiB
C++

//===- InlinerPass.h - Code common to all inliners --------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines a simple policy-based bottom-up inliner. This file
// implements all of the boring mechanics of the bottom-up inlining, while the
// subclass determines WHAT to inline, which is the much more interesting
// component.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TRANSFORMS_IPO_INLINERPASS_H
#define LLVM_TRANSFORMS_IPO_INLINERPASS_H
#include "llvm/CallGraphSCCPass.h"
namespace llvm {
class CallSite;
class TargetData;
class InlineCost;
template<class PtrType, unsigned SmallSize>
class SmallPtrSet;
/// Inliner - This class contains all of the helper code which is used to
/// perform the inlining operations that do not depend on the policy.
///
struct Inliner : public CallGraphSCCPass {
explicit Inliner(char &ID);
explicit Inliner(char &ID, int Threshold, bool InsertLifetime);
/// 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.
virtual void getAnalysisUsage(AnalysisUsage &Info) const;
// Main run interface method, this implements the interface required by the
// Pass class.
virtual bool runOnSCC(CallGraphSCC &SCC);
// doFinalization - Remove now-dead linkonce functions at the end of
// processing to avoid breaking the SCC traversal.
virtual bool doFinalization(CallGraph &CG);
/// This method returns the value specified by the -inline-threshold value,
/// specified on the command line. This is typically not directly needed.
///
unsigned getInlineThreshold() const { return InlineThreshold; }
/// Calculate the inline threshold for given Caller. This threshold is lower
/// if the caller is marked with OptimizeForSize and -inline-threshold is not
/// given on the comand line. It is higher if the callee is marked with the
/// inlinehint attribute.
///
unsigned getInlineThreshold(CallSite CS) const;
/// getInlineCost - This method must be implemented by the subclass to
/// determine the cost of inlining the specified call site. If the cost
/// returned is greater than the current inline threshold, the call site is
/// not inlined.
///
virtual InlineCost getInlineCost(CallSite CS) = 0;
/// removeDeadFunctions - Remove dead functions.
///
/// This also includes a hack in the form of the 'AlwaysInlineOnly' flag
/// which restricts it to deleting functions with an 'AlwaysInline'
/// attribute. This is useful for the InlineAlways pass that only wants to
/// deal with that subset of the functions.
bool removeDeadFunctions(CallGraph &CG, bool AlwaysInlineOnly = false);
private:
// InlineThreshold - Cache the value here for easy access.
unsigned InlineThreshold;
// InsertLifetime - Insert @llvm.lifetime intrinsics.
bool InsertLifetime;
/// shouldInline - Return true if the inliner should attempt to
/// inline at the given CallSite.
bool shouldInline(CallSite CS);
};
} // End llvm namespace
#endif