#include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/Compiler.h"
#include <set>
using namespace llvm;
namespace {
/// ArgPromotion - The 'by reference' to 'by value' argument promotion pass.
///
- struct ArgPromotion : public CallGraphSCCPass {
+ struct VISIBILITY_HIDDEN ArgPromotion : public CallGraphSCCPass {
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<AliasAnalysis>();
AU.addRequired<TargetData>();
#include "llvm/Module.h"
#include "llvm/Pass.h"
#include "llvm/ADT/Statistic.h"
+#include "llvm/Support/Compiler.h"
using namespace llvm;
STATISTIC(NumMerged, "Number of global constants merged");
namespace {
- struct ConstantMerge : public ModulePass {
+ struct VISIBILITY_HIDDEN ConstantMerge : public ModulePass {
// run - For this pass, process all of the globals in the module,
// eliminating duplicate constants.
//
#include "llvm/Support/CallSite.h"
#include "llvm/Support/Debug.h"
#include "llvm/ADT/Statistic.h"
+#include "llvm/Support/Compiler.h"
#include <set>
using namespace llvm;
namespace {
/// DAE - The dead argument elimination pass.
///
- class DAE : public ModulePass {
+ class VISIBILITY_HIDDEN DAE : public ModulePass {
/// Liveness enum - During our initial pass over the program, we determine
/// that things are either definately alive, definately dead, or in need of
/// interprocedural analysis (MaybeLive).
#include "llvm/TypeSymbolTable.h"
#include "llvm/DerivedTypes.h"
#include "llvm/ADT/Statistic.h"
+#include "llvm/Support/Compiler.h"
using namespace llvm;
STATISTIC(NumKilled, "Number of unused typenames removed from symtab");
namespace {
- struct DTE : public ModulePass {
+ struct VISIBILITY_HIDDEN DTE : public ModulePass {
// doPassInitialization - For this pass, it removes global symbol table
// entries for primitive types. These are never used for linking in GCC and
// they make the output uglier to look at, so we nuke them.
#include "llvm/Module.h"
#include "llvm/Pass.h"
#include "llvm/Transforms/IPO.h"
+#include "llvm/Support/Compiler.h"
using namespace llvm;
namespace {
- class FunctionExtractorPass : public ModulePass {
+ /// @brief A pass to extract specific functions and their dependencies.
+ class VISIBILITY_HIDDEN FunctionExtractorPass : public ModulePass {
Function *Named;
bool deleteFunc;
bool reLink;
#include "llvm/Module.h"
#include "llvm/Pass.h"
#include "llvm/ADT/Statistic.h"
+#include "llvm/Support/Compiler.h"
#include <set>
using namespace llvm;
STATISTIC(NumVariables, "Number of global variables removed");
namespace {
- struct GlobalDCE : public ModulePass {
+ struct VISIBILITY_HIDDEN GlobalDCE : public ModulePass {
// run - Do the GlobalDCE pass on the specified module, optionally updating
// the specified callgraph to reflect the changes.
//
#include "llvm/Pass.h"
#include "llvm/Analysis/ConstantFolding.h"
#include "llvm/Target/TargetData.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Statistic.h"
STATISTIC(NumCtorsEvaluated, "Number of static ctors evaluated");
namespace {
- struct GlobalOpt : public ModulePass {
+ struct VISIBILITY_HIDDEN GlobalOpt : public ModulePass {
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<TargetData>();
}
/// GlobalStatus - As we analyze each global, keep track of some information
/// about it. If we find out that the address of the global is taken, none of
/// this info will be accurate.
-struct GlobalStatus {
+struct VISIBILITY_HIDDEN GlobalStatus {
/// isLoaded - True if the global is ever loaded. If the global isn't ever
/// loaded it can be deleted.
bool isLoaded;
#include "llvm/Module.h"
#include "llvm/Pass.h"
#include "llvm/Support/CallSite.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/ADT/Statistic.h"
using namespace llvm;
namespace {
/// IPCP - The interprocedural constant propagation pass
///
- struct IPCP : public ModulePass {
+ struct VISIBILITY_HIDDEN IPCP : public ModulePass {
bool runOnModule(Module &M);
private:
bool PropagateConstantsIntoArguments(Function &F);
#include "llvm/Type.h"
#include "llvm/DerivedTypes.h"
#include "llvm/ADT/Statistic.h"
+#include "llvm/Support/Compiler.h"
using namespace llvm;
STATISTIC(NumBounceSites, "Number of sites modified");
STATISTIC(NumBounce , "Number of bounce functions created");
namespace {
- class IndMemRemPass : public ModulePass {
+ class VISIBILITY_HIDDEN IndMemRemPass : public ModulePass {
public:
virtual bool runOnModule(Module &M);
};
#include "llvm/Function.h"
#include "llvm/Type.h"
#include "llvm/Support/CallSite.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Transforms/IPO.h"
using namespace llvm;
namespace {
- struct ArgInfo {
+ struct VISIBILITY_HIDDEN ArgInfo {
unsigned ConstantWeight;
unsigned AllocaWeight;
// FunctionInfo - For each function, calculate the size of it in blocks and
// instructions.
- struct FunctionInfo {
+ struct VISIBILITY_HIDDEN FunctionInfo {
// NumInsts, NumBlocks - Keep track of how large each function is, which is
// used to estimate the code size cost of inlining it.
unsigned NumInsts, NumBlocks;
void analyzeFunction(Function *F);
};
- class SimpleInliner : public Inliner {
+ class VISIBILITY_HIDDEN SimpleInliner : public Inliner {
std::map<const Function*, FunctionInfo> CachedFunctionInfo;
public:
int getInlineCost(CallSite CS);
#include "llvm/Pass.h"
#include "llvm/Module.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/ADT/Statistic.h"
#include <fstream>
cl::desc("A list of symbol names to preserve"),
cl::CommaSeparated);
- class InternalizePass : public ModulePass {
+ class VISIBILITY_HIDDEN InternalizePass : public ModulePass {
std::set<std::string> ExternalNames;
bool DontInternalize;
public:
#include "llvm/Pass.h"
#include "llvm/Analysis/Dominators.h"
#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Transforms/Utils/FunctionUtils.h"
#include "llvm/ADT/Statistic.h"
// FIXME: This is not a function pass, but the PassManager doesn't allow
// Module passes to require FunctionPasses, so we can't get loop info if we're
// not a function pass.
- struct LoopExtractor : public FunctionPass {
+ struct VISIBILITY_HIDDEN LoopExtractor : public FunctionPass {
unsigned NumLoops;
LoopExtractor(unsigned numLoops = ~0) : NumLoops(numLoops) {}
#include "llvm/Module.h"
#include "llvm/Pass.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/InstVisitor.h"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/ADT/DepthFirstIterator.h"
namespace {
//===--------------------------------------------------------------------===//
// LowerSetJmp pass implementation.
- class LowerSetJmp : public ModulePass,
+ class VISIBILITY_HIDDEN LowerSetJmp : public ModulePass,
public InstVisitor<LowerSetJmp> {
// LLVM library functions...
Constant *InitSJMap; // __llvm_sjljeh_init_setjmpmap
#include "llvm/Analysis/CallGraph.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Compiler.h"
#include <set>
#include <algorithm>
using namespace llvm;
STATISTIC(NumUnreach, "Number of noreturn calls optimized");
namespace {
- struct PruneEH : public CallGraphSCCPass {
+ struct VISIBILITY_HIDDEN PruneEH : public CallGraphSCCPass {
/// DoesNotUnwind - This set contains all of the functions which we have
/// determined cannot unwind.
std::set<CallGraphNode*> DoesNotUnwind;
#include "llvm/Instructions.h"
#include "llvm/Pass.h"
#include "llvm/Support/CallSite.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/ADT/Statistic.h"
using namespace llvm;
// RaiseAllocations - Turn %malloc and %free calls into the appropriate
// instruction.
//
- class RaiseAllocations : public ModulePass {
+ class VISIBILITY_HIDDEN RaiseAllocations : public ModulePass {
Function *MallocFunc; // Functions in the module we are processing
Function *FreeFunc; // Initialized by doPassInitializationVirt
public:
#include "llvm/ADT/hash_map"
#include "llvm/ADT/Statistic.h"
#include "llvm/Config/config.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Transforms/IPO.h"
/// generally short-circuit actually calling the function if there's a simpler
/// way (e.g. strlen(X) can be reduced to a constant if X is a constant global).
/// @brief Base class for library call optimizations
-class LibCallOptimization {
+class VISIBILITY_HIDDEN LibCallOptimization {
LibCallOptimization **Prev, *Next;
const char *FunctionName; ///< Name of the library call we optimize
#ifndef NDEBUG
/// validate the call (ValidateLibraryCall). If it is validated, then
/// the OptimizeCall method is also called.
/// @brief A ModulePass for optimizing well-known function calls.
-class SimplifyLibCalls : public ModulePass {
+class VISIBILITY_HIDDEN SimplifyLibCalls : public ModulePass {
public:
/// We need some target data for accurate signature details that are
/// target dependent. So we require target data in our AnalysisUsage.
namespace {
// Forward declare utility functions.
-bool getConstantStringLength(Value* V, uint64_t& len, ConstantArray** A = 0 );
-Value *CastToCStr(Value *V, Instruction &IP);
+static bool getConstantStringLength(Value* V, uint64_t& len,
+ ConstantArray** A = 0 );
+static Value *CastToCStr(Value *V, Instruction &IP);
/// This LibCallOptimization will find instances of a call to "exit" that occurs
/// within the "main" function and change it to a simple "ret" instruction with
/// the same value passed to the exit function. When this is done, it splits the
/// basic block at the exit(3) call and deletes the call instruction.
/// @brief Replace calls to exit in main with a simple return
-struct ExitInMainOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN ExitInMainOptimization : public LibCallOptimization {
ExitInMainOptimization() : LibCallOptimization("exit",
"Number of 'exit' calls simplified") {}
/// of the constant string. Both of these calls are further reduced, if possible
/// on subsequent passes.
/// @brief Simplify the strcat library function.
-struct StrCatOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN StrCatOptimization : public LibCallOptimization {
public:
/// @brief Default constructor
StrCatOptimization() : LibCallOptimization("strcat",
/// function. It optimizes out cases where the arguments are both constant
/// and the result can be determined statically.
/// @brief Simplify the strcmp library function.
-struct StrChrOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN StrChrOptimization : public LibCallOptimization {
public:
StrChrOptimization() : LibCallOptimization("strchr",
"Number of 'strchr' calls simplified") {}
/// function. It optimizes out cases where one or both arguments are constant
/// and the result can be determined statically.
/// @brief Simplify the strcmp library function.
-struct StrCmpOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN StrCmpOptimization : public LibCallOptimization {
public:
StrCmpOptimization() : LibCallOptimization("strcmp",
"Number of 'strcmp' calls simplified") {}
/// function. It optimizes out cases where one or both arguments are constant
/// and the result can be determined statically.
/// @brief Simplify the strncmp library function.
-struct StrNCmpOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN StrNCmpOptimization : public LibCallOptimization {
public:
StrNCmpOptimization() : LibCallOptimization("strncmp",
"Number of 'strncmp' calls simplified") {}
/// (1) If src and dest are the same and not volatile, just return dest
/// (2) If the src is a constant then we can convert to llvm.memmove
/// @brief Simplify the strcpy library function.
-struct StrCpyOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN StrCpyOptimization : public LibCallOptimization {
public:
StrCpyOptimization() : LibCallOptimization("strcpy",
"Number of 'strcpy' calls simplified") {}
/// function by replacing it with a constant value if the string provided to
/// it is a constant array.
/// @brief Simplify the strlen library function.
-struct StrLenOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN StrLenOptimization : public LibCallOptimization {
StrLenOptimization() : LibCallOptimization("strlen",
"Number of 'strlen' calls simplified") {}
/// This memcmpOptimization will simplify a call to the memcmp library
/// function.
-struct memcmpOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN memcmpOptimization : public LibCallOptimization {
/// @brief Default Constructor
memcmpOptimization()
: LibCallOptimization("memcmp", "Number of 'memcmp' calls simplified") {}
/// bytes depending on the length of the string and the alignment. Additional
/// optimizations are possible in code generation (sequence of immediate store)
/// @brief Simplify the memcpy library function.
-struct LLVMMemCpyMoveOptzn : public LibCallOptimization {
+struct VISIBILITY_HIDDEN LLVMMemCpyMoveOptzn : public LibCallOptimization {
LLVMMemCpyMoveOptzn(const char* fname, const char* desc)
: LibCallOptimization(fname, desc) {}
/// This LibCallOptimization will simplify a call to the memset library
/// function by expanding it out to a single store of size 0, 1, 2, 4, or 8
/// bytes depending on the length argument.
-struct LLVMMemSetOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN LLVMMemSetOptimization : public LibCallOptimization {
/// @brief Default Constructor
LLVMMemSetOptimization(const char *Name) : LibCallOptimization(Name,
"Number of 'llvm.memset' calls simplified") {}
/// function. It looks for cases where the result of pow is well known and
/// substitutes the appropriate value.
/// @brief Simplify the pow library function.
-struct PowOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN PowOptimization : public LibCallOptimization {
public:
/// @brief Default Constructor
PowOptimization() : LibCallOptimization("pow",
/// function. It looks for cases where the result of printf is not used and the
/// operation can be reduced to something simpler.
/// @brief Simplify the printf library function.
-struct PrintfOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN PrintfOptimization : public LibCallOptimization {
public:
/// @brief Default Constructor
PrintfOptimization() : LibCallOptimization("printf",
/// function. It looks for cases where the result of fprintf is not used and the
/// operation can be reduced to something simpler.
/// @brief Simplify the fprintf library function.
-struct FPrintFOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN FPrintFOptimization : public LibCallOptimization {
public:
/// @brief Default Constructor
FPrintFOptimization() : LibCallOptimization("fprintf",
/// function. It looks for cases where the result of sprintf is not used and the
/// operation can be reduced to something simpler.
/// @brief Simplify the sprintf library function.
-struct SPrintFOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN SPrintFOptimization : public LibCallOptimization {
public:
/// @brief Default Constructor
SPrintFOptimization() : LibCallOptimization("sprintf",
/// function. It looks for cases where the result of fputs is not used and the
/// operation can be reduced to something simpler.
/// @brief Simplify the puts library function.
-struct PutsOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN PutsOptimization : public LibCallOptimization {
public:
/// @brief Default Constructor
PutsOptimization() : LibCallOptimization("fputs",
/// This LibCallOptimization will simplify calls to the "isdigit" library
/// function. It simply does range checks the parameter explicitly.
/// @brief Simplify the isdigit library function.
-struct isdigitOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN isdigitOptimization : public LibCallOptimization {
public:
isdigitOptimization() : LibCallOptimization("isdigit",
"Number of 'isdigit' calls simplified") {}
}
} isdigitOptimizer;
-struct isasciiOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN isasciiOptimization : public LibCallOptimization {
public:
isasciiOptimization()
: LibCallOptimization("isascii", "Number of 'isascii' calls simplified") {}
/// function. It simply does the corresponding and operation to restrict the
/// range of values to the ASCII character set (0-127).
/// @brief Simplify the toascii library function.
-struct ToAsciiOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN ToAsciiOptimization : public LibCallOptimization {
public:
/// @brief Default Constructor
ToAsciiOptimization() : LibCallOptimization("toascii",
/// optimization is to compute the result at compile time if the argument is
/// a constant.
/// @brief Simplify the ffs library function.
-struct FFSOptimization : public LibCallOptimization {
+struct VISIBILITY_HIDDEN FFSOptimization : public LibCallOptimization {
protected:
/// @brief Subclass Constructor
FFSOptimization(const char* funcName, const char* description)
/// calls. It simply uses FFSOptimization for which the transformation is
/// identical.
/// @brief Simplify the ffsl library function.
-struct FFSLOptimization : public FFSOptimization {
+struct VISIBILITY_HIDDEN FFSLOptimization : public FFSOptimization {
public:
/// @brief Default Constructor
FFSLOptimization() : FFSOptimization("ffsl",
/// calls. It simply uses FFSOptimization for which the transformation is
/// identical.
/// @brief Simplify the ffsl library function.
-struct FFSLLOptimization : public FFSOptimization {
+struct VISIBILITY_HIDDEN FFSLLOptimization : public FFSOptimization {
public:
/// @brief Default Constructor
FFSLLOptimization() : FFSOptimization("ffsll",
};
-struct FloorOptimization : public UnaryDoubleFPOptimizer {
+struct VISIBILITY_HIDDEN FloorOptimization : public UnaryDoubleFPOptimizer {
FloorOptimization()
: UnaryDoubleFPOptimizer("floor", "Number of 'floor' calls simplified") {}
}
} FloorOptimizer;
-struct CeilOptimization : public UnaryDoubleFPOptimizer {
+struct VISIBILITY_HIDDEN CeilOptimization : public UnaryDoubleFPOptimizer {
CeilOptimization()
: UnaryDoubleFPOptimizer("ceil", "Number of 'ceil' calls simplified") {}
}
} CeilOptimizer;
-struct RoundOptimization : public UnaryDoubleFPOptimizer {
+struct VISIBILITY_HIDDEN RoundOptimization : public UnaryDoubleFPOptimizer {
RoundOptimization()
: UnaryDoubleFPOptimizer("round", "Number of 'round' calls simplified") {}
}
} RoundOptimizer;
-struct RintOptimization : public UnaryDoubleFPOptimizer {
+struct VISIBILITY_HIDDEN RintOptimization : public UnaryDoubleFPOptimizer {
RintOptimization()
: UnaryDoubleFPOptimizer("rint", "Number of 'rint' calls simplified") {}
}
} RintOptimizer;
-struct NearByIntOptimization : public UnaryDoubleFPOptimizer {
+struct VISIBILITY_HIDDEN NearByIntOptimization : public UnaryDoubleFPOptimizer {
NearByIntOptimization()
: UnaryDoubleFPOptimizer("nearbyint",
"Number of 'nearbyint' calls simplified") {}
/// of the null-terminated string. If false is returned, the conditions were
/// not met and len is set to 0.
/// @brief Get the length of a constant string (null-terminated array).
-bool getConstantStringLength(Value *V, uint64_t &len, ConstantArray **CA) {
+static bool getConstantStringLength(Value *V, uint64_t &len, ConstantArray **CA)
+{
assert(V != 0 && "Invalid args to getConstantStringLength");
len = 0; // make sure we initialize this
User* GEP = 0;
/// CastToCStr - Return V if it is an sbyte*, otherwise cast it to sbyte*,
/// inserting the cast before IP, and return the cast.
/// @brief Cast a value to a "C" string.
-Value *CastToCStr(Value *V, Instruction &IP) {
+static Value *CastToCStr(Value *V, Instruction &IP) {
assert(isa<PointerType>(V->getType()) &&
"Can't cast non-pointer type to C string type");
const Type *SBPTy = PointerType::get(Type::Int8Ty);
#include "llvm/Pass.h"
#include "llvm/ValueSymbolTable.h"
#include "llvm/TypeSymbolTable.h"
+#include "llvm/Support/Compiler.h"
using namespace llvm;
namespace {
- class StripSymbols : public ModulePass {
+ class VISIBILITY_HIDDEN StripSymbols : public ModulePass {
bool OnlyDebugInfo;
public:
StripSymbols(bool ODI = false) : OnlyDebugInfo(ODI) {}
#include "llvm/DerivedTypes.h"
#include "llvm/Module.h"
#include "llvm/Pass.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/Streams.h"
#include "llvm/Transforms/Instrumentation.h"
#include "RSProfiling.h"
using namespace llvm;
namespace {
- class FunctionProfiler : public RSProfilers_std {
+ class VISIBILITY_HIDDEN FunctionProfiler : public RSProfilers_std {
bool runOnModule(Module &M);
};
#include "llvm/DerivedTypes.h"
#include "llvm/Module.h"
#include "llvm/Pass.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/Streams.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Instrumentation.h"
using namespace llvm;
namespace {
- class EdgeProfiler : public ModulePass {
+ class VISIBILITY_HIDDEN EdgeProfiler : public ModulePass {
bool runOnModule(Module &M);
};
#include "llvm/Module.h"
#include "llvm/Pass.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Transforms/Instrumentation.h"
using namespace llvm;
BLACK
};
- struct EmitFunctionTable : public ModulePass {
+ struct VISIBILITY_HIDDEN EmitFunctionTable : public ModulePass {
bool runOnModule(Module &M);
};
#include "llvm/Transforms/Scalar.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Transforms/Instrumentation.h"
#include "RSProfiling.h"
/// NullProfilerRS - The basic profiler that does nothing. It is the default
/// profiler and thus terminates RSProfiler chains. It is useful for
/// measuring framework overhead
- class NullProfilerRS : public RSProfilers {
+ class VISIBILITY_HIDDEN NullProfilerRS : public RSProfilers {
public:
bool isProfiling(Value* v) {
return false;
static RegisterAnalysisGroup<RSProfilers, true> NPT(NP);
/// Chooser - Something that chooses when to make a sample of the profiled code
- class Chooser {
+ class VISIBILITY_HIDDEN Chooser {
public:
/// ProcessChoicePoint - is called for each basic block inserted to choose
/// between normal and sample code
//Things that implement sampling policies
//A global value that is read-mod-stored to choose when to sample.
//A sample is taken when the global counter hits 0
- class GlobalRandomCounter : public Chooser {
+ class VISIBILITY_HIDDEN GlobalRandomCounter : public Chooser {
GlobalVariable* Counter;
Value* ResetValue;
const Type* T;
};
//Same is GRC, but allow register allocation of the global counter
- class GlobalRandomCounterOpt : public Chooser {
+ class VISIBILITY_HIDDEN GlobalRandomCounterOpt : public Chooser {
GlobalVariable* Counter;
Value* ResetValue;
AllocaInst* AI;
//Use the cycle counter intrinsic as a source of pseudo randomness when
//deciding when to sample.
- class CycleCounter : public Chooser {
+ class VISIBILITY_HIDDEN CycleCounter : public Chooser {
uint64_t rm;
Constant *F;
public:
};
/// ProfilerRS - Insert the random sampling framework
- struct ProfilerRS : public FunctionPass {
+ struct VISIBILITY_HIDDEN ProfilerRS : public FunctionPass {
std::map<Value*, Value*> TransCache;
std::set<BasicBlock*> ChoicePoints;
Chooser* c;
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Instrumentation.h"
#include "llvm/Instructions.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include <set>
using namespace llvm;
namespace {
- class TraceBasicBlocks : public ModulePass {
+ class VISIBILITY_HIDDEN TraceBasicBlocks : public ModulePass {
bool runOnModule(Module &M);
};
#include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Compiler.h"
#include <algorithm>
using namespace llvm;
// This class does all of the work of Aggressive Dead Code Elimination.
// It's public interface consists of a constructor and a doADCE() method.
//
-class ADCE : public FunctionPass {
+class VISIBILITY_HIDDEN ADCE : public FunctionPass {
Function *Func; // The function that we are working on
std::vector<Instruction*> WorkList; // Instructions that just became live
std::set<Instruction*> LiveSet; // The set of live instructions
#include "llvm/Function.h"
#include "llvm/Pass.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Transforms/Scalar.h"
#include <set>
STATISTIC(NumMoved, "Number of basic blocks moved");
namespace {
- struct BlockPlacement : public FunctionPass {
+ struct VISIBILITY_HIDDEN BlockPlacement : public FunctionPass {
virtual bool runOnFunction(Function &F);
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
#include "llvm/Type.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Statistic.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/Streams.h"
using namespace llvm;
STATISTIC(NumSwThread, "Number of CFG edges threaded through switches");
namespace {
- struct CondProp : public FunctionPass {
+ struct VISIBILITY_HIDDEN CondProp : public FunctionPass {
virtual bool runOnFunction(Function &F);
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
#include "llvm/Constant.h"
#include "llvm/Instruction.h"
#include "llvm/Pass.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/InstIterator.h"
#include "llvm/ADT/Statistic.h"
#include <set>
STATISTIC(NumInstKilled, "Number of instructions killed");
namespace {
- struct ConstantPropagation : public FunctionPass {
+ struct VISIBILITY_HIDDEN ConstantPropagation : public FunctionPass {
bool runOnFunction(Function &F);
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
#include "llvm/Analysis/Dominators.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
-#include "llvm/Support/ConstantRange.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/ConstantRange.h"
#include "llvm/Support/Debug.h"
#include "llvm/ADT/PostOrderIterator.h"
#include "llvm/ADT/Statistic.h"
namespace {
class ValueInfo;
- class Relation {
+ class VISIBILITY_HIDDEN Relation {
Value *Val; // Relation to what value?
unsigned Rel; // SetCC or ICmp relation, or Add if no information
public:
// relationships to other values in the program (specified with Relation) that
// are known to be valid in a region.
//
- class ValueInfo {
+ class VISIBILITY_HIDDEN ValueInfo {
// RelationShips - this value is know to have the specified relationships to
// other values. There can only be one entry per value, and this list is
// kept sorted by the Val field.
// the RegionInfo for their dominator, because anything known in a dominator
// is known to be true in a dominated block as well.
//
- class RegionInfo {
+ class VISIBILITY_HIDDEN RegionInfo {
BasicBlock *BB;
// ValueMap - Tracks the ValueInformation known for this region
};
/// CEE - Correlated Expression Elimination
- class CEE : public FunctionPass {
+ class VISIBILITY_HIDDEN CEE : public FunctionPass {
std::map<Value*, unsigned> RankMap;
std::map<BasicBlock*, RegionInfo> RegionInfoMap;
ETForest *EF;
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Instruction.h"
#include "llvm/Pass.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/InstIterator.h"
#include "llvm/ADT/Statistic.h"
#include <set>
//===--------------------------------------------------------------------===//
// DeadInstElimination pass implementation
//
- struct DeadInstElimination : public BasicBlockPass {
+ struct VISIBILITY_HIDDEN DeadInstElimination : public BasicBlockPass {
virtual bool runOnBasicBlock(BasicBlock &BB) {
bool Changed = false;
for (BasicBlock::iterator DI = BB.begin(); DI != BB.end(); )
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/Statistic.h"
+#include "llvm/Support/Compiler.h"
using namespace llvm;
STATISTIC(NumStores, "Number of stores deleted");
STATISTIC(NumOther , "Number of other instrs removed");
namespace {
- struct DSE : public FunctionPass {
+ struct VISIBILITY_HIDDEN DSE : public FunctionPass {
virtual bool runOnFunction(Function &F) {
bool Changed = false;
#include "llvm/Analysis/ValueNumbering.h"
#include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/Statistic.h"
+#include "llvm/Support/Compiler.h"
#include <algorithm>
using namespace llvm;
STATISTIC(NumArgsRepl , "Number of function arguments replaced "
"with constant values");
namespace {
- struct GCSE : public FunctionPass {
+ struct VISIBILITY_HIDDEN GCSE : public FunctionPass {
virtual bool runOnFunction(Function &F);
private:
#include "llvm/Analysis/ScalarEvolutionExpander.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/GetElementPtrTypeIterator.h"
#include "llvm/Transforms/Utils/Local.h"
STATISTIC(NumLFTR , "Number of loop exit tests replaced");
namespace {
- class IndVarSimplify : public FunctionPass {
+ class VISIBILITY_HIDDEN IndVarSimplify : public FunctionPass {
LoopInfo *LI;
ScalarEvolution *SE;
bool Changed;
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/AliasSetTracker.h"
#include "llvm/Analysis/Dominators.h"
-#include "llvm/Support/CFG.h"
#include "llvm/Transforms/Utils/PromoteMemToReg.h"
+#include "llvm/Support/CFG.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/ADT/Statistic.h"
DisablePromotion("disable-licm-promotion", cl::Hidden,
cl::desc("Disable memory promotion in LICM pass"));
- struct LICM : public FunctionPass {
+ struct VISIBILITY_HIDDEN LICM : public FunctionPass {
virtual bool runOnFunction(Function &F);
/// This transformation requires natural loop information & requires that
/// the stride is stored externally. The Offset member keeps track of the
/// offset from the IV, User is the actual user of the operand, and 'Operand'
/// is the operand # of the User that is the use.
- struct IVStrideUse {
+ struct VISIBILITY_HIDDEN IVStrideUse {
SCEVHandle Offset;
Instruction *User;
Value *OperandValToReplace;
/// have an operand that is based on the trip count multiplied by some stride.
/// The stride for all of these users is common and kept external to this
/// structure.
- struct IVUsersOfOneStride {
+ struct VISIBILITY_HIDDEN IVUsersOfOneStride {
/// Users - Keep track of all of the users of this stride as well as the
/// initial value and the operand that uses the IV.
std::vector<IVStrideUse> Users;
/// IVInfo - This structure keeps track of one IV expression inserted during
/// StrengthReduceStridedIVUsers. It contains the stride, the common base, as
/// well as the PHI node and increment value created for rewrite.
- struct IVExpr {
+ struct VISIBILITY_HIDDEN IVExpr {
SCEVHandle Stride;
SCEVHandle Base;
PHINode *PHI;
/// IVsOfOneStride - This structure keeps track of all IV expression inserted
/// during StrengthReduceStridedIVUsers for a particular stride of the IV.
- struct IVsOfOneStride {
+ struct VISIBILITY_HIDDEN IVsOfOneStride {
std::vector<IVExpr> IVs;
void addIV(const SCEVHandle &Stride, const SCEVHandle &Base, PHINode *PHI,
#include "llvm/Transforms/Utils/Cloning.h"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/ADT/Statistic.h"
UnrollThreshold("unroll-threshold", cl::init(100), cl::Hidden,
cl::desc("The cut-off point for loop unrolling"));
- class LoopUnroll : public FunctionPass {
+ class VISIBILITY_HIDDEN LoopUnroll : public FunctionPass {
LoopInfo *LI; // The current loop information
public:
virtual bool runOnFunction(Function &F);
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/PostOrderIterator.h"
-#include "llvm/Support/Debug.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/Debug.h"
#include <algorithm>
#include <set>
using namespace llvm;
Threshold("loop-unswitch-threshold", cl::desc("Max loop size to unswitch"),
cl::init(10), cl::Hidden);
- class LoopUnswitch : public FunctionPass {
+ class VISIBILITY_HIDDEN LoopUnswitch : public FunctionPass {
LoopInfo *LI; // Loop information
// LoopProcessWorklist - List of loops we need to process.
#include "llvm/Function.h"
#include "llvm/Instructions.h"
#include "llvm/Pass.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/InstVisitor.h"
#include "llvm/Support/Streams.h"
#include "llvm/ADT/StringExtras.h"
///
/// @brief Transforms packed instructions to simpler instructions.
///
-class LowerPacked : public FunctionPass, public InstVisitor<LowerPacked> {
+class VISIBILITY_HIDDEN LowerPacked
+ : public FunctionPass, public InstVisitor<LowerPacked> {
public:
/// @brief Lowers packed operations to scalar operations.
/// @param F The fuction to process
#include "llvm/Pass.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/ADT/PostOrderIterator.h"
#include "llvm/ADT/Statistic.h"
STATISTIC(NumFactor , "Number of multiplies factored");
namespace {
- struct ValueEntry {
+ struct VISIBILITY_HIDDEN ValueEntry {
unsigned Rank;
Value *Op;
ValueEntry(unsigned R, Value *O) : Rank(R), Op(O) {}
}
namespace {
- class Reassociate : public FunctionPass {
+ class VISIBILITY_HIDDEN Reassociate : public FunctionPass {
std::map<BasicBlock*, unsigned> RankMap;
std::map<Value*, unsigned> ValueRankMap;
bool MadeChange;
#include "llvm/BasicBlock.h"
#include "llvm/Instructions.h"
#include "llvm/ADT/Statistic.h"
+#include "llvm/Support/Compiler.h"
#include <list>
using namespace llvm;
STATISTIC(NumDemoted, "Number of registers demoted");
namespace {
- struct RegToMem : public FunctionPass {
+ struct VISIBILITY_HIDDEN RegToMem : public FunctionPass {
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequiredID(BreakCriticalEdgesID);
#include "llvm/Analysis/ConstantFolding.h"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Support/CallSite.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/InstVisitor.h"
#include "llvm/ADT/DenseMap.h"
/// LatticeVal class - This class represents the different lattice values that
/// an LLVM value may occupy. It is a simple class with value semantics.
///
-class LatticeVal {
+class VISIBILITY_HIDDEN LatticeVal {
enum {
/// undefined - This LLVM Value has no known value yet.
undefined,
/// SCCP Class - This class uses the SCCPSolver to implement a per-function
/// Sparse Conditional Constant Propagator.
///
- struct SCCP : public FunctionPass {
+ struct VISIBILITY_HIDDEN SCCP : public FunctionPass {
// runOnFunction - Run the Sparse Conditional Constant Propagation
// algorithm, and return true if the function was modified.
//
/// IPSCCP Class - This class implements interprocedural Sparse Conditional
/// Constant Propagation.
///
- struct IPSCCP : public ModulePass {
+ struct VISIBILITY_HIDDEN IPSCCP : public ModulePass {
bool runOnModule(Module &M);
};
#include "llvm/Instructions.h"
#include "llvm/Module.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Pass.h"
#include "llvm/ADT/Statistic.h"
#include <set>
STATISTIC(NumSimpl, "Number of blocks simplified");
namespace {
- struct CFGSimplifyPass : public FunctionPass {
+ struct VISIBILITY_HIDDEN CFGSimplifyPass : public FunctionPass {
virtual bool runOnFunction(Function &F);
};
RegisterPass<CFGSimplifyPass> X("simplifycfg", "Simplify the CFG");
#include "llvm/Support/CFG.h"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/ADT/Statistic.h"
using namespace llvm;
cl::opt<unsigned>
Threshold("taildup-threshold", cl::desc("Max block size to tail duplicate"),
cl::init(6), cl::Hidden);
- class TailDup : public FunctionPass {
+ class VISIBILITY_HIDDEN TailDup : public FunctionPass {
bool runOnFunction(Function &F);
private:
inline bool shouldEliminateUnconditionalBranch(TerminatorInst *TI);
#include "llvm/Pass.h"
#include "llvm/Support/CFG.h"
#include "llvm/ADT/Statistic.h"
+#include "llvm/Support/Compiler.h"
using namespace llvm;
STATISTIC(NumEliminated, "Number of tail calls removed");
STATISTIC(NumAccumAdded, "Number of accumulators introduced");
namespace {
- struct TailCallElim : public FunctionPass {
+ struct VISIBILITY_HIDDEN TailCallElim : public FunctionPass {
virtual bool runOnFunction(Function &F);
private:
#include "llvm/Instructions.h"
#include "llvm/Function.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Compiler.h"
#include "ValueMapper.h"
#include "llvm/Analysis/ConstantFolding.h"
#include "llvm/ADT/SmallVector.h"
namespace {
/// PruningFunctionCloner - This class is a private class used to implement
/// the CloneAndPruneFunctionInto method.
- struct PruningFunctionCloner {
+ struct VISIBILITY_HIDDEN PruningFunctionCloner {
Function *NewFunc;
const Function *OldFunc;
DenseMap<const Value*, Value*> &ValueMap;
#include "llvm/Analysis/Verifier.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/ADT/StringExtras.h"
#include <algorithm>
cl::desc("Aggregate arguments to code-extracted functions"));
namespace {
- class CodeExtractor {
+ class VISIBILITY_HIDDEN CodeExtractor {
typedef std::vector<Value*> Values;
std::set<BasicBlock*> BlocksToExtract;
DominatorSet *DS;
#include "llvm/Analysis/Dominators.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Compiler.h"
#include <algorithm>
#include <map>
using namespace llvm;
STATISTIC(NumLCSSA, "Number of live out of a loop variables");
namespace {
- struct LCSSA : public FunctionPass {
+ struct VISIBILITY_HIDDEN LCSSA : public FunctionPass {
// Cached analysis information for the current function.
LoopInfo *LI;
DominatorTree *DT;
#include "llvm/Instructions.h"
#include "llvm/Pass.h"
#include "llvm/Type.h"
+#include "llvm/Support/Compiler.h"
using namespace llvm;
namespace {
/// LowerSelect - Turn select instructions into conditional branches.
///
- class LowerSelect : public FunctionPass {
+ class VISIBILITY_HIDDEN LowerSelect : public FunctionPass {
bool OnlyFP; // Only lower FP select instructions?
public:
LowerSelect(bool onlyfp = false) : OnlyFP(onlyfp) {}
projects / oota-llvm.git / commitdiff