PrintAllFailures("count-aa-print-all-failed-queries", cl::ReallyHidden);
namespace {
- class VISIBILITY_HIDDEN AliasAnalysisCounter
- : public ModulePass, public AliasAnalysis {
+ class AliasAnalysisCounter : public ModulePass, public AliasAnalysis {
unsigned No, May, Must;
unsigned NoMR, JustRef, JustMod, MR;
const char *Name;
static cl::opt<bool> PrintModRef("print-modref", cl::ReallyHidden);
namespace {
- class VISIBILITY_HIDDEN AAEval : public FunctionPass {
+ class AAEval : public FunctionPass {
unsigned NoAlias, MayAlias, MustAlias;
unsigned NoModRef, Mod, Ref, ModRef;
namespace {
- class VISIBILITY_HIDDEN AliasDebugger
- : public ModulePass, public AliasAnalysis {
+ class AliasDebugger : public ModulePass, public AliasAnalysis {
//What we do is simple. Keep track of every value the AA could
//know about, and verify that queries are one of those.
//===----------------------------------------------------------------------===//
namespace {
- class VISIBILITY_HIDDEN AliasSetPrinter : public FunctionPass {
+ class AliasSetPrinter : public FunctionPass {
AliasSetTracker *Tracker;
public:
static char ID; // Pass identification, replacement for typeid
/// implementations, in that it does not chain to a previous analysis. As
/// such it doesn't follow many of the rules that other alias analyses must.
///
- struct VISIBILITY_HIDDEN NoAA : public ImmutablePass, public AliasAnalysis {
+ struct NoAA : public ImmutablePass, public AliasAnalysis {
static char ID; // Class identification, replacement for typeinfo
NoAA() : ImmutablePass(&ID) {}
explicit NoAA(void *PID) : ImmutablePass(PID) { }
/// BasicAliasAnalysis - This is the default alias analysis implementation.
/// Because it doesn't chain to a previous alias analysis (like -no-aa), it
/// derives from the NoAA class.
- struct VISIBILITY_HIDDEN BasicAliasAnalysis : public NoAA {
+ struct BasicAliasAnalysis : public NoAA {
static char ID; // Class identification, replacement for typeinfo
BasicAliasAnalysis() : NoAA(&ID) {}
AliasResult alias(const Value *V1, unsigned V1Size,
using namespace llvm;
namespace {
- struct VISIBILITY_HIDDEN CFGViewer : public FunctionPass {
+ struct CFGViewer : public FunctionPass {
static char ID; // Pass identifcation, replacement for typeid
CFGViewer() : FunctionPass(&ID) {}
V0("view-cfg", "View CFG of function", false, true);
namespace {
- struct VISIBILITY_HIDDEN CFGOnlyViewer : public FunctionPass {
+ struct CFGOnlyViewer : public FunctionPass {
static char ID; // Pass identifcation, replacement for typeid
CFGOnlyViewer() : FunctionPass(&ID) {}
"View CFG of function (with no function bodies)", false, true);
namespace {
- struct VISIBILITY_HIDDEN CFGPrinter : public FunctionPass {
+ struct CFGPrinter : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
CFGPrinter() : FunctionPass(&ID) {}
explicit CFGPrinter(void *pid) : FunctionPass(pid) {}
P1("dot-cfg", "Print CFG of function to 'dot' file", false, true);
namespace {
- struct VISIBILITY_HIDDEN CFGOnlyPrinter : public FunctionPass {
+ struct CFGOnlyPrinter : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
CFGOnlyPrinter() : FunctionPass(&ID) {}
explicit CFGOnlyPrinter(void *pid) : FunctionPass(pid) {}
cl::Hidden);
namespace {
- class VISIBILITY_HIDDEN PrintDbgInfo : public FunctionPass {
+ class PrintDbgInfo : public FunctionPass {
raw_ostream &Out;
void printStopPoint(const DbgStopPointInst *DSI);
void printFuncStart(const DbgFuncStartInst *FS);
static bool isPod() { return true; }
};
- class VISIBILITY_HIDDEN Andersens : public ModulePass, public AliasAnalysis,
-
private InstVisitor<Andersens> {
+ class Andersens : public ModulePass, public AliasAnalysis,
+ private InstVisitor<Andersens> {
struct Node;
/// Constraint - Objects of this structure are used to represent the various
//===----------------------------------------------------------------------===//
// BasicCallGraph class definition
//
-class VISIBILITY_HIDDEN BasicCallGraph : public CallGraph, public ModulePass {
+class BasicCallGraph : public CallGraph, public ModulePass {
// Root is root of the call graph, or the external node if a 'main' function
// couldn't be found.
//
/// function in the program. Later, the entries for these functions are
/// removed if the function is found to call an external function (in which
/// case we know nothing about it.
- struct VISIBILITY_HIDDEN FunctionRecord {
+ struct FunctionRecord {
/// GlobalInfo - Maintain mod/ref info for all of the globals without
/// addresses taken that are read or written (transitively) by this
/// function.
};
/// GlobalsModRef - The actual analysis pass.
- class VISIBILITY_HIDDEN GlobalsModRef
- : public ModulePass, public AliasAnalysis {
+ class GlobalsModRef : public ModulePass, public AliasAnalysis {
/// NonAddressTakenGlobals - The globals that do not have their addresses
/// taken.
std::set<GlobalValue*> NonAddressTakenGlobals;
namespace {
- class VISIBILITY_HIDDEN InstCount
- : public FunctionPass, public InstVisitor<InstCount> {
+ class InstCount : public FunctionPass, public InstVisitor<InstCount> {
friend class InstVisitor<InstCount>;
void visitFunction (Function &F) { ++TotalFuncs; }
);
namespace {
- class VISIBILITY_HIDDEN ProfileEstimatorPass :
- public FunctionPass, public ProfileInfo {
+ class ProfileEstimatorPass : public FunctionPass, public ProfileInfo {
double ExecCount;
LoopInfo *LI;
std::set<BasicBlock*> BBToVisit;
//
namespace {
- struct VISIBILITY_HIDDEN NoProfileInfo
- : public ImmutablePass, public ProfileInfo {
+ struct NoProfileInfo : public ImmutablePass, public ProfileInfo {
static char ID; // Class identification, replacement for typeinfo
NoProfileInfo() : ImmutablePass(&ID) {}
};
cl::desc("Profile file loaded by -profile-loader"));
namespace {
- class VISIBILITY_HIDDEN LoaderPass : public ModulePass, public ProfileInfo {
+ class LoaderPass : public ModulePass, public ProfileInfo {
std::string Filename;
std::set<Edge> SpanningTree;
std::set<const BasicBlock*> BBisUnvisited;
cl::desc("Disable assertions"));
namespace {
- class VISIBILITY_HIDDEN ProfileVerifierPass : public FunctionPass {
+ class ProfileVerifierPass : public FunctionPass {
struct DetailedBlockInfo {
const BasicBlock *BB;
/// SCEVComplexityCompare - Return true if the complexity of the LHS is less
/// than the complexity of the RHS. This comparator is used to canonicalize
/// expressions.
- class VISIBILITY_HIDDEN SCEVComplexityCompare {
+ class SCEVComplexityCompare {
LoopInfo *LI;
public:
explicit SCEVComplexityCompare(LoopInfo *li) : LI(li) {}
namespace {
/// ScalarEvolutionAliasAnalysis - This is a simple alias analysis
/// implementation that uses ScalarEvolution to answer queries.
- class VISIBILITY_HIDDEN ScalarEvolutionAliasAnalysis : public FunctionPass,
- public AliasAnalysis {
+ class ScalarEvolutionAliasAnalysis : public FunctionPass,
+ public AliasAnalysis {
ScalarEvolution *SE;
public:
namespace {
- class VISIBILITY_HIDDEN OcamlGCMetadataPrinter : public GCMetadataPrinter {
+ class OcamlGCMetadataPrinter : public GCMetadataPrinter {
public:
void beginAssembly(raw_ostream &OS, AsmPrinter &AP,
const MCAsmInfo &MAI);
using namespace llvm;
namespace {
- class VISIBILITY_HIDDEN DeadMachineInstructionElim :
- public MachineFunctionPass {
+ class DeadMachineInstructionElim : public MachineFunctionPass {
virtual bool runOnMachineFunction(MachineFunction &MF);
const TargetRegisterInfo *TRI;
STATISTIC(NumStackTempsIntroduced, "Number of stack temporaries introduced");
namespace {
- class VISIBILITY_HIDDEN DwarfEHPrepare : public FunctionPass {
+ class DwarfEHPrepare : public FunctionPass {
const TargetLowering *TLI;
bool CompileFast;
namespace {
- class VISIBILITY_HIDDEN Printer : public FunctionPass {
+ class Printer : public FunctionPass {
static char ID;
raw_ostream &OS;
bool runOnFunction(Function &F);
};
- class VISIBILITY_HIDDEN Deleter : public FunctionPass {
+ class Deleter : public FunctionPass {
static char ID;
public:
/// llvm.gcwrite intrinsics, replacing them with simple loads and stores as
/// directed by the GCStrategy. It also performs automatic root initialization
/// and custom intrinsic lowering.
- class VISIBILITY_HIDDEN LowerIntrinsics : public FunctionPass {
+ class LowerIntrinsics : public FunctionPass {
static bool NeedsDefaultLoweringPass(const GCStrategy &C);
static bool NeedsCustomLoweringPass(const GCStrategy &C);
static bool CouldBecomeSafePoint(Instruction *I);
/// function representation to identify safe points for the garbage collector
/// in the machine code. It inserts labels at safe points and populates a
/// GCMetadata record for each function.
- class VISIBILITY_HIDDEN MachineCodeAnalysis : public MachineFunctionPass {
+ class MachineCodeAnalysis : public MachineFunctionPass {
const TargetMachine *TM;
GCFunctionInfo *FI;
MachineModuleInfo *MMI;
STATISTIC(NumDupBBs, "Number of duplicated blocks");
namespace {
- class VISIBILITY_HIDDEN IfConverter : public MachineFunctionPass {
+ class IfConverter : public MachineFunctionPass {
enum IfcvtKind {
ICNotClassfied, // BB data valid, but not classified.
ICSimpleFalse, // Same as ICSimple, but on the false path.
using namespace llvm;
namespace {
- struct VISIBILITY_HIDDEN LowerSubregsInstructionPass
- : public MachineFunctionPass {
+ struct LowerSubregsInstructionPass : public MachineFunctionPass {
static char ID; // Pass identification, replacement for typeid
LowerSubregsInstructionPass() : MachineFunctionPass(&ID) {}
using namespace llvm;
namespace {
- struct VISIBILITY_HIDDEN Printer : public MachineFunctionPass {
+ struct Printer : public MachineFunctionPass {
static char ID;
raw_ostream &OS;
STATISTIC(NumCSEed, "Number of hoisted machine instructions CSEed");
namespace {
- class VISIBILITY_HIDDEN MachineLICM : public MachineFunctionPass {
+ class MachineLICM : public MachineFunctionPass {
const TargetMachine *TM;
const TargetInstrInfo *TII;
const TargetRegisterInfo *TRI;
STATISTIC(NumSunk, "Number of machine instructions sunk");
namespace {
- class VISIBILITY_HIDDEN MachineSinking : public MachineFunctionPass {
+ class MachineSinking : public MachineFunctionPass {
const TargetInstrInfo *TII;
const TargetRegisterInfo *TRI;
MachineRegisterInfo *RegInfo; // Machine register information
using namespace llvm;
namespace {
- struct VISIBILITY_HIDDEN MachineVerifier : public MachineFunctionPass {
+ struct MachineVerifier : public MachineFunctionPass {
static char ID; // Pass ID, replacement for typeid
MachineVerifier(bool allowDoubleDefs = false) :
using namespace llvm;
namespace {
- class VISIBILITY_HIDDEN OcamlGC : public GCStrategy {
+ class OcamlGC : public GCStrategy {
public:
OcamlGC();
};
cl::init(0), cl::Hidden);
namespace {
- class VISIBILITY_HIDDEN PostRAScheduler : public MachineFunctionPass {
+ class PostRAScheduler : public MachineFunctionPass {
AliasAnalysis *AA;
CodeGenOpt::Level OptLevel;
};
char PostRAScheduler::ID = 0;
- class VISIBILITY_HIDDEN SchedulePostRATDList : public ScheduleDAGInstrs {
+ class SchedulePostRATDList : public ScheduleDAGInstrs {
/// AvailableQueue - The priority queue to use for the available SUnits.
///
LatencyPriorityQueue AvailableQueue;
STATISTIC(NumDeadSpills, "Number of dead spills removed");
namespace {
- class VISIBILITY_HIDDEN PreAllocSplitting : public MachineFunctionPass {
+ class PreAllocSplitting : public MachineFunctionPass {
MachineFunction *CurrMF;
const TargetMachine *TM;
const TargetInstrInfo *TII;
/// FixedStackPseudoSourceValue - A specialized PseudoSourceValue
/// for holding FixedStack values, which must include a frame
/// index.
- class VISIBILITY_HIDDEN FixedStackPseudoSourceValue
- : public PseudoSourceValue {
+ class FixedStackPseudoSourceValue : public PseudoSourceValue {
const int FI;
public:
explicit FixedStackPseudoSourceValue(int fi) : FI(fi) {}
createLinearScanRegisterAllocator);
namespace {
- struct VISIBILITY_HIDDEN RALinScan : public MachineFunctionPass {
+ struct RALinScan : public MachineFunctionPass {
static char ID;
RALinScan() : MachineFunctionPass(&ID) {}
createLocalRegisterAllocator);
namespace {
- class VISIBILITY_HIDDEN RALocal : public MachineFunctionPass {
+ class RALocal : public MachineFunctionPass {
public:
static char ID;
RALocal() : MachineFunctionPass(&ID), StackSlotForVirtReg(-1) {}
/// PBQP based allocators solve the register allocation problem by mapping
/// register allocation problems to Partitioned Boolean Quadratic
/// Programming problems.
- class VISIBILITY_HIDDEN PBQPRegAlloc : public MachineFunctionPass {
+ class PBQPRegAlloc : public MachineFunctionPass {
public:
static char ID;
//------------------------------ DAGCombiner ---------------------------------//
- class VISIBILITY_HIDDEN DAGCombiner {
+ class DAGCombiner {
SelectionDAG &DAG;
const TargetLowering &TLI;
CombineLevel Level;
namespace {
/// WorkListRemover - This class is a DAGUpdateListener that removes any deleted
/// nodes from the worklist.
-class VISIBILITY_HIDDEN WorkListRemover :
- public SelectionDAG::DAGUpdateListener {
+class WorkListRemover : public SelectionDAG::DAGUpdateListener {
DAGCombiner &DC;
public:
explicit WorkListRemover(DAGCombiner &dc) : DC(dc) {}
/// will attempt merge setcc and brc instructions into brcc's.
///
namespace {
-class VISIBILITY_HIDDEN SelectionDAGLegalize {
+class SelectionDAGLegalize {
TargetLowering &TLI;
SelectionDAG &DAG;
CodeGenOpt::Level OptLevel;
namespace {
/// NodeUpdateListener - This class is a DAGUpdateListener that listens for
/// updates to nodes and recomputes their ready state.
- class VISIBILITY_HIDDEN NodeUpdateListener :
- public SelectionDAG::DAGUpdateListener {
+ class NodeUpdateListener : public SelectionDAG::DAGUpdateListener {
DAGTypeLegalizer &DTL;
SmallSetVector<SDNode*, 16> &NodesToAnalyze;
public:
/// FastPriorityQueue - A degenerate priority queue that considers
/// all nodes to have the same priority.
///
- struct VISIBILITY_HIDDEN FastPriorityQueue {
+ struct FastPriorityQueue {
SmallVector<SUnit *, 16> Queue;
bool empty() const { return Queue.empty(); }
//===----------------------------------------------------------------------===//
/// ScheduleDAGFast - The actual "fast" list scheduler implementation.
///
-class VISIBILITY_HIDDEN ScheduleDAGFast : public ScheduleDAGSDNodes {
+class ScheduleDAGFast : public ScheduleDAGSDNodes {
private:
/// AvailableQueue - The priority queue to use for the available SUnits.
FastPriorityQueue AvailableQueue;
/// ScheduleDAGList - The actual list scheduler implementation. This supports
/// top-down scheduling.
///
-class VISIBILITY_HIDDEN ScheduleDAGList : public ScheduleDAGSDNodes {
+class ScheduleDAGList : public ScheduleDAGSDNodes {
private:
/// AvailableQueue - The priority queue to use for the available SUnits.
///
/// ScheduleDAGRRList - The actual register reduction list scheduler
/// implementation. This supports both top-down and bottom-up scheduling.
///
-class VISIBILITY_HIDDEN ScheduleDAGRRList : public ScheduleDAGSDNodes {
+class ScheduleDAGRRList : public ScheduleDAGSDNodes {
private:
/// isBottomUp - This is true if the scheduling problem is bottom-up, false if
/// it is top-down.
namespace {
template<class SF>
- class VISIBILITY_HIDDEN RegReductionPriorityQueue
- : public SchedulingPriorityQueue {
+ class RegReductionPriorityQueue : public SchedulingPriorityQueue {
PriorityQueue<SUnit*, std::vector<SUnit*>, SF> Queue;
unsigned currentQueueId;
namespace {
- class VISIBILITY_HIDDEN ShadowStackGC : public GCStrategy {
+ class ShadowStackGC : public GCStrategy {
/// RootChain - This is the global linked-list that contains the chain of GC
/// roots.
GlobalVariable *Head;
///
/// It's wrapped up in a state machine using the same transform C# uses for
/// 'yield return' enumerators, This transform allows it to be non-allocating.
- class VISIBILITY_HIDDEN EscapeEnumerator {
+ class EscapeEnumerator {
Function &F;
const char *CleanupBBName;
STATISTIC(NumSpilled, "Number of registers live across unwind edges");
namespace {
- class VISIBILITY_HIDDEN SjLjEHPass : public FunctionPass {
+ class SjLjEHPass : public FunctionPass {
const TargetLowering *TLI;
"stack protection"));
namespace {
- class VISIBILITY_HIDDEN StackProtector : public FunctionPass {
+ class StackProtector : public FunctionPass {
/// TLI - Keep a pointer of a TargetLowering to consult for determining
/// target type sizes.
const TargetLowering *TLI;
STATISTIC(NumDead, "Number of trivially dead stack accesses eliminated");
namespace {
- class VISIBILITY_HIDDEN StackSlotColoring : public MachineFunctionPass {
+ class StackSlotColoring : public MachineFunctionPass {
bool ColorWithRegs;
LiveStacks* LS;
VirtRegMap* VRM;
using namespace llvm;
namespace {
- struct VISIBILITY_HIDDEN StrongPHIElimination : public MachineFunctionPass {
+ struct StrongPHIElimination : public MachineFunctionPass {
static char ID; // Pass identification, replacement for typeid
StrongPHIElimination() : MachineFunctionPass(&ID) {}
STATISTIC(NumDeletes, "Number of dead instructions deleted");
namespace {
- class VISIBILITY_HIDDEN TwoAddressInstructionPass
- : public MachineFunctionPass {
+ class TwoAddressInstructionPass : public MachineFunctionPass {
const TargetInstrInfo *TII;
const TargetRegisterInfo *TRI;
MachineRegisterInfo *MRI;
using namespace llvm;
namespace {
- class VISIBILITY_HIDDEN UnreachableBlockElim : public FunctionPass {
+ class UnreachableBlockElim : public FunctionPass {
virtual bool runOnFunction(Function &F);
public:
static char ID; // Pass identification, replacement for typeid
namespace {
- class VISIBILITY_HIDDEN UnreachableMachineBlockElim :
- public MachineFunctionPass {
+ class UnreachableMachineBlockElim : public MachineFunctionPass {
virtual bool runOnMachineFunction(MachineFunction &F);
virtual void getAnalysisUsage(AnalysisUsage &AU) const;
MachineModuleInfo *MMI;
/// This class is intended for use with the new spilling framework only. It
/// rewrites vreg def/uses to use the assigned preg, but does not insert any
/// spill code.
-struct VISIBILITY_HIDDEN TrivialRewriter : public VirtRegRewriter {
+struct TrivialRewriter : public VirtRegRewriter {
bool runOnMachineFunction(MachineFunction &MF, VirtRegMap &VRM,
LiveIntervals* LIs) {
/// on a per-stack-slot / remat id basis as the low bit in the value of the
/// SpillSlotsAvailable entries. The predicate 'canClobberPhysReg()' checks
/// this bit and addAvailable sets it if.
-class VISIBILITY_HIDDEN AvailableSpills {
+class AvailableSpills {
const TargetRegisterInfo *TRI;
const TargetInstrInfo *TII;
/// ReuseInfo - This maintains a collection of ReuseOp's for each operand that
/// is reused instead of reloaded.
-class VISIBILITY_HIDDEN ReuseInfo {
+class ReuseInfo {
MachineInstr &MI;
std::vector<ReusedOp> Reuses;
BitVector PhysRegsClobbered;
namespace {
-class VISIBILITY_HIDDEN LocalRewriter : public VirtRegRewriter {
+class LocalRewriter : public VirtRegRewriter {
MachineRegisterInfo *RegInfo;
const TargetRegisterInfo *TRI;
const TargetInstrInfo *TII;
};
template<class CodeEmitter>
- class VISIBILITY_HIDDEN Emitter : public MachineFunctionPass,
- public ARMCodeEmitter {
+ class Emitter : public MachineFunctionPass, public ARMCodeEmitter {
ARMJITInfo *JTI;
const ARMInstrInfo *II;
const TargetData *TD;
/// Water - Potential places where an island could be formed.
/// CPE - A constant pool entry that has been placed somewhere, which
/// tracks a list of users.
- class VISIBILITY_HIDDEN ARMConstantIslands : public MachineFunctionPass {
+ class ARMConstantIslands : public MachineFunctionPass {
/// BBSizes - The size of each MachineBasicBlock in bytes of code, indexed
/// by MBB Number. The two-byte pads required for Thumb alignment are
/// counted as part of the following block (i.e., the offset and size for
/// load / store instructions to form ldm / stm instructions.
namespace {
- struct VISIBILITY_HIDDEN ARMLoadStoreOpt : public MachineFunctionPass {
+ struct ARMLoadStoreOpt : public MachineFunctionPass {
static char ID;
ARMLoadStoreOpt() : MachineFunctionPass(&ID) {}
/// likely they will be combined later.
namespace {
- struct VISIBILITY_HIDDEN ARMPreAllocLoadStoreOpt : public MachineFunctionPass{
+ struct ARMPreAllocLoadStoreOpt : public MachineFunctionPass{
static char ID;
ARMPreAllocLoadStoreOpt() : MachineFunctionPass(&ID) {}
using namespace llvm;
namespace {
- class VISIBILITY_HIDDEN NEONPreAllocPass : public MachineFunctionPass {
+ class NEONPreAllocPass : public MachineFunctionPass {
const TargetInstrInfo *TII;
public:
STATISTIC(NumITs, "Number of IT blocks inserted");
namespace {
- struct VISIBILITY_HIDDEN Thumb2ITBlockPass : public MachineFunctionPass {
+ struct Thumb2ITBlockPass : public MachineFunctionPass {
static char ID;
Thumb2ITBlockPass() : MachineFunctionPass(&ID) {}
{ ARM::t2STM, ARM::tSTM, ARM::tPUSH, 0, 0, 1, 1, 1,1, 1 },
};
- class VISIBILITY_HIDDEN Thumb2SizeReduce : public MachineFunctionPass {
+ class Thumb2SizeReduce : public MachineFunctionPass {
public:
static char ID;
Thumb2SizeReduce();
using namespace llvm;
namespace {
- struct VISIBILITY_HIDDEN AlphaBSel : public MachineFunctionPass {
+ struct AlphaBSel : public MachineFunctionPass {
static char ID;
AlphaBSel() : MachineFunctionPass(&ID) {}
};
template <class CodeEmitter>
- class VISIBILITY_HIDDEN Emitter : public MachineFunctionPass,
- public AlphaCodeEmitter
+ class Emitter : public MachineFunctionPass, public AlphaCodeEmitter
{
const AlphaInstrInfo *II;
TargetMachine &TM;
STATISTIC(EmittedInsts, "Number of machine instrs printed");
namespace {
- struct VISIBILITY_HIDDEN AlphaAsmPrinter : public AsmPrinter {
+ struct AlphaAsmPrinter : public AsmPrinter {
/// Unique incrementer for label values for referencing Global values.
///
STATISTIC(EmittedInsts, "Number of machine instrs printed");
namespace {
- class VISIBILITY_HIDDEN BlackfinAsmPrinter : public AsmPrinter {
+ class BlackfinAsmPrinter : public AsmPrinter {
public:
BlackfinAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
const MCAsmInfo *MAI, bool V)
const std::string bss_section(".bss");
- class VISIBILITY_HIDDEN SPUAsmPrinter : public AsmPrinter {
+ class SPUAsmPrinter : public AsmPrinter {
std::set<std::string> FnStubs, GVStubs;
public:
explicit SPUAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
};
/// LinuxAsmPrinter - SPU assembly printer, customized for Linux
- class VISIBILITY_HIDDEN LinuxAsmPrinter : public SPUAsmPrinter {
+ class LinuxAsmPrinter : public SPUAsmPrinter {
public:
explicit LinuxAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
const MCAsmInfo *T, bool V)
namespace llvm {
// TargetMachine for the MSIL
- struct VISIBILITY_HIDDEN MSILTarget : public TargetMachine {
+ struct MSILTarget : public TargetMachine {
MSILTarget(const Target &T, const std::string &TT, const std::string &FS)
: TargetMachine(T) {}
cl::desc("enable experimental mcinst gunk in the msp430 backend"));
namespace {
- class VISIBILITY_HIDDEN MSP430AsmPrinter : public AsmPrinter {
+ class MSP430AsmPrinter : public AsmPrinter {
public:
MSP430AsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
const MCAsmInfo *MAI, bool V)
STATISTIC(EmittedInsts, "Number of machine instrs printed");
namespace {
- class VISIBILITY_HIDDEN MipsAsmPrinter : public AsmPrinter {
+ class MipsAsmPrinter : public AsmPrinter {
const MipsSubtarget *Subtarget;
public:
explicit MipsAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
//===----------------------------------------------------------------------===//
namespace {
-class VISIBILITY_HIDDEN MipsDAGToDAGISel : public SelectionDAGISel {
+class MipsDAGToDAGISel : public SelectionDAGISel {
/// TM - Keep a reference to MipsTargetMachine.
MipsTargetMachine &TM;
using namespace llvm;
namespace {
- struct VISIBILITY_HIDDEN MemSelOpt : public MachineFunctionPass {
+ struct MemSelOpt : public MachineFunctionPass {
static char ID;
MemSelOpt() : MachineFunctionPass(&ID) {}
STATISTIC(EmittedInsts, "Number of machine instrs printed");
namespace {
- class VISIBILITY_HIDDEN PPCAsmPrinter : public AsmPrinter {
+ class PPCAsmPrinter : public AsmPrinter {
protected:
struct FnStubInfo {
std::string Stub, LazyPtr, AnonSymbol;
};
/// PPCLinuxAsmPrinter - PowerPC assembly printer, customized for Linux
- class VISIBILITY_HIDDEN PPCLinuxAsmPrinter : public PPCAsmPrinter {
+ class PPCLinuxAsmPrinter : public PPCAsmPrinter {
public:
explicit PPCLinuxAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
const MCAsmInfo *T, bool V)
/// PPCDarwinAsmPrinter - PowerPC assembly printer, customized for Darwin/Mac
/// OS X
- class VISIBILITY_HIDDEN PPCDarwinAsmPrinter : public PPCAsmPrinter {
+ class PPCDarwinAsmPrinter : public PPCAsmPrinter {
formatted_raw_ostream &OS;
public:
explicit PPCDarwinAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
STATISTIC(NumExpanded, "Number of branches expanded to long format");
namespace {
- struct VISIBILITY_HIDDEN PPCBSel : public MachineFunctionPass {
+ struct PPCBSel : public MachineFunctionPass {
static char ID;
PPCBSel() : MachineFunctionPass(&ID) {}
};
template <class CodeEmitter>
- class VISIBILITY_HIDDEN Emitter : public MachineFunctionPass,
- public PPCCodeEmitter {
+ class Emitter : public MachineFunctionPass, public PPCCodeEmitter {
TargetMachine &TM;
CodeEmitter &MCE;
/// PPCDAGToDAGISel - PPC specific code to select PPC machine
/// instructions for SelectionDAG operations.
///
- class VISIBILITY_HIDDEN PPCDAGToDAGISel : public SelectionDAGISel {
+ class PPCDAGToDAGISel : public SelectionDAGISel {
PPCTargetMachine &TM;
PPCTargetLowering &PPCLowering;
const PPCSubtarget &PPCSubTarget;
STATISTIC(EmittedInsts, "Number of machine instrs printed");
namespace {
- class VISIBILITY_HIDDEN SparcAsmPrinter : public AsmPrinter {
+ class SparcAsmPrinter : public AsmPrinter {
/// We name each basic block in a Function with a unique number, so
/// that we can consistently refer to them later. This is cleared
/// at the beginning of each call to runOnMachineFunction().
STATISTIC(EmittedInsts, "Number of machine instrs printed");
namespace {
- class VISIBILITY_HIDDEN SystemZAsmPrinter : public AsmPrinter {
+ class SystemZAsmPrinter : public AsmPrinter {
public:
SystemZAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
const MCAsmInfo *MAI, bool V)
namespace {
template<class CodeEmitter>
- class VISIBILITY_HIDDEN Emitter : public MachineFunctionPass {
+ class Emitter : public MachineFunctionPass {
const X86InstrInfo *II;
const TargetData *TD;
X86TargetMachine &TM;
STATISTIC(NumFP , "Number of floating point instructions");
namespace {
- struct VISIBILITY_HIDDEN FPS : public MachineFunctionPass {
+ struct FPS : public MachineFunctionPass {
static char ID;
FPS() : MachineFunctionPass(&ID) {}
STATISTIC(NumFPKill, "Number of FP_REG_KILL instructions added");
namespace {
- struct VISIBILITY_HIDDEN FPRegKiller : public MachineFunctionPass {
+ struct FPRegKiller : public MachineFunctionPass {
static char ID;
FPRegKiller() : MachineFunctionPass(&ID) {}
/// ISel - X86 specific code to select X86 machine instructions for
/// SelectionDAG operations.
///
- class VISIBILITY_HIDDEN X86DAGToDAGISel : public SelectionDAGISel {
+ class X86DAGToDAGISel : public SelectionDAGISel {
/// X86Lowering - This object fully describes how to lower LLVM code to an
/// X86-specific SelectionDAG.
X86TargetLowering &X86Lowering;
#include "X86GenRegisterInfo.inc"
namespace {
- struct VISIBILITY_HIDDEN MSAC : public MachineFunctionPass {
+ struct MSAC : public MachineFunctionPass {
static char ID;
MSAC() : MachineFunctionPass(&ID) {}
cl::init(8));
namespace {
- class VISIBILITY_HIDDEN XCoreAsmPrinter : public AsmPrinter {
+ class XCoreAsmPrinter : public AsmPrinter {
const XCoreSubtarget &Subtarget;
public:
explicit XCoreAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
namespace {
/// ArgPromotion - The 'by reference' to 'by value' argument promotion pass.
///
- struct VISIBILITY_HIDDEN ArgPromotion : public CallGraphSCCPass {
+ struct ArgPromotion : public CallGraphSCCPass {
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<AliasAnalysis>();
CallGraphSCCPass::getAnalysisUsage(AU);
STATISTIC(NumMerged, "Number of global constants merged");
namespace {
- struct VISIBILITY_HIDDEN ConstantMerge : public ModulePass {
+ struct ConstantMerge : public ModulePass {
static char ID; // Pass identification, replacement for typeid
ConstantMerge() : ModulePass(&ID) {}
namespace {
/// DAE - The dead argument elimination pass.
///
- class VISIBILITY_HIDDEN DAE : public ModulePass {
+ class DAE : public ModulePass {
public:
/// Struct that represents (part of) either a return value or a function
STATISTIC(NumKilled, "Number of unused typenames removed from symtab");
namespace {
- struct VISIBILITY_HIDDEN DTE : public ModulePass {
+ struct DTE : public ModulePass {
static char ID; // Pass identification, replacement for typeid
DTE() : ModulePass(&ID) {}
namespace {
/// @brief A pass to extract specific functions and their dependencies.
- class VISIBILITY_HIDDEN GVExtractorPass : public ModulePass {
+ class GVExtractorPass : public ModulePass {
std::vector<GlobalValue*> Named;
bool deleteStuff;
bool reLink;
STATISTIC(NumNoAlias, "Number of function returns marked noalias");
namespace {
- struct VISIBILITY_HIDDEN FunctionAttrs : public CallGraphSCCPass {
+ struct FunctionAttrs : public CallGraphSCCPass {
static char ID; // Pass identification, replacement for typeid
FunctionAttrs() : CallGraphSCCPass(&ID) {}
STATISTIC(NumVariables, "Number of global variables removed");
namespace {
- struct VISIBILITY_HIDDEN GlobalDCE : public ModulePass {
+ struct GlobalDCE : public ModulePass {
static char ID; // Pass identification, replacement for typeid
GlobalDCE() : ModulePass(&ID) {}
STATISTIC(NumAliasesRemoved, "Number of global aliases eliminated");
namespace {
- struct VISIBILITY_HIDDEN GlobalOpt : public ModulePass {
+ struct GlobalOpt : public ModulePass {
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
}
static char ID; // Pass identification, replacement for typeid
/// 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 VISIBILITY_HIDDEN GlobalStatus {
+struct GlobalStatus {
/// isLoaded - True if the global is ever loaded. If the global isn't ever
/// loaded it can be deleted.
bool isLoaded;
namespace {
/// IPCP - The interprocedural constant propagation pass
///
- struct VISIBILITY_HIDDEN IPCP : public ModulePass {
+ struct IPCP : public ModulePass {
static char ID; // Pass identification, replacement for typeid
IPCP() : ModulePass(&ID) {}
namespace {
// AlwaysInliner only inlines functions that are mark as "always inline".
- class VISIBILITY_HIDDEN AlwaysInliner : public Inliner {
+ class AlwaysInliner : public Inliner {
// Functions that are never inlined
SmallPtrSet<const Function*, 16> NeverInline;
InlineCostAnalyzer CA;
namespace {
- class VISIBILITY_HIDDEN SimpleInliner : public Inliner {
+ class SimpleInliner : public Inliner {
// Functions that are never inlined
SmallPtrSet<const Function*, 16> NeverInline;
InlineCostAnalyzer CA;
cl::CommaSeparated);
namespace {
- class VISIBILITY_HIDDEN InternalizePass : public ModulePass {
+ class InternalizePass : public ModulePass {
std::set<std::string> ExternalNames;
/// If no api symbols were specified and a main function is defined,
/// assume the main function is the only API
STATISTIC(NumExtracted, "Number of loops extracted");
namespace {
- struct VISIBILITY_HIDDEN LoopExtractor : public LoopPass {
+ struct LoopExtractor : public LoopPass {
static char ID; // Pass identification, replacement for typeid
unsigned NumLoops;
namespace {
//===--------------------------------------------------------------------===//
// LowerSetJmp pass implementation.
- class VISIBILITY_HIDDEN LowerSetJmp : public ModulePass,
- public InstVisitor<LowerSetJmp> {
+ class LowerSetJmp : public ModulePass, public InstVisitor<LowerSetJmp> {
// LLVM library functions...
Constant *InitSJMap; // __llvm_sjljeh_init_setjmpmap
Constant *DestroySJMap; // __llvm_sjljeh_destroy_setjmpmap
STATISTIC(NumFunctionsMerged, "Number of functions merged");
namespace {
- struct VISIBILITY_HIDDEN MergeFunctions : public ModulePass {
+ struct MergeFunctions : public ModulePass {
static char ID; // Pass identification, replacement for typeid
MergeFunctions() : ModulePass(&ID) {}
STATISTIC(NumPartialInlined, "Number of functions partially inlined");
namespace {
- struct VISIBILITY_HIDDEN PartialInliner : public ModulePass {
+ struct PartialInliner : public ModulePass {
virtual void getAnalysisUsage(AnalysisUsage &AU) const { }
static char ID; // Pass identification, replacement for typeid
PartialInliner() : ModulePass(&ID) {}
static const double ConstValPercent = .1;
namespace {
- class VISIBILITY_HIDDEN PartSpec : public ModulePass {
+ class PartSpec : public ModulePass {
void scanForInterest(Function&, SmallVector<int, 6>&);
int scanDistribution(Function&, int, std::map<Constant*, int>&);
public :
STATISTIC(NumUnreach, "Number of noreturn calls optimized");
namespace {
- struct VISIBILITY_HIDDEN PruneEH : public CallGraphSCCPass {
+ struct PruneEH : public CallGraphSCCPass {
static char ID; // Pass identification, replacement for typeid
PruneEH() : CallGraphSCCPass(&ID) {}
namespace {
/// @brief Pass to remove unused function declarations.
-class VISIBILITY_HIDDEN StripDeadPrototypesPass : public ModulePass {
+class StripDeadPrototypesPass : public ModulePass {
public:
static char ID; // Pass identification, replacement for typeid
StripDeadPrototypesPass() : ModulePass(&ID) { }
/// SRETPromotion - This pass removes sret parameter and updates
/// function to use multiple return value.
///
- struct VISIBILITY_HIDDEN SRETPromotion : public CallGraphSCCPass {
+ struct SRETPromotion : public CallGraphSCCPass {
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
CallGraphSCCPass::getAnalysisUsage(AU);
}
using namespace llvm;
namespace {
- class VISIBILITY_HIDDEN FunctionProfiler : public RSProfilers_std {
+ class FunctionProfiler : public RSProfilers_std {
public:
static char ID;
bool runOnModule(Module &M);
STATISTIC(NumEdgesInserted, "The # of edges inserted.");
namespace {
- class VISIBILITY_HIDDEN EdgeProfiler : public ModulePass {
+ class EdgeProfiler : public ModulePass {
bool runOnModule(Module &M);
public:
static char ID; // Pass identification, replacement for typeid
STATISTIC(NumEdgesInserted, "The # of edges inserted.");
namespace {
- class VISIBILITY_HIDDEN OptimalEdgeProfiler : public ModulePass {
+ class OptimalEdgeProfiler : public ModulePass {
bool runOnModule(Module &M);
public:
static char ID; // Pass identification, replacement for typeid
/// 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 VISIBILITY_HIDDEN NullProfilerRS : public RSProfilers {
+ class NullProfilerRS : public RSProfilers {
public:
static char ID; // Pass identification, replacement for typeid
bool isProfiling(Value* v) {
namespace {
/// Chooser - Something that chooses when to make a sample of the profiled code
- class VISIBILITY_HIDDEN Chooser {
+ class 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 VISIBILITY_HIDDEN GlobalRandomCounter : public Chooser {
+ class GlobalRandomCounter : public Chooser {
GlobalVariable* Counter;
Value* ResetValue;
const IntegerType* T;
};
//Same is GRC, but allow register allocation of the global counter
- class VISIBILITY_HIDDEN GlobalRandomCounterOpt : public Chooser {
+ class 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 VISIBILITY_HIDDEN CycleCounter : public Chooser {
+ class CycleCounter : public Chooser {
uint64_t rm;
Constant *F;
public:
};
/// ProfilerRS - Insert the random sampling framework
- struct VISIBILITY_HIDDEN ProfilerRS : public FunctionPass {
+ struct ProfilerRS : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
ProfilerRS() : FunctionPass(&ID) {}
/// BasicInlinerImpl - BasicInliner implemantation class. This hides
/// container info, used by basic inliner, from public interface.
- struct VISIBILITY_HIDDEN BasicInlinerImpl {
+ struct BasicInlinerImpl {
BasicInlinerImpl(const BasicInlinerImpl&); // DO NOT IMPLEMENT
void operator=(const BasicInlinerImpl&); // DO NO IMPLEMENT
STATISTIC(NumBroken, "Number of blocks inserted");
namespace {
- struct VISIBILITY_HIDDEN BreakCriticalEdges : public FunctionPass {
+ struct BreakCriticalEdges : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
BreakCriticalEdges() : FunctionPass(&ID) {}
namespace {
/// PruningFunctionCloner - This class is a private class used to implement
/// the CloneAndPruneFunctionInto method.
- struct VISIBILITY_HIDDEN PruningFunctionCloner {
+ struct PruningFunctionCloner {
Function *NewFunc;
const Function *OldFunc;
DenseMap<const Value*, Value*> &ValueMap;
cl::desc("Aggregate arguments to code-extracted functions"));
namespace {
- class VISIBILITY_HIDDEN CodeExtractor {
+ class CodeExtractor {
typedef std::vector<Value*> Values;
std::set<BasicBlock*> BlocksToExtract;
DominatorTree* DT;
STATISTIC(NumNested , "Number of nested loops split out");
namespace {
- struct VISIBILITY_HIDDEN LoopSimplify : public LoopPass {
+ struct LoopSimplify : public LoopPass {
static char ID; // Pass identification, replacement for typeid
LoopSimplify() : LoopPass(&ID) {}
namespace {
/// LowerAllocations - Turn free instructions into @free calls.
///
- class VISIBILITY_HIDDEN LowerAllocations : public BasicBlockPass {
+ class LowerAllocations : public BasicBlockPass {
Constant *FreeFunc; // Functions in the module we are processing
// Initialized by doInitialization
public:
cl::desc("Make the -lowerinvoke pass insert expensive, but correct, EH code"));
namespace {
- class VISIBILITY_HIDDEN LowerInvoke : public FunctionPass {
+ class LowerInvoke : public FunctionPass {
// Used for both models.
Constant *WriteFn;
Constant *AbortFn;
/// LowerSwitch Pass - Replace all SwitchInst instructions with chained branch
/// instructions. Note that this cannot be a BasicBlock pass because it
/// modifies the CFG!
- class VISIBILITY_HIDDEN LowerSwitch : public FunctionPass {
+ class LowerSwitch : public FunctionPass {
public:
static char ID; // Pass identification, replacement for typeid
LowerSwitch() : FunctionPass(&ID) {}
STATISTIC(NumPromoted, "Number of alloca's promoted");
namespace {
- struct VISIBILITY_HIDDEN PromotePass : public FunctionPass {
+ struct PromotePass : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
PromotePass() : FunctionPass(&ID) {}
struct AllocaInfo;
// Data package used by RenamePass()
- class VISIBILITY_HIDDEN RenamePassData {
+ class RenamePassData {
public:
typedef std::vector<Value *> ValVector;
///
/// This functionality is important because it avoids scanning large basic
/// blocks multiple times when promoting many allocas in the same block.
- class VISIBILITY_HIDDEN LargeBlockInfo {
+ class LargeBlockInfo {
/// InstNumbers - For each instruction that we track, keep the index of the
/// instruction. The index starts out as the number of the instruction from
/// the start of the block.
}
};
- struct VISIBILITY_HIDDEN PromoteMem2Reg {
+ struct PromoteMem2Reg {
/// Allocas - The alloca instructions being promoted.
///
std::vector<AllocaInst*> Allocas;
/// SSIEverything - A pass that runs createSSI on every non-void variable,
/// intended for debugging.
namespace {
- struct VISIBILITY_HIDDEN SSIEverything : public FunctionPass {
+ struct SSIEverything : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
SSIEverything() : FunctionPass(&ID) {}
/// BBPassManager manages BasicBlockPass. It batches all the
/// pass together and sequence them to process one basic block before
/// processing next basic block.
-class VISIBILITY_HIDDEN BBPassManager : public PMDataManager,
- public FunctionPass {
+class BBPassManager : public PMDataManager, public FunctionPass {
public:
static char ID;
static ManagedStatic<sys::SmartMutex<true> > TimingInfoMutex;
-class VISIBILITY_HIDDEN TimingInfo {
+class TimingInfo {
std::map<Pass*, Timer> TimingData;
TimerGroup TG;
namespace {
- class VISIBILITY_HIDDEN PrintModulePass : public ModulePass {
+ class PrintModulePass : public ModulePass {
raw_ostream *Out; // raw_ostream to print on
bool DeleteStream; // Delete the ostream in our dtor?
public:
using namespace llvm;
namespace { // Anonymous namespace for class
- struct VISIBILITY_HIDDEN PreVerifier : public FunctionPass {
+ struct PreVerifier : public FunctionPass {
static char ID; // Pass ID, replacement for typeid
PreVerifier() : FunctionPass(&ID) { }
projects / oota-llvm.git / commitdiff