RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-22 18:54:02 +01:00
Code Issues Projects Releases Wiki Activity

Revert r262185, "[PM] Appease mingw32's auto-import DLL build with minimal tweaks."

Browse Source 
I'll rework soon.

llvm-svn: 262186
This commit is contained in:
NAKAMURA Takumi 2016-02-28 16:54:06 +00:00
parent 56eaf56c6e
commit e7de739142
28 changed files with 0 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/Analysis/AliasAnalysis.h
View File

@ -1024,8 +1024,6 @@ private:
} }
}; };
extern template class AnalysisBase<AAManager>;
/// A wrapper pass to provide the legacy pass manager access to a suitably /// A wrapper pass to provide the legacy pass manager access to a suitably
/// prepared AAResults object. /// prepared AAResults object.
class AAResultsWrapperPass : public FunctionPass { class AAResultsWrapperPass : public FunctionPass {

2
include/llvm/Analysis/AssumptionCache.h
View File

@ -105,8 +105,6 @@ struct AssumptionAnalysis : AnalysisBase<AssumptionAnalysis> {
AssumptionCache run(Function &F) { return AssumptionCache(F); } AssumptionCache run(Function &F) { return AssumptionCache(F); }
}; };
extern template class AnalysisBase<AssumptionAnalysis>;
/// \brief Printer pass for the \c AssumptionAnalysis results. /// \brief Printer pass for the \c AssumptionAnalysis results.
class AssumptionPrinterPass : public PassBase<AssumptionPrinterPass> { class AssumptionPrinterPass : public PassBase<AssumptionPrinterPass> {
raw_ostream &OS; raw_ostream &OS;

6
include/llvm/Analysis/CGSCCPassManager.h
View File

@ -48,16 +48,12 @@ extern template class InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>;
typedef InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module> typedef InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>
CGSCCAnalysisManagerModuleProxy; CGSCCAnalysisManagerModuleProxy;
extern template class AnalysisBase<CGSCCAnalysisManagerModuleProxy>;
extern template class OuterAnalysisManagerProxy<ModuleAnalysisManager, extern template class OuterAnalysisManagerProxy<ModuleAnalysisManager,
LazyCallGraph::SCC>; LazyCallGraph::SCC>;
/// A proxy from a \c ModuleAnalysisManager to an \c SCC. /// A proxy from a \c ModuleAnalysisManager to an \c SCC.
typedef OuterAnalysisManagerProxy<ModuleAnalysisManager, LazyCallGraph::SCC> typedef OuterAnalysisManagerProxy<ModuleAnalysisManager, LazyCallGraph::SCC>
ModuleAnalysisManagerCGSCCProxy; ModuleAnalysisManagerCGSCCProxy;
extern template class AnalysisBase<ModuleAnalysisManagerCGSCCProxy>;
/// \brief The core module pass which does a post-order walk of the SCCs and /// \brief The core module pass which does a post-order walk of the SCCs and
/// runs a CGSCC pass over each one. /// runs a CGSCC pass over each one.
/// ///
@ -148,8 +144,6 @@ extern template class InnerAnalysisManagerProxy<FunctionAnalysisManager,
typedef InnerAnalysisManagerProxy<FunctionAnalysisManager, LazyCallGraph::SCC> typedef InnerAnalysisManagerProxy<FunctionAnalysisManager, LazyCallGraph::SCC>
FunctionAnalysisManagerCGSCCProxy; FunctionAnalysisManagerCGSCCProxy;
extern template class AnalysisBase<FunctionAnalysisManagerCGSCCProxy>;
extern template class OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>; extern template class OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>;
/// A proxy from a \c CGSCCAnalysisManager to a \c Function. /// A proxy from a \c CGSCCAnalysisManager to a \c Function.
typedef OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function> typedef OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>

2
include/llvm/Analysis/DominanceFrontier.h
View File

@ -176,8 +176,6 @@ struct DominanceFrontierAnalysis : AnalysisBase<DominanceFrontierAnalysis> {
DominanceFrontier run(Function &F, AnalysisManager<Function> *AM); DominanceFrontier run(Function &F, AnalysisManager<Function> *AM);
}; };
extern template class AnalysisBase<DominanceFrontierAnalysis>;
/// \brief Printer pass for the \c DominanceFrontier. /// \brief Printer pass for the \c DominanceFrontier.
class DominanceFrontierPrinterPass class DominanceFrontierPrinterPass
: public PassBase<DominanceFrontierPrinterPass> { : public PassBase<DominanceFrontierPrinterPass> {

2
include/llvm/Analysis/LazyCallGraph.h
View File

@ -906,8 +906,6 @@ struct LazyCallGraphAnalysis : AnalysisBase<LazyCallGraphAnalysis> {
LazyCallGraph run(Module &M) { return LazyCallGraph(M); } LazyCallGraph run(Module &M) { return LazyCallGraph(M); }
}; };
extern template class AnalysisBase<LazyCallGraphAnalysis>;
/// A pass which prints the call graph to a \c raw_ostream. /// A pass which prints the call graph to a \c raw_ostream.
/// ///
/// This is primarily useful for testing the analysis. /// This is primarily useful for testing the analysis.

2
include/llvm/Analysis/LoopInfo.h
View File

@ -793,8 +793,6 @@ struct LoopAnalysis : AnalysisBase<LoopAnalysis> {
LoopInfo run(Function &F, AnalysisManager<Function> *AM); LoopInfo run(Function &F, AnalysisManager<Function> *AM);
}; };
extern template class AnalysisBase<LoopAnalysis>;
/// \brief Printer pass for the \c LoopAnalysis results. /// \brief Printer pass for the \c LoopAnalysis results.
class LoopPrinterPass : public PassBase<LoopPrinterPass> { class LoopPrinterPass : public PassBase<LoopPrinterPass> {
raw_ostream &OS; raw_ostream &OS;

2
include/llvm/Analysis/LoopPassManager.h
View File

@ -43,8 +43,6 @@ extern template class InnerAnalysisManagerProxy<LoopAnalysisManager, Function>;
typedef InnerAnalysisManagerProxy<LoopAnalysisManager, Function> typedef InnerAnalysisManagerProxy<LoopAnalysisManager, Function>
LoopAnalysisManagerFunctionProxy; LoopAnalysisManagerFunctionProxy;
extern template class AnalysisBase<LoopAnalysisManagerFunctionProxy>;
extern template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop>; extern template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop>;
/// A proxy from a \c FunctionAnalysisManager to a \c Loop. /// A proxy from a \c FunctionAnalysisManager to a \c Loop.
typedef OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop> typedef OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop>

2
include/llvm/Analysis/PostDominators.h
View File

@ -46,8 +46,6 @@ struct PostDominatorTreeAnalysis : AnalysisBase<PostDominatorTreeAnalysis> {
PostDominatorTree run(Function &F); PostDominatorTree run(Function &F);
}; };
extern template class AnalysisBase<PostDominatorTreeAnalysis>;
/// \brief Printer pass for the \c PostDominatorTree. /// \brief Printer pass for the \c PostDominatorTree.
class PostDominatorTreePrinterPass class PostDominatorTreePrinterPass
: public PassBase<PostDominatorTreePrinterPass> { : public PassBase<PostDominatorTreePrinterPass> {

2
include/llvm/Analysis/RegionInfo.h
View File

@ -929,8 +929,6 @@ struct RegionInfoAnalysis : AnalysisBase<RegionInfoAnalysis> {
RegionInfo run(Function &F, AnalysisManager<Function> *AM); RegionInfo run(Function &F, AnalysisManager<Function> *AM);
}; };
extern template class AnalysisBase<RegionInfoAnalysis>;
/// \brief Printer pass for the \c RegionInfo. /// \brief Printer pass for the \c RegionInfo.
class RegionInfoPrinterPass : public PassBase<RegionInfoPrinterPass> { class RegionInfoPrinterPass : public PassBase<RegionInfoPrinterPass> {
raw_ostream &OS; raw_ostream &OS;

2
include/llvm/Analysis/ScalarEvolution.h
View File

@ -1421,8 +1421,6 @@ namespace llvm {
ScalarEvolution run(Function &F, AnalysisManager<Function> *AM); ScalarEvolution run(Function &F, AnalysisManager<Function> *AM);
}; };
extern template class AnalysisBase<ScalarEvolutionAnalysis>;
/// \brief Printer pass for the \c ScalarEvolutionAnalysis results. /// \brief Printer pass for the \c ScalarEvolutionAnalysis results.
class ScalarEvolutionPrinterPass class ScalarEvolutionPrinterPass
: public PassBase<ScalarEvolutionPrinterPass> { : public PassBase<ScalarEvolutionPrinterPass> {

2
include/llvm/Analysis/TargetLibraryInfo.h
View File

@ -299,8 +299,6 @@ private:
TargetLibraryInfoImpl &lookupInfoImpl(Triple T); TargetLibraryInfoImpl &lookupInfoImpl(Triple T);
}; };
extern template class AnalysisBase<TargetLibraryAnalysis>;
class TargetLibraryInfoWrapperPass : public ImmutablePass { class TargetLibraryInfoWrapperPass : public ImmutablePass {
TargetLibraryInfoImpl TLIImpl; TargetLibraryInfoImpl TLIImpl;
TargetLibraryInfo TLI; TargetLibraryInfo TLI;

2
include/llvm/Analysis/TargetTransformInfo.h
View File

@ -938,8 +938,6 @@ private:
static Result getDefaultTTI(const Function &F); static Result getDefaultTTI(const Function &F);
}; };
extern template class AnalysisBase<TargetIRAnalysis>;
/// \brief Wrapper pass for TargetTransformInfo. /// \brief Wrapper pass for TargetTransformInfo.
/// ///
/// This pass can be constructed from a TTI object which it stores internally /// This pass can be constructed from a TTI object which it stores internally

2
include/llvm/IR/Dominators.h
View File

@ -190,8 +190,6 @@ struct DominatorTreeAnalysis : AnalysisBase<DominatorTreeAnalysis> {
DominatorTree run(Function &F); DominatorTree run(Function &F);
}; };
extern template class AnalysisBase<DominatorTreeAnalysis>;
/// \brief Printer pass for the \c DominatorTree. /// \brief Printer pass for the \c DominatorTree.
class DominatorTreePrinterPass : public PassBase<DominatorTreePrinterPass> { class DominatorTreePrinterPass : public PassBase<DominatorTreePrinterPass> {
raw_ostream &OS; raw_ostream &OS;

2
include/llvm/IR/PassManager.h
View File

@ -749,8 +749,6 @@ extern template class InnerAnalysisManagerProxy<FunctionAnalysisManager,
typedef InnerAnalysisManagerProxy<FunctionAnalysisManager, Module> typedef InnerAnalysisManagerProxy<FunctionAnalysisManager, Module>
FunctionAnalysisManagerModuleProxy; FunctionAnalysisManagerModuleProxy;
extern template class AnalysisBase<FunctionAnalysisManagerModuleProxy>;
/// \brief A function analysis which acts as a proxy for a module analysis /// \brief A function analysis which acts as a proxy for a module analysis
/// manager. /// manager.
/// ///

3
lib/Analysis/AliasAnalysis.cpp
View File

@ -390,9 +390,6 @@ bool AAResults::canInstructionRangeModRef(const Instruction &I1,
// Provide a definition for the root virtual destructor. // Provide a definition for the root virtual destructor.
AAResults::Concept::~Concept() {} AAResults::Concept::~Concept() {}
// Provide a definition for the static object used to identify passes.
template class AnalysisBase<AAManager>;
namespace { namespace {
/// A wrapper pass for external alias analyses. This just squirrels away the /// A wrapper pass for external alias analyses. This just squirrels away the
/// callback used to run any analyses and register their results. /// callback used to run any analyses and register their results.

2
lib/Analysis/AssumptionCache.cpp
View File

@ -74,8 +74,6 @@ void AssumptionCache::registerAssumption(CallInst *CI) {
#endif #endif
} }
template class AnalysisBase<AssumptionAnalysis>;
PreservedAnalyses AssumptionPrinterPass::run(Function &F, PreservedAnalyses AssumptionPrinterPass::run(Function &F,
AnalysisManager<Function> *AM) { AnalysisManager<Function> *AM) {
AssumptionCache &AC = AM->getResult<AssumptionAnalysis>(F); AssumptionCache &AC = AM->getResult<AssumptionAnalysis>(F);

3
lib/Analysis/CGSCCPassManager.cpp
View File

@ -18,12 +18,9 @@ namespace llvm {
template class PassManager<LazyCallGraph::SCC>; template class PassManager<LazyCallGraph::SCC>;
template class AnalysisManager<LazyCallGraph::SCC>; template class AnalysisManager<LazyCallGraph::SCC>;
template class InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>; template class InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>;
template class AnalysisBase<CGSCCAnalysisManagerModuleProxy>;
template class OuterAnalysisManagerProxy<ModuleAnalysisManager, template class OuterAnalysisManagerProxy<ModuleAnalysisManager,
LazyCallGraph::SCC>; LazyCallGraph::SCC>;
template class AnalysisBase<ModuleAnalysisManagerCGSCCProxy>;
template class InnerAnalysisManagerProxy<FunctionAnalysisManager, template class InnerAnalysisManagerProxy<FunctionAnalysisManager,
LazyCallGraph::SCC>; LazyCallGraph::SCC>;
template class AnalysisBase<FunctionAnalysisManagerCGSCCProxy>;
template class OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>; template class OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>;
} }

2
lib/Analysis/DominanceFrontier.cpp
View File

@ -56,8 +56,6 @@ LLVM_DUMP_METHOD void DominanceFrontierWrapperPass::dump() const {
} }
#endif #endif
template class AnalysisBase<DominanceFrontierAnalysis>;
DominanceFrontier DominanceFrontierAnalysis::run(Function &F, DominanceFrontier DominanceFrontierAnalysis::run(Function &F,
FunctionAnalysisManager *AM) { FunctionAnalysisManager *AM) {
DominanceFrontier DF; DominanceFrontier DF;

2
lib/Analysis/LazyCallGraph.cpp
View File

@ -1499,8 +1499,6 @@ LazyCallGraph::RefSCC *LazyCallGraph::getNextRefSCCInPostOrder() {
} }
} }
template class AnalysisBase<LazyCallGraphAnalysis>;
LazyCallGraphPrinterPass::LazyCallGraphPrinterPass(raw_ostream &OS) : OS(OS) {} LazyCallGraphPrinterPass::LazyCallGraphPrinterPass(raw_ostream &OS) : OS(OS) {}
static void printNode(raw_ostream &OS, LazyCallGraph::Node &N) { static void printNode(raw_ostream &OS, LazyCallGraph::Node &N) {

2
lib/Analysis/LoopInfo.cpp
View File

@ -641,8 +641,6 @@ void LoopInfo::markAsRemoved(Loop *Unloop) {
} }
} }
template class AnalysisBase<LoopAnalysis>;
LoopInfo LoopAnalysis::run(Function &F, AnalysisManager<Function> *AM) { LoopInfo LoopAnalysis::run(Function &F, AnalysisManager<Function> *AM) {
// FIXME: Currently we create a LoopInfo from scratch for every function. // FIXME: Currently we create a LoopInfo from scratch for every function.
// This may prove to be too wasteful due to deallocating and re-allocating // This may prove to be too wasteful due to deallocating and re-allocating

1
lib/Analysis/LoopPassManager.cpp
View File

@ -16,6 +16,5 @@ namespace llvm {
template class PassManager<Loop>; template class PassManager<Loop>;
template class AnalysisManager<Loop>; template class AnalysisManager<Loop>;
template class InnerAnalysisManagerProxy<LoopAnalysisManager, Function>; template class InnerAnalysisManagerProxy<LoopAnalysisManager, Function>;
template class AnalysisBase<LoopAnalysisManagerFunctionProxy>;
template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop>; template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop>;
} }

2
lib/Analysis/PostDominators.cpp
View File

@ -44,8 +44,6 @@ FunctionPass* llvm::createPostDomTree() {
return new PostDominatorTreeWrapperPass(); return new PostDominatorTreeWrapperPass();
} }
template class AnalysisBase<PostDominatorTreeAnalysis>;
PostDominatorTree PostDominatorTreeAnalysis::run(Function &F) { PostDominatorTree PostDominatorTreeAnalysis::run(Function &F) {
PostDominatorTree PDT; PostDominatorTree PDT;
PDT.recalculate(F); PDT.recalculate(F);

2
lib/Analysis/RegionInfo.cpp
View File

@ -185,8 +185,6 @@ namespace llvm {
// RegionInfoAnalysis implementation // RegionInfoAnalysis implementation
// //
template class AnalysisBase<RegionInfoAnalysis>;
RegionInfo RegionInfoAnalysis::run(Function &F, AnalysisManager<Function> *AM) { RegionInfo RegionInfoAnalysis::run(Function &F, AnalysisManager<Function> *AM) {
RegionInfo RI; RegionInfo RI;
auto *DT = &AM->getResult<DominatorTreeAnalysis>(F); auto *DT = &AM->getResult<DominatorTreeAnalysis>(F);

2
lib/Analysis/ScalarEvolution.cpp
View File

@ -9554,8 +9554,6 @@ void ScalarEvolution::verify() const {
// TODO: Verify more things. // TODO: Verify more things.
} }
template class AnalysisBase<ScalarEvolutionAnalysis>;
ScalarEvolution ScalarEvolutionAnalysis::run(Function &F, ScalarEvolution ScalarEvolutionAnalysis::run(Function &F,
AnalysisManager<Function> *AM) { AnalysisManager<Function> *AM) {
return ScalarEvolution(F, AM->getResult<TargetLibraryAnalysis>(F), return ScalarEvolution(F, AM->getResult<TargetLibraryAnalysis>(F),

2
lib/Analysis/TargetLibraryInfo.cpp
View File

@ -636,8 +636,6 @@ TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass(
initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry()); initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
} }
template class AnalysisBase<TargetLibraryAnalysis>;
// Register the basic pass. // Register the basic pass.
INITIALIZE_PASS(TargetLibraryInfoWrapperPass, "targetlibinfo", INITIALIZE_PASS(TargetLibraryInfoWrapperPass, "targetlibinfo",
"Target Library Information", false, true) "Target Library Information", false, true)

2
lib/Analysis/TargetTransformInfo.cpp
View File

@ -377,8 +377,6 @@ TargetIRAnalysis::Result TargetIRAnalysis::run(const Function &F) {
return TTICallback(F); return TTICallback(F);
} }
template class AnalysisBase<TargetIRAnalysis>;
TargetIRAnalysis::Result TargetIRAnalysis::getDefaultTTI(const Function &F) { TargetIRAnalysis::Result TargetIRAnalysis::getDefaultTTI(const Function &F) {
return Result(F.getParent()->getDataLayout()); return Result(F.getParent()->getDataLayout());
} }

2
lib/IR/Dominators.cpp
View File

@ -308,8 +308,6 @@ DominatorTree DominatorTreeAnalysis::run(Function &F) {
return DT; return DT;
} }
template class AnalysisBase<DominatorTreeAnalysis>;
DominatorTreePrinterPass::DominatorTreePrinterPass(raw_ostream &OS) : OS(OS) {} DominatorTreePrinterPass::DominatorTreePrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses DominatorTreePrinterPass::run(Function &F, PreservedAnalyses DominatorTreePrinterPass::run(Function &F,

1
lib/IR/PassManager.cpp
View File

@ -20,6 +20,5 @@ template class PassManager<Function>;
template class AnalysisManager<Module>; template class AnalysisManager<Module>;
template class AnalysisManager<Function>; template class AnalysisManager<Function>;
template class InnerAnalysisManagerProxy<FunctionAnalysisManager, Module>; template class InnerAnalysisManagerProxy<FunctionAnalysisManager, Module>;
template class AnalysisBase<FunctionAnalysisManagerModuleProxy>;
template class OuterAnalysisManagerProxy<ModuleAnalysisManager, Function>; template class OuterAnalysisManagerProxy<ModuleAnalysisManager, Function>;
} }