#include "llvm/Pass.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/Support/Visibility.h"
#include <algorithm>
using namespace llvm;
/// 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 NoAA : public ImmutablePass, public AliasAnalysis {
+ struct VISIBILITY_HIDDEN NoAA : public ImmutablePass, public AliasAnalysis {
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<TargetData>();
}
/// 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 BasicAliasAnalysis : public NoAA {
+ struct VISIBILITY_HIDDEN BasicAliasAnalysis : public NoAA {
AliasResult alias(const Value *V1, unsigned V1Size,
const Value *V2, unsigned V2Size);
#include "llvm/Assembly/Writer.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ConstantRange.h"
#include "llvm/Support/InstIterator.h"
-#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Visibility.h"
#include "llvm/ADT/Statistic.h"
#include <cmath>
#include <iostream>
/// SCEVComplexityCompare - Return true if the complexity of the LHS is less
/// than the complexity of the RHS. This comparator is used to canonicalize
/// expressions.
- struct SCEVComplexityCompare {
+ struct VISIBILITY_HIDDEN SCEVComplexityCompare {
bool operator()(SCEV *LHS, SCEV *RHS) {
return LHS->getSCEVType() < RHS->getSCEVType();
}
/// evolution code.
///
namespace {
- struct ScalarEvolutionsImpl {
+ struct VISIBILITY_HIDDEN ScalarEvolutionsImpl {
/// F - The function we are analyzing.
///
Function &F;
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Statistic.h"
+#include "llvm/Support/Visibility.h"
#include <set>
#include <algorithm>
using namespace llvm;
Statistic<> NumAtomic("phielim", "Number of atomic phis lowered");
Statistic<> NumSimple("phielim", "Number of simple phis lowered");
- struct PNE : public MachineFunctionPass {
+ struct VISIBILITY_HIDDEN PNE : public MachineFunctionPass {
bool runOnMachineFunction(MachineFunction &Fn) {
bool Changed = false;
#include "llvm/Target/TargetMachine.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
+#include "llvm/Support/Visibility.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/Statistic.h"
#include <algorithm>
Statistic<> NumLoads ("ra-local", "Number of loads added");
Statistic<> NumFolded("ra-local", "Number of loads/stores folded into "
"instructions");
- class RA : public MachineFunctionPass {
+ class VISIBILITY_HIDDEN RA : public MachineFunctionPass {
const TargetMachine *TM;
MachineFunction *MF;
const MRegisterInfo *RegInfo;
namespace {
template<class SF>
- class RegReductionPriorityQueue : public SchedulingPriorityQueue {
+ class VISIBILITY_HIDDEN RegReductionPriorityQueue
+ : public SchedulingPriorityQueue {
std::priority_queue<SUnit*, std::vector<SUnit*>, SF> Queue;
public:
};
template<class SF>
- class BURegReductionPriorityQueue : public RegReductionPriorityQueue<SF> {
+ class VISIBILITY_HIDDEN BURegReductionPriorityQueue
+ : public RegReductionPriorityQueue<SF> {
// SUnits - The SUnits for the current graph.
const std::vector<SUnit> *SUnits;
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/Debug.h"
+#include "llvm/Support/Visibility.h"
#include <map>
#include <set>
#include <iostream>
/// particular value is assigned and the type information about the value.
/// This is needed because values can be promoted into larger registers and
/// expanded into multiple smaller registers than the value.
- struct RegsForValue {
+ struct VISIBILITY_HIDDEN RegsForValue {
/// Regs - This list hold the register (for legal and promoted values)
/// or register set (for expanded values) that the value should be assigned
/// to.
#include "llvm/Pass.h"
#include "llvm/Type.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Visibility.h"
#include "llvm/ADT/DepthFirstIterator.h"
using namespace llvm;
namespace {
- class UnreachableBlockElim : public FunctionPass {
+ class VISIBILITY_HIDDEN UnreachableBlockElim : public FunctionPass {
virtual bool runOnFunction(Function &F);
};
RegisterOpt<UnreachableBlockElim>
/// DarwinDwarfWriter - Dwarf debug info writer customized for Darwin/Mac OS X
///
- struct DarwinDwarfWriter : public DwarfWriter {
+ struct VISIBILITY_HIDDEN DarwinDwarfWriter : public DwarfWriter {
// Ctor.
DarwinDwarfWriter(std::ostream &o, AsmPrinter *ap)
: DwarfWriter(o, ap)
/// DarwinAsmPrinter - PowerPC assembly printer, customized for Darwin/Mac OS
/// X
- struct DarwinAsmPrinter : public PPCAsmPrinter {
+ struct VISIBILITY_HIDDEN DarwinAsmPrinter : public PPCAsmPrinter {
DarwinDwarfWriter DW;
/// AIXAsmPrinter - PowerPC assembly printer, customized for AIX
///
- struct AIXAsmPrinter : public PPCAsmPrinter {
+ struct VISIBILITY_HIDDEN AIXAsmPrinter : public PPCAsmPrinter {
/// Map for labels corresponding to global variables
///
std::map<const GlobalVariable*,std::string> GVToLabelMap;
#include "PPCInstrBuilder.h"
#include "PPCInstrInfo.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/Support/Visibility.h"
#include <map>
using namespace llvm;
namespace {
- struct PPCBSel : public MachineFunctionPass {
+ struct VISIBILITY_HIDDEN PPCBSel : public MachineFunctionPass {
// OffsetMap - Mapping between BB and byte offset from start of function
std::map<MachineBasicBlock*, unsigned> OffsetMap;
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/Passes.h"
#include "llvm/Support/Debug.h"
+#include "llvm/Support/Visibility.h"
#include "llvm/Target/TargetOptions.h"
#include <iostream>
using namespace llvm;
namespace {
- class PPCCodeEmitter : public MachineFunctionPass {
+ class VISIBILITY_HIDDEN PPCCodeEmitter : public MachineFunctionPass {
TargetMachine &TM;
MachineCodeEmitter &MCE;
#include "llvm/Target/TargetData.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Support/Debug.h"
+#include "llvm/Support/Visibility.h"
#include "llvm/Target/TargetLowering.h"
#include <algorithm>
#include <iostream>
}
};
- class LoopStrengthReduce : public FunctionPass {
+ class VISIBILITY_HIDDEN LoopStrengthReduce : public FunctionPass {
LoopInfo *LI;
ETForest *EF;
ScalarEvolution *SE;
#include "llvm/Analysis/Dominators.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Transforms/Utils/PromoteMemToReg.h"
+#include "llvm/Support/Debug.h"
#include "llvm/Support/GetElementPtrTypeIterator.h"
#include "llvm/Support/MathExtras.h"
-#include "llvm/Support/Debug.h"
+#include "llvm/Support/Visibility.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringExtras.h"
#include <iostream>
Statistic<> NumConverted("scalarrepl",
"Number of aggregates converted to scalar");
- struct SROA : public FunctionPass {
+ struct VISIBILITY_HIDDEN SROA : public FunctionPass {
bool runOnFunction(Function &F);
bool performScalarRepl(Function &F);
#include "llvm/Instructions.h"
#include "llvm/Type.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Visibility.h"
#include "llvm/ADT/Statistic.h"
using namespace llvm;
namespace {
Statistic<> NumBroken("break-crit-edges", "Number of blocks inserted");
- struct BreakCriticalEdges : public FunctionPass {
+ struct VISIBILITY_HIDDEN BreakCriticalEdges : public FunctionPass {
virtual bool runOnFunction(Function &F);
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
#include "llvm/Analysis/Dominators.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Visibility.h"
#include "llvm/ADT/SetOperations.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/Statistic.h"
Statistic<>
NumNested("loopsimplify", "Number of nested loops split out");
- struct LoopSimplify : public FunctionPass {
+ struct VISIBILITY_HIDDEN LoopSimplify : public FunctionPass {
// AA - If we have an alias analysis object to update, this is it, otherwise
// this is null.
AliasAnalysis *AA;
#include "llvm/Pass.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Target/TargetData.h"
+#include "llvm/Support/Visibility.h"
using namespace llvm;
namespace {
/// LowerAllocations - Turn malloc and free instructions into %malloc and
/// %free calls.
///
- class LowerAllocations : public BasicBlockPass {
+ class VISIBILITY_HIDDEN LowerAllocations : public BasicBlockPass {
Function *MallocFunc; // Functions in the module we are processing
Function *FreeFunc; // Initialized by doInitialization
bool LowerMallocArgToInteger;
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/CFG.h"
#include "llvm/Support/StableBasicBlockNumbering.h"
+#include "llvm/Support/Visibility.h"
#include <algorithm>
using namespace llvm;
}
namespace {
- struct PromoteMem2Reg {
+ struct VISIBILITY_HIDDEN PromoteMem2Reg {
/// Allocas - The alloca instructions being promoted.
///
std::vector<AllocaInst*> Allocas;