From 8749d297f5995a580721b0a5d293627e73251eaa Mon Sep 17 00:00:00 2001 From: Reid Spencer Date: Mon, 5 Feb 2007 23:32:05 +0000 Subject: [PATCH] Apply the VISIBILITY_HIDDEN field to the remaining anonymous classes in the Transforms library. This reduces debug library size by 132 KB, debug binary size by 376 KB, and reduces link time for llvm tools slightly. llvm-svn: 33939 --- lib/Transforms/IPO/ArgumentPromotion.cpp | 3 +- lib/Transforms/IPO/ConstantMerge.cpp | 3 +- .../IPO/DeadArgumentElimination.cpp | 3 +- lib/Transforms/IPO/DeadTypeElimination.cpp | 3 +- lib/Transforms/IPO/ExtractFunction.cpp | 4 +- lib/Transforms/IPO/GlobalDCE.cpp | 3 +- lib/Transforms/IPO/GlobalOpt.cpp | 5 +- lib/Transforms/IPO/IPConstantPropagation.cpp | 3 +- lib/Transforms/IPO/IndMemRemoval.cpp | 3 +- lib/Transforms/IPO/InlineSimple.cpp | 7 +- lib/Transforms/IPO/Internalize.cpp | 3 +- lib/Transforms/IPO/LoopExtractor.cpp | 3 +- lib/Transforms/IPO/LowerSetJmp.cpp | 3 +- lib/Transforms/IPO/PruneEH.cpp | 3 +- lib/Transforms/IPO/RaiseAllocations.cpp | 3 +- lib/Transforms/IPO/SimplifyLibCalls.cpp | 67 ++++++++++--------- lib/Transforms/IPO/StripSymbols.cpp | 3 +- .../Instrumentation/BlockProfiling.cpp | 3 +- .../Instrumentation/EdgeProfiling.cpp | 3 +- .../Instrumentation/EmitFunctions.cpp | 3 +- .../Instrumentation/RSProfiling.cpp | 13 ++-- .../Instrumentation/TraceBasicBlocks.cpp | 3 +- lib/Transforms/Scalar/ADCE.cpp | 3 +- lib/Transforms/Scalar/BasicBlockPlacement.cpp | 3 +- lib/Transforms/Scalar/CondPropagate.cpp | 3 +- lib/Transforms/Scalar/ConstantProp.cpp | 3 +- lib/Transforms/Scalar/CorrelatedExprs.cpp | 11 +-- lib/Transforms/Scalar/DCE.cpp | 3 +- .../Scalar/DeadStoreElimination.cpp | 3 +- lib/Transforms/Scalar/GCSE.cpp | 3 +- lib/Transforms/Scalar/IndVarSimplify.cpp | 3 +- lib/Transforms/Scalar/LICM.cpp | 5 +- lib/Transforms/Scalar/LoopStrengthReduce.cpp | 8 +-- lib/Transforms/Scalar/LoopUnroll.cpp | 3 +- lib/Transforms/Scalar/LoopUnswitch.cpp | 5 +- lib/Transforms/Scalar/LowerPacked.cpp | 4 +- lib/Transforms/Scalar/Reassociate.cpp | 5 +- lib/Transforms/Scalar/Reg2Mem.cpp | 3 +- lib/Transforms/Scalar/SCCP.cpp | 7 +- lib/Transforms/Scalar/SimplifyCFG.cpp | 3 +- lib/Transforms/Scalar/TailDuplication.cpp | 3 +- .../Scalar/TailRecursionElimination.cpp | 3 +- lib/Transforms/Utils/CloneFunction.cpp | 3 +- lib/Transforms/Utils/CodeExtractor.cpp | 3 +- lib/Transforms/Utils/LCSSA.cpp | 3 +- lib/Transforms/Utils/LowerSelect.cpp | 3 +- 46 files changed, 146 insertions(+), 97 deletions(-) diff --git a/lib/Transforms/IPO/ArgumentPromotion.cpp b/lib/Transforms/IPO/ArgumentPromotion.cpp index 8e51e77b868..3c57649f4e7 100644 --- a/lib/Transforms/IPO/ArgumentPromotion.cpp +++ b/lib/Transforms/IPO/ArgumentPromotion.cpp @@ -44,6 +44,7 @@ #include "llvm/ADT/DepthFirstIterator.h" #include "llvm/ADT/Statistic.h" #include "llvm/ADT/StringExtras.h" +#include "llvm/Support/Compiler.h" #include using namespace llvm; @@ -54,7 +55,7 @@ STATISTIC(NumArgumentsDead , "Number of dead pointer args eliminated"); 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(); AU.addRequired(); diff --git a/lib/Transforms/IPO/ConstantMerge.cpp b/lib/Transforms/IPO/ConstantMerge.cpp index 291653376ed..11ec09ab2e6 100644 --- a/lib/Transforms/IPO/ConstantMerge.cpp +++ b/lib/Transforms/IPO/ConstantMerge.cpp @@ -22,12 +22,13 @@ #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. // diff --git a/lib/Transforms/IPO/DeadArgumentElimination.cpp b/lib/Transforms/IPO/DeadArgumentElimination.cpp index fd1be4dda24..149043d05ce 100644 --- a/lib/Transforms/IPO/DeadArgumentElimination.cpp +++ b/lib/Transforms/IPO/DeadArgumentElimination.cpp @@ -29,6 +29,7 @@ #include "llvm/Support/CallSite.h" #include "llvm/Support/Debug.h" #include "llvm/ADT/Statistic.h" +#include "llvm/Support/Compiler.h" #include using namespace llvm; @@ -38,7 +39,7 @@ STATISTIC(NumRetValsEliminated , "Number of unused return values removed"); 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). diff --git a/lib/Transforms/IPO/DeadTypeElimination.cpp b/lib/Transforms/IPO/DeadTypeElimination.cpp index 18724bb9db3..a72a48cc635 100644 --- a/lib/Transforms/IPO/DeadTypeElimination.cpp +++ b/lib/Transforms/IPO/DeadTypeElimination.cpp @@ -19,12 +19,13 @@ #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. diff --git a/lib/Transforms/IPO/ExtractFunction.cpp b/lib/Transforms/IPO/ExtractFunction.cpp index f8771845a6a..ae1eb224783 100644 --- a/lib/Transforms/IPO/ExtractFunction.cpp +++ b/lib/Transforms/IPO/ExtractFunction.cpp @@ -15,10 +15,12 @@ #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; diff --git a/lib/Transforms/IPO/GlobalDCE.cpp b/lib/Transforms/IPO/GlobalDCE.cpp index 0f868f976b4..7fd110208f7 100644 --- a/lib/Transforms/IPO/GlobalDCE.cpp +++ b/lib/Transforms/IPO/GlobalDCE.cpp @@ -21,6 +21,7 @@ #include "llvm/Module.h" #include "llvm/Pass.h" #include "llvm/ADT/Statistic.h" +#include "llvm/Support/Compiler.h" #include using namespace llvm; @@ -28,7 +29,7 @@ STATISTIC(NumFunctions, "Number of functions removed"); 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. // diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp index d57047bc32f..5be5ace315f 100644 --- a/lib/Transforms/IPO/GlobalOpt.cpp +++ b/lib/Transforms/IPO/GlobalOpt.cpp @@ -24,6 +24,7 @@ #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" @@ -45,7 +46,7 @@ STATISTIC(NumFastCallFns , "Number of functions converted to fastcc"); 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(); } @@ -68,7 +69,7 @@ ModulePass *llvm::createGlobalOptimizerPass() { return new GlobalOpt(); } /// 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; diff --git a/lib/Transforms/IPO/IPConstantPropagation.cpp b/lib/Transforms/IPO/IPConstantPropagation.cpp index daaa5a71213..af4fb69c821 100644 --- a/lib/Transforms/IPO/IPConstantPropagation.cpp +++ b/lib/Transforms/IPO/IPConstantPropagation.cpp @@ -22,6 +22,7 @@ #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; @@ -31,7 +32,7 @@ STATISTIC(NumReturnValProped, "Number of return values turned into constants"); 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); diff --git a/lib/Transforms/IPO/IndMemRemoval.cpp b/lib/Transforms/IPO/IndMemRemoval.cpp index 343fadb6376..6c80aca1489 100644 --- a/lib/Transforms/IPO/IndMemRemoval.cpp +++ b/lib/Transforms/IPO/IndMemRemoval.cpp @@ -23,13 +23,14 @@ #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); }; diff --git a/lib/Transforms/IPO/InlineSimple.cpp b/lib/Transforms/IPO/InlineSimple.cpp index 9ee69d92b53..64de9c395e3 100644 --- a/lib/Transforms/IPO/InlineSimple.cpp +++ b/lib/Transforms/IPO/InlineSimple.cpp @@ -18,11 +18,12 @@ #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; @@ -32,7 +33,7 @@ namespace { // 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; @@ -50,7 +51,7 @@ namespace { void analyzeFunction(Function *F); }; - class SimpleInliner : public Inliner { + class VISIBILITY_HIDDEN SimpleInliner : public Inliner { std::map CachedFunctionInfo; public: int getInlineCost(CallSite CS); diff --git a/lib/Transforms/IPO/Internalize.cpp b/lib/Transforms/IPO/Internalize.cpp index eebc70a47fc..a1ebe956e50 100644 --- a/lib/Transforms/IPO/Internalize.cpp +++ b/lib/Transforms/IPO/Internalize.cpp @@ -18,6 +18,7 @@ #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 @@ -41,7 +42,7 @@ namespace { cl::desc("A list of symbol names to preserve"), cl::CommaSeparated); - class InternalizePass : public ModulePass { + class VISIBILITY_HIDDEN InternalizePass : public ModulePass { std::set ExternalNames; bool DontInternalize; public: diff --git a/lib/Transforms/IPO/LoopExtractor.cpp b/lib/Transforms/IPO/LoopExtractor.cpp index 7169b503b21..e99fa78a7d2 100644 --- a/lib/Transforms/IPO/LoopExtractor.cpp +++ b/lib/Transforms/IPO/LoopExtractor.cpp @@ -21,6 +21,7 @@ #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" @@ -32,7 +33,7 @@ namespace { // 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) {} diff --git a/lib/Transforms/IPO/LowerSetJmp.cpp b/lib/Transforms/IPO/LowerSetJmp.cpp index 8941c8b7b73..fcaa4e8ac5e 100644 --- a/lib/Transforms/IPO/LowerSetJmp.cpp +++ b/lib/Transforms/IPO/LowerSetJmp.cpp @@ -42,6 +42,7 @@ #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" @@ -58,7 +59,7 @@ STATISTIC(InvokesTransformed , "Number of invokes modified"); namespace { //===--------------------------------------------------------------------===// // LowerSetJmp pass implementation. - class LowerSetJmp : public ModulePass, + class VISIBILITY_HIDDEN LowerSetJmp : public ModulePass, public InstVisitor { // LLVM library functions... Constant *InitSJMap; // __llvm_sjljeh_init_setjmpmap diff --git a/lib/Transforms/IPO/PruneEH.cpp b/lib/Transforms/IPO/PruneEH.cpp index c92f4289144..d6043a1df5b 100644 --- a/lib/Transforms/IPO/PruneEH.cpp +++ b/lib/Transforms/IPO/PruneEH.cpp @@ -24,6 +24,7 @@ #include "llvm/Analysis/CallGraph.h" #include "llvm/ADT/Statistic.h" #include "llvm/Support/CFG.h" +#include "llvm/Support/Compiler.h" #include #include using namespace llvm; @@ -32,7 +33,7 @@ STATISTIC(NumRemoved, "Number of invokes removed"); 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 DoesNotUnwind; diff --git a/lib/Transforms/IPO/RaiseAllocations.cpp b/lib/Transforms/IPO/RaiseAllocations.cpp index c5a9cbf4478..b689de70830 100644 --- a/lib/Transforms/IPO/RaiseAllocations.cpp +++ b/lib/Transforms/IPO/RaiseAllocations.cpp @@ -20,6 +20,7 @@ #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; @@ -29,7 +30,7 @@ namespace { // 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: diff --git a/lib/Transforms/IPO/SimplifyLibCalls.cpp b/lib/Transforms/IPO/SimplifyLibCalls.cpp index 3ace4b365f4..51d70b1dac3 100644 --- a/lib/Transforms/IPO/SimplifyLibCalls.cpp +++ b/lib/Transforms/IPO/SimplifyLibCalls.cpp @@ -26,6 +26,7 @@ #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" @@ -62,7 +63,7 @@ static LibCallOptimization *OptList = 0; /// 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 @@ -142,7 +143,7 @@ public: /// 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. @@ -383,15 +384,16 @@ ModulePass *llvm::createSimplifyLibCallsPass() { 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") {} @@ -447,7 +449,7 @@ struct ExitInMainOptimization : public LibCallOptimization { /// 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", @@ -530,7 +532,7 @@ public: /// 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") {} @@ -611,7 +613,7 @@ public: /// 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") {} @@ -688,7 +690,7 @@ public: /// 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") {} @@ -781,7 +783,7 @@ public: /// (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") {} @@ -859,7 +861,7 @@ public: /// 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") {} @@ -947,7 +949,7 @@ static bool IsOnlyUsedInEqualsZeroComparison(Instruction *I) { /// 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") {} @@ -1052,7 +1054,7 @@ struct memcmpOptimization : public LibCallOptimization { /// 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) {} @@ -1129,7 +1131,7 @@ LLVMMemCpyMoveOptzn LLVMMemMoveOptimizer64("llvm.memmove.i64", /// 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") {} @@ -1232,7 +1234,7 @@ LLVMMemSetOptimization MemSet64Optimizer("llvm.memset.i64"); /// 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", @@ -1293,7 +1295,7 @@ public: /// 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", @@ -1371,7 +1373,7 @@ public: /// 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", @@ -1491,7 +1493,7 @@ public: /// 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", @@ -1614,7 +1616,7 @@ public: /// 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", @@ -1675,7 +1677,7 @@ public: /// 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") {} @@ -1716,7 +1718,7 @@ public: } } isdigitOptimizer; -struct isasciiOptimization : public LibCallOptimization { +struct VISIBILITY_HIDDEN isasciiOptimization : public LibCallOptimization { public: isasciiOptimization() : LibCallOptimization("isascii", "Number of 'isascii' calls simplified") {} @@ -1746,7 +1748,7 @@ public: /// 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", @@ -1775,7 +1777,7 @@ public: /// 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) @@ -1855,7 +1857,7 @@ public: /// 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", @@ -1867,7 +1869,7 @@ public: /// 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", @@ -1909,7 +1911,7 @@ struct UnaryDoubleFPOptimizer : public LibCallOptimization { }; -struct FloorOptimization : public UnaryDoubleFPOptimizer { +struct VISIBILITY_HIDDEN FloorOptimization : public UnaryDoubleFPOptimizer { FloorOptimization() : UnaryDoubleFPOptimizer("floor", "Number of 'floor' calls simplified") {} @@ -1923,7 +1925,7 @@ struct FloorOptimization : public UnaryDoubleFPOptimizer { } } FloorOptimizer; -struct CeilOptimization : public UnaryDoubleFPOptimizer { +struct VISIBILITY_HIDDEN CeilOptimization : public UnaryDoubleFPOptimizer { CeilOptimization() : UnaryDoubleFPOptimizer("ceil", "Number of 'ceil' calls simplified") {} @@ -1937,7 +1939,7 @@ struct CeilOptimization : public UnaryDoubleFPOptimizer { } } CeilOptimizer; -struct RoundOptimization : public UnaryDoubleFPOptimizer { +struct VISIBILITY_HIDDEN RoundOptimization : public UnaryDoubleFPOptimizer { RoundOptimization() : UnaryDoubleFPOptimizer("round", "Number of 'round' calls simplified") {} @@ -1951,7 +1953,7 @@ struct RoundOptimization : public UnaryDoubleFPOptimizer { } } RoundOptimizer; -struct RintOptimization : public UnaryDoubleFPOptimizer { +struct VISIBILITY_HIDDEN RintOptimization : public UnaryDoubleFPOptimizer { RintOptimization() : UnaryDoubleFPOptimizer("rint", "Number of 'rint' calls simplified") {} @@ -1965,7 +1967,7 @@ struct RintOptimization : public UnaryDoubleFPOptimizer { } } RintOptimizer; -struct NearByIntOptimization : public UnaryDoubleFPOptimizer { +struct VISIBILITY_HIDDEN NearByIntOptimization : public UnaryDoubleFPOptimizer { NearByIntOptimization() : UnaryDoubleFPOptimizer("nearbyint", "Number of 'nearbyint' calls simplified") {} @@ -1990,7 +1992,8 @@ struct NearByIntOptimization : public UnaryDoubleFPOptimizer { /// 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; @@ -2079,7 +2082,7 @@ bool getConstantStringLength(Value *V, uint64_t &len, ConstantArray **CA) { /// 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(V->getType()) && "Can't cast non-pointer type to C string type"); const Type *SBPTy = PointerType::get(Type::Int8Ty); diff --git a/lib/Transforms/IPO/StripSymbols.cpp b/lib/Transforms/IPO/StripSymbols.cpp index 00cfc513b66..4c0b35a1a4e 100644 --- a/lib/Transforms/IPO/StripSymbols.cpp +++ b/lib/Transforms/IPO/StripSymbols.cpp @@ -30,10 +30,11 @@ #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) {} diff --git a/lib/Transforms/Instrumentation/BlockProfiling.cpp b/lib/Transforms/Instrumentation/BlockProfiling.cpp index 23f2093499c..fb7268e57b9 100644 --- a/lib/Transforms/Instrumentation/BlockProfiling.cpp +++ b/lib/Transforms/Instrumentation/BlockProfiling.cpp @@ -23,6 +23,7 @@ #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" @@ -30,7 +31,7 @@ using namespace llvm; namespace { - class FunctionProfiler : public RSProfilers_std { + class VISIBILITY_HIDDEN FunctionProfiler : public RSProfilers_std { bool runOnModule(Module &M); }; diff --git a/lib/Transforms/Instrumentation/EdgeProfiling.cpp b/lib/Transforms/Instrumentation/EdgeProfiling.cpp index 4960d3c2065..e45d2bfd151 100644 --- a/lib/Transforms/Instrumentation/EdgeProfiling.cpp +++ b/lib/Transforms/Instrumentation/EdgeProfiling.cpp @@ -22,6 +22,7 @@ #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" @@ -29,7 +30,7 @@ using namespace llvm; namespace { - class EdgeProfiler : public ModulePass { + class VISIBILITY_HIDDEN EdgeProfiler : public ModulePass { bool runOnModule(Module &M); }; diff --git a/lib/Transforms/Instrumentation/EmitFunctions.cpp b/lib/Transforms/Instrumentation/EmitFunctions.cpp index 24c4f66419d..6fe10d07d6b 100644 --- a/lib/Transforms/Instrumentation/EmitFunctions.cpp +++ b/lib/Transforms/Instrumentation/EmitFunctions.cpp @@ -24,6 +24,7 @@ #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; @@ -36,7 +37,7 @@ namespace { BLACK }; - struct EmitFunctionTable : public ModulePass { + struct VISIBILITY_HIDDEN EmitFunctionTable : public ModulePass { bool runOnModule(Module &M); }; diff --git a/lib/Transforms/Instrumentation/RSProfiling.cpp b/lib/Transforms/Instrumentation/RSProfiling.cpp index d6d152dfbf3..fc464c00ec2 100644 --- a/lib/Transforms/Instrumentation/RSProfiling.cpp +++ b/lib/Transforms/Instrumentation/RSProfiling.cpp @@ -40,6 +40,7 @@ #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" @@ -66,7 +67,7 @@ namespace { /// 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; @@ -85,7 +86,7 @@ namespace { static RegisterAnalysisGroup 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 @@ -99,7 +100,7 @@ namespace { //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; @@ -111,7 +112,7 @@ namespace { }; //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; @@ -125,7 +126,7 @@ namespace { //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: @@ -136,7 +137,7 @@ namespace { }; /// ProfilerRS - Insert the random sampling framework - struct ProfilerRS : public FunctionPass { + struct VISIBILITY_HIDDEN ProfilerRS : public FunctionPass { std::map TransCache; std::set ChoicePoints; Chooser* c; diff --git a/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp b/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp index 4c09fb61c58..a6c20711a6d 100644 --- a/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp +++ b/lib/Transforms/Instrumentation/TraceBasicBlocks.cpp @@ -21,12 +21,13 @@ #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 using namespace llvm; namespace { - class TraceBasicBlocks : public ModulePass { + class VISIBILITY_HIDDEN TraceBasicBlocks : public ModulePass { bool runOnModule(Module &M); }; diff --git a/lib/Transforms/Scalar/ADCE.cpp b/lib/Transforms/Scalar/ADCE.cpp index 825c7815362..63612768f4d 100644 --- a/lib/Transforms/Scalar/ADCE.cpp +++ b/lib/Transforms/Scalar/ADCE.cpp @@ -27,6 +27,7 @@ #include "llvm/ADT/DepthFirstIterator.h" #include "llvm/ADT/Statistic.h" #include "llvm/ADT/STLExtras.h" +#include "llvm/Support/Compiler.h" #include using namespace llvm; @@ -41,7 +42,7 @@ namespace { // 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 WorkList; // Instructions that just became live std::set LiveSet; // The set of live instructions diff --git a/lib/Transforms/Scalar/BasicBlockPlacement.cpp b/lib/Transforms/Scalar/BasicBlockPlacement.cpp index 020b2b2c52e..14de1f1f475 100644 --- a/lib/Transforms/Scalar/BasicBlockPlacement.cpp +++ b/lib/Transforms/Scalar/BasicBlockPlacement.cpp @@ -31,6 +31,7 @@ #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 @@ -39,7 +40,7 @@ using namespace llvm; 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 { diff --git a/lib/Transforms/Scalar/CondPropagate.cpp b/lib/Transforms/Scalar/CondPropagate.cpp index 55dccd78408..4c3a9754963 100644 --- a/lib/Transforms/Scalar/CondPropagate.cpp +++ b/lib/Transforms/Scalar/CondPropagate.cpp @@ -22,6 +22,7 @@ #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; @@ -29,7 +30,7 @@ STATISTIC(NumBrThread, "Number of CFG edges threaded through branches"); 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 { diff --git a/lib/Transforms/Scalar/ConstantProp.cpp b/lib/Transforms/Scalar/ConstantProp.cpp index da59ad42baf..226d1deb41b 100644 --- a/lib/Transforms/Scalar/ConstantProp.cpp +++ b/lib/Transforms/Scalar/ConstantProp.cpp @@ -24,6 +24,7 @@ #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 @@ -32,7 +33,7 @@ using namespace llvm; 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 { diff --git a/lib/Transforms/Scalar/CorrelatedExprs.cpp b/lib/Transforms/Scalar/CorrelatedExprs.cpp index 5172daa9c4e..fe122c456c4 100644 --- a/lib/Transforms/Scalar/CorrelatedExprs.cpp +++ b/lib/Transforms/Scalar/CorrelatedExprs.cpp @@ -38,8 +38,9 @@ #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" @@ -52,7 +53,7 @@ STATISTIC(BranchRevectors, "Number of branches revectored"); 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: @@ -96,7 +97,7 @@ namespace { // 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. @@ -167,7 +168,7 @@ namespace { // 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 @@ -218,7 +219,7 @@ namespace { }; /// CEE - Correlated Expression Elimination - class CEE : public FunctionPass { + class VISIBILITY_HIDDEN CEE : public FunctionPass { std::map RankMap; std::map RegionInfoMap; ETForest *EF; diff --git a/lib/Transforms/Scalar/DCE.cpp b/lib/Transforms/Scalar/DCE.cpp index eb5721583ca..998d87cf1b6 100644 --- a/lib/Transforms/Scalar/DCE.cpp +++ b/lib/Transforms/Scalar/DCE.cpp @@ -21,6 +21,7 @@ #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 @@ -33,7 +34,7 @@ namespace { //===--------------------------------------------------------------------===// // 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(); ) diff --git a/lib/Transforms/Scalar/DeadStoreElimination.cpp b/lib/Transforms/Scalar/DeadStoreElimination.cpp index 39f2506c163..9ebb9b4974b 100644 --- a/lib/Transforms/Scalar/DeadStoreElimination.cpp +++ b/lib/Transforms/Scalar/DeadStoreElimination.cpp @@ -26,13 +26,14 @@ #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; diff --git a/lib/Transforms/Scalar/GCSE.cpp b/lib/Transforms/Scalar/GCSE.cpp index 7fef306985b..5ef6d976d77 100644 --- a/lib/Transforms/Scalar/GCSE.cpp +++ b/lib/Transforms/Scalar/GCSE.cpp @@ -24,6 +24,7 @@ #include "llvm/Analysis/ValueNumbering.h" #include "llvm/ADT/DepthFirstIterator.h" #include "llvm/ADT/Statistic.h" +#include "llvm/Support/Compiler.h" #include using namespace llvm; @@ -35,7 +36,7 @@ STATISTIC(NumNonInsts , "Number of instructions removed due " 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: diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp index 30435df8605..155e7ccb397 100644 --- a/lib/Transforms/Scalar/IndVarSimplify.cpp +++ b/lib/Transforms/Scalar/IndVarSimplify.cpp @@ -46,6 +46,7 @@ #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" @@ -61,7 +62,7 @@ STATISTIC(NumReplaced, "Number of exit values replaced"); 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; diff --git a/lib/Transforms/Scalar/LICM.cpp b/lib/Transforms/Scalar/LICM.cpp index a07ea268900..3a7adef56eb 100644 --- a/lib/Transforms/Scalar/LICM.cpp +++ b/lib/Transforms/Scalar/LICM.cpp @@ -41,8 +41,9 @@ #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" @@ -60,7 +61,7 @@ namespace { 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 diff --git a/lib/Transforms/Scalar/LoopStrengthReduce.cpp b/lib/Transforms/Scalar/LoopStrengthReduce.cpp index 798fb81190f..d841642de05 100644 --- a/lib/Transforms/Scalar/LoopStrengthReduce.cpp +++ b/lib/Transforms/Scalar/LoopStrengthReduce.cpp @@ -46,7 +46,7 @@ namespace { /// 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; @@ -66,7 +66,7 @@ namespace { /// 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 Users; @@ -79,7 +79,7 @@ namespace { /// 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; @@ -95,7 +95,7 @@ namespace { /// 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 IVs; void addIV(const SCEVHandle &Stride, const SCEVHandle &Base, PHINode *PHI, diff --git a/lib/Transforms/Scalar/LoopUnroll.cpp b/lib/Transforms/Scalar/LoopUnroll.cpp index c6d88538310..d1770da8fce 100644 --- a/lib/Transforms/Scalar/LoopUnroll.cpp +++ b/lib/Transforms/Scalar/LoopUnroll.cpp @@ -27,6 +27,7 @@ #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" @@ -44,7 +45,7 @@ namespace { 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); diff --git a/lib/Transforms/Scalar/LoopUnswitch.cpp b/lib/Transforms/Scalar/LoopUnswitch.cpp index 9492cefb6a1..8a4ac01fbe4 100644 --- a/lib/Transforms/Scalar/LoopUnswitch.cpp +++ b/lib/Transforms/Scalar/LoopUnswitch.cpp @@ -39,8 +39,9 @@ #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 #include using namespace llvm; @@ -56,7 +57,7 @@ namespace { 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. diff --git a/lib/Transforms/Scalar/LowerPacked.cpp b/lib/Transforms/Scalar/LowerPacked.cpp index c2ec981c190..116cccad62a 100644 --- a/lib/Transforms/Scalar/LowerPacked.cpp +++ b/lib/Transforms/Scalar/LowerPacked.cpp @@ -19,6 +19,7 @@ #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" @@ -36,7 +37,8 @@ namespace { /// /// @brief Transforms packed instructions to simpler instructions. /// -class LowerPacked : public FunctionPass, public InstVisitor { +class VISIBILITY_HIDDEN LowerPacked + : public FunctionPass, public InstVisitor { public: /// @brief Lowers packed operations to scalar operations. /// @param F The fuction to process diff --git a/lib/Transforms/Scalar/Reassociate.cpp b/lib/Transforms/Scalar/Reassociate.cpp index 4fcbf35f567..40f2ece255e 100644 --- a/lib/Transforms/Scalar/Reassociate.cpp +++ b/lib/Transforms/Scalar/Reassociate.cpp @@ -29,6 +29,7 @@ #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" @@ -41,7 +42,7 @@ STATISTIC(NumAnnihil, "Number of expr tree annihilated"); 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) {} @@ -63,7 +64,7 @@ static void PrintOps(Instruction *I, const std::vector &Ops) { } namespace { - class Reassociate : public FunctionPass { + class VISIBILITY_HIDDEN Reassociate : public FunctionPass { std::map RankMap; std::map ValueRankMap; bool MadeChange; diff --git a/lib/Transforms/Scalar/Reg2Mem.cpp b/lib/Transforms/Scalar/Reg2Mem.cpp index a5faa422e46..e1eab65bd40 100644 --- a/lib/Transforms/Scalar/Reg2Mem.cpp +++ b/lib/Transforms/Scalar/Reg2Mem.cpp @@ -25,13 +25,14 @@ #include "llvm/BasicBlock.h" #include "llvm/Instructions.h" #include "llvm/ADT/Statistic.h" +#include "llvm/Support/Compiler.h" #include 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); diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp index 411d9023975..78377e74271 100644 --- a/lib/Transforms/Scalar/SCCP.cpp +++ b/lib/Transforms/Scalar/SCCP.cpp @@ -31,6 +31,7 @@ #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" @@ -53,7 +54,7 @@ namespace { /// 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, @@ -1332,7 +1333,7 @@ namespace { /// 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. // @@ -1440,7 +1441,7 @@ namespace { /// IPSCCP Class - This class implements interprocedural Sparse Conditional /// Constant Propagation. /// - struct IPSCCP : public ModulePass { + struct VISIBILITY_HIDDEN IPSCCP : public ModulePass { bool runOnModule(Module &M); }; diff --git a/lib/Transforms/Scalar/SimplifyCFG.cpp b/lib/Transforms/Scalar/SimplifyCFG.cpp index f363a3a5c58..97ea9f4ce55 100644 --- a/lib/Transforms/Scalar/SimplifyCFG.cpp +++ b/lib/Transforms/Scalar/SimplifyCFG.cpp @@ -25,6 +25,7 @@ #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 @@ -33,7 +34,7 @@ using namespace llvm; STATISTIC(NumSimpl, "Number of blocks simplified"); namespace { - struct CFGSimplifyPass : public FunctionPass { + struct VISIBILITY_HIDDEN CFGSimplifyPass : public FunctionPass { virtual bool runOnFunction(Function &F); }; RegisterPass X("simplifycfg", "Simplify the CFG"); diff --git a/lib/Transforms/Scalar/TailDuplication.cpp b/lib/Transforms/Scalar/TailDuplication.cpp index 97e8b186e52..398da0aa9b6 100644 --- a/lib/Transforms/Scalar/TailDuplication.cpp +++ b/lib/Transforms/Scalar/TailDuplication.cpp @@ -29,6 +29,7 @@ #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; @@ -39,7 +40,7 @@ namespace { cl::opt 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); diff --git a/lib/Transforms/Scalar/TailRecursionElimination.cpp b/lib/Transforms/Scalar/TailRecursionElimination.cpp index daa6200871a..d2ec688b749 100644 --- a/lib/Transforms/Scalar/TailRecursionElimination.cpp +++ b/lib/Transforms/Scalar/TailRecursionElimination.cpp @@ -59,13 +59,14 @@ #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: diff --git a/lib/Transforms/Utils/CloneFunction.cpp b/lib/Transforms/Utils/CloneFunction.cpp index 5db664f443c..542ced8b98b 100644 --- a/lib/Transforms/Utils/CloneFunction.cpp +++ b/lib/Transforms/Utils/CloneFunction.cpp @@ -19,6 +19,7 @@ #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" @@ -152,7 +153,7 @@ Function *llvm::CloneFunction(const Function *F, 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 &ValueMap; diff --git a/lib/Transforms/Utils/CodeExtractor.cpp b/lib/Transforms/Utils/CodeExtractor.cpp index 0f35d8b2551..87a286838df 100644 --- a/lib/Transforms/Utils/CodeExtractor.cpp +++ b/lib/Transforms/Utils/CodeExtractor.cpp @@ -25,6 +25,7 @@ #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 @@ -40,7 +41,7 @@ AggregateArgsOpt("aggregate-extracted-args", cl::Hidden, cl::desc("Aggregate arguments to code-extracted functions")); namespace { - class CodeExtractor { + class VISIBILITY_HIDDEN CodeExtractor { typedef std::vector Values; std::set BlocksToExtract; DominatorSet *DS; diff --git a/lib/Transforms/Utils/LCSSA.cpp b/lib/Transforms/Utils/LCSSA.cpp index 554dcbcec22..b0a8caeef96 100644 --- a/lib/Transforms/Utils/LCSSA.cpp +++ b/lib/Transforms/Utils/LCSSA.cpp @@ -38,6 +38,7 @@ #include "llvm/Analysis/Dominators.h" #include "llvm/Analysis/LoopInfo.h" #include "llvm/Support/CFG.h" +#include "llvm/Support/Compiler.h" #include #include using namespace llvm; @@ -45,7 +46,7 @@ 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; diff --git a/lib/Transforms/Utils/LowerSelect.cpp b/lib/Transforms/Utils/LowerSelect.cpp index c0c8a329da2..5f9f593f9d1 100644 --- a/lib/Transforms/Utils/LowerSelect.cpp +++ b/lib/Transforms/Utils/LowerSelect.cpp @@ -24,12 +24,13 @@ #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) {}