6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-27 13:30:05 +00:00
Code Issues Projects Releases Wiki Activity

Move the old pass manager infrastructure into a legacy namespace and

Browse Source 
give the files a legacy prefix in the right directory. Use forwarding
headers in the old locations to paper over the name change for most
clients during the transitional period.

No functionality changed here! This is just clearing some space to
reduce renaming churn later on with a new system.

Even when the new stuff starts to go in, it is going to be hidden behind
a flag and off-by-default as it is still WIP and under development.

This patch is specifically designed so that very little out-of-tree code
has to change. I'm going to work as hard as I can to keep that the case.
Only direct forward declarations of the PassManager class are impacted
by this change.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@194324 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chandler Carruth 2013-11-09 12:26:54 +00:00
parent 9defe9a7cc
commit 49837ef811
13 changed files with 185 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -16,8 +16,8 @@
#define LLVM_ANALYSIS_LOOPPASS_H
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/IR/LegacyPassManagers.h"
#include "llvm/Pass.h"
#include "llvm/PassManagers.h"
#include <deque>
namespace llvm {

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

@ -18,8 +18,8 @@
#include "llvm/Analysis/RegionInfo.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/LegacyPassManagers.h"
#include "llvm/Pass.h"
#include "llvm/PassManagers.h"
#include <deque>
namespace llvm {

7
include/llvm/CodeGen/Passes.h
View File

@ -25,7 +25,6 @@ class FunctionPass;
class MachineFunctionPass;
class PassConfigImpl;
class PassInfo;
class PassManagerBase;
class ScheduleDAGInstrs;
class TargetLowering;
class TargetLoweringBase;
@ -33,6 +32,12 @@ class TargetRegisterClass;
class raw_ostream;
struct MachineSchedContext;
// The old pass manager infrastructure is hidden in a legacy namespace now.
namespace legacy {
class PassManagerBase;
}
using legacy::PassManagerBase;
/// Discriminated union of Pass ID types.
///
/// The PassConfig API prefers dealing with IDs because they are safer and more

111
include/llvm/IR/LegacyPassManager.h Normal file
View File

@ -0,0 +1,111 @@
//===- LegacyPassManager.h - Legacy Container for Passes --------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the legacy PassManager class. This class is used to hold,
// maintain, and optimize execution of Passes. The PassManager class ensures
// that analysis results are available before a pass runs, and that Pass's are
// destroyed when the PassManager is destroyed.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_IR_LEGACYPASSMANAGER_H
#define LLVM_IR_LEGACYPASSMANAGER_H
#include "llvm/Pass.h"
#include "llvm/Support/CBindingWrapping.h"
namespace llvm {
class Pass;
class Module;
namespace legacy {
class PassManagerImpl;
class FunctionPassManagerImpl;
/// PassManagerBase - An abstract interface to allow code to add passes to
/// a pass manager without having to hard-code what kind of pass manager
/// it is.
class PassManagerBase {
public:
virtual ~PassManagerBase();
/// add - Add a pass to the queue of passes to run. This passes ownership of
/// the Pass to the PassManager. When the PassManager is destroyed, the pass
/// will be destroyed as well, so there is no need to delete the pass. This
/// implies that all passes MUST be allocated with 'new'.
virtual void add(Pass *P) = 0;
};
/// PassManager manages ModulePassManagers
class PassManager : public PassManagerBase {
public:
PassManager();
~PassManager();
/// add - Add a pass to the queue of passes to run. This passes ownership of
/// the Pass to the PassManager. When the PassManager is destroyed, the pass
/// will be destroyed as well, so there is no need to delete the pass. This
/// implies that all passes MUST be allocated with 'new'.
void add(Pass *P);
/// run - Execute all of the passes scheduled for execution. Keep track of
/// whether any of the passes modifies the module, and if so, return true.
bool run(Module &M);
private:
/// PassManagerImpl_New is the actual class. PassManager is just the
/// wraper to publish simple pass manager interface
PassManagerImpl *PM;
};
/// FunctionPassManager manages FunctionPasses and BasicBlockPassManagers.
class FunctionPassManager : public PassManagerBase {
public:
/// FunctionPassManager ctor - This initializes the pass manager. It needs,
/// but does not take ownership of, the specified Module.
explicit FunctionPassManager(Module *M);
~FunctionPassManager();
/// add - Add a pass to the queue of passes to run. This passes
/// ownership of the Pass to the PassManager. When the
/// PassManager_X is destroyed, the pass will be destroyed as well, so
/// there is no need to delete the pass.
/// This implies that all passes MUST be allocated with 'new'.
void add(Pass *P);
/// run - Execute all of the passes scheduled for execution. Keep
/// track of whether any of the passes modifies the function, and if
/// so, return true.
///
bool run(Function &F);
/// doInitialization - Run all of the initializers for the function passes.
///
bool doInitialization();
/// doFinalization - Run all of the finalizers for the function passes.
///
bool doFinalization();
private:
FunctionPassManagerImpl *FPM;
Module *M;
};
} // End legacy namespace
// Create wrappers for C Binding types (see CBindingWrapping.h).
DEFINE_STDCXX_CONVERSION_FUNCTIONS(legacy::PassManagerBase, LLVMPassManagerRef)
} // End llvm namespace
#endif

2
include/llvm/PassManagers.h → include/llvm/IR/LegacyPassManagers.h
View File

@ -1,4 +1,4 @@
//===- llvm/PassManagers.h - Pass Infrastructure classes -------*- C++ -*-===//
//===- LegacyPassManagers.h - Legacy Pass Infrastructure --------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//

104
include/llvm/PassManager.h
View File

@ -7,101 +7,33 @@
//
//===----------------------------------------------------------------------===//
//
// This file defines the PassManager class. This class is used to hold,
// maintain, and optimize execution of Passes. The PassManager class ensures
// that analysis results are available before a pass runs, and that Pass's are
// destroyed when the PassManager is destroyed.
// This is a legacy redirect header for the old PassManager. It is intended to
// be used by clients that have not been converted to be aware of the new pass
// management infrastructure being built for LLVM, which is every client
// initially. Eventually this header (and the legacy management layer) will go
// away, but we want to minimize changes to out-of-tree users of LLVM in the
// interim.
//
// Note that this header *must not* be included into the same file as the new
// pass management infrastructure is included. Things will break spectacularly.
// If you are starting that conversion, you should switch to explicitly
// including LegacyPassManager.h and using the legacy namespace.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_PASSMANAGER_H
#define LLVM_PASSMANAGER_H
#include "llvm/Pass.h"
#include "llvm/Support/CBindingWrapping.h"
#include "llvm/IR/LegacyPassManager.h"
namespace llvm {
class Pass;
class Module;
// Pull these into the llvm namespace so that existing code that expects it
// there can find it.
using legacy::PassManagerBase;
using legacy::PassManager;
using legacy::FunctionPassManager;
class PassManagerImpl;
class FunctionPassManagerImpl;
/// PassManagerBase - An abstract interface to allow code to add passes to
/// a pass manager without having to hard-code what kind of pass manager
/// it is.
class PassManagerBase {
public:
virtual ~PassManagerBase();
/// add - Add a pass to the queue of passes to run. This passes ownership of
/// the Pass to the PassManager. When the PassManager is destroyed, the pass
/// will be destroyed as well, so there is no need to delete the pass. This
/// implies that all passes MUST be allocated with 'new'.
virtual void add(Pass *P) = 0;
};
/// PassManager manages ModulePassManagers
class PassManager : public PassManagerBase {
public:
PassManager();
~PassManager();
/// add - Add a pass to the queue of passes to run. This passes ownership of
/// the Pass to the PassManager. When the PassManager is destroyed, the pass
/// will be destroyed as well, so there is no need to delete the pass. This
/// implies that all passes MUST be allocated with 'new'.
void add(Pass *P);
/// run - Execute all of the passes scheduled for execution. Keep track of
/// whether any of the passes modifies the module, and if so, return true.
bool run(Module &M);
private:
/// PassManagerImpl_New is the actual class. PassManager is just the
/// wraper to publish simple pass manager interface
PassManagerImpl *PM;
};
/// FunctionPassManager manages FunctionPasses and BasicBlockPassManagers.
class FunctionPassManager : public PassManagerBase {
public:
/// FunctionPassManager ctor - This initializes the pass manager. It needs,
/// but does not take ownership of, the specified Module.
explicit FunctionPassManager(Module *M);
~FunctionPassManager();
/// add - Add a pass to the queue of passes to run. This passes
/// ownership of the Pass to the PassManager. When the
/// PassManager_X is destroyed, the pass will be destroyed as well, so
/// there is no need to delete the pass.
/// This implies that all passes MUST be allocated with 'new'.
void add(Pass *P);
/// run - Execute all of the passes scheduled for execution. Keep
/// track of whether any of the passes modifies the function, and if
/// so, return true.
///
bool run(Function &F);
/// doInitialization - Run all of the initializers for the function passes.
///
bool doInitialization();
/// doFinalization - Run all of the finalizers for the function passes.
///
bool doFinalization();
private:
FunctionPassManagerImpl *FPM;
Module *M;
};
// Create wrappers for C Binding types (see CBindingWrapping.h).
DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef)
} // End llvm namespace
}
#endif

7
include/llvm/Target/TargetMachine.h
View File

@ -29,7 +29,6 @@ class GlobalValue;
class MCAsmInfo;
class MCCodeGenInfo;
class MCContext;
class PassManagerBase;
class Target;
class DataLayout;
class TargetLibraryInfo;
@ -47,6 +46,12 @@ class VectorTargetTransformInfo;
class formatted_raw_ostream;
class raw_ostream;
// The old pass manager infrastructure is hidden in a legacy namespace now.
namespace legacy {
class PassManagerBase;
}
using legacy::PassManagerBase;
//===----------------------------------------------------------------------===//
///
/// TargetMachine - Primary interface to the complete machine description for

14
include/llvm/Transforms/IPO/PassManagerBuilder.h
View File

@ -18,10 +18,16 @@
#include <vector>
namespace llvm {
class TargetLibraryInfo;
class PassManagerBase;
class Pass;
class FunctionPassManager;
class TargetLibraryInfo;
class Pass;
// The old pass manager infrastructure is hidden in a legacy namespace now.
namespace legacy {
class PassManagerBase;
class FunctionPassManager;
}
using legacy::PassManagerBase;
using legacy::FunctionPassManager;
/// PassManagerBuilder - This class is used to set up a standard optimization
/// sequence for languages like C and C++, allowing some APIs to customize the

2
lib/Analysis/IPA/CallGraphSCCPass.cpp
View File

@ -22,7 +22,7 @@
#include "llvm/Analysis/CallGraph.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/PassManagers.h"
#include "llvm/IR/LegacyPassManagers.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/Timer.h"

4
lib/IR/CMakeLists.txt
View File

@ -6,10 +6,10 @@ add_llvm_library(LLVMCore
ConstantFold.cpp
Constants.cpp
Core.cpp
DIBuilder.cpp
DataLayout.cpp
DebugInfo.cpp
DebugLoc.cpp
DIBuilder.cpp
Dominators.cpp
Function.cpp
GCOV.cpp
@ -23,10 +23,10 @@ add_llvm_library(LLVMCore
LLVMContext.cpp
LLVMContextImpl.cpp
LeakDetector.cpp
LegacyPassManager.cpp
Metadata.cpp
Module.cpp
Pass.cpp
PassManager.cpp
PassRegistry.cpp
PrintModulePass.cpp
Type.cpp

30
lib/IR/PassManager.cpp → lib/IR/LegacyPassManager.cpp
View File

@ -1,4 +1,4 @@
//===- PassManager.cpp - LLVM Pass Infrastructure Implementation ----------===//
//===- LegacyPassManager.cpp - LLVM Pass Infrastructure Implementation ----===//
//
// The LLVM Compiler Infrastructure
//
@ -7,16 +7,16 @@
//
//===----------------------------------------------------------------------===//
//
// This file implements the LLVM Pass Manager infrastructure.
// This file implements the legacy LLVM Pass Manager infrastructure.
//
//===----------------------------------------------------------------------===//
#include "llvm/PassManagers.h"
#include "llvm/Assembly/PrintModulePass.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/IR/LegacyPassManager.h"
#include "llvm/IR/Module.h"
#include "llvm/PassManager.h"
#include "llvm/IR/LegacyPassManagers.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
@ -28,11 +28,10 @@
#include <algorithm>
#include <map>
using namespace llvm;
using namespace llvm::legacy;
// See PassManagers.h for Pass Manager infrastructure overview.
namespace llvm {
//===----------------------------------------------------------------------===//
// Pass debugging information. Often it is useful to find out what pass is
// running when a crash occurs in a utility. When this library is compiled with
@ -40,10 +39,12 @@ namespace llvm {
// pass name to be printed before it executes.
//
namespace {
// Different debug levels that can be enabled...
enum PassDebugLevel {
Disabled, Arguments, Structure, Executions, Details
};
}
static cl::opt<enum PassDebugLevel>
PassDebugging("debug-pass", cl::Hidden,
@ -56,8 +57,10 @@ PassDebugging("debug-pass", cl::Hidden,
clEnumVal(Details , "print pass details when it is executed"),
clEnumValEnd));
namespace {
typedef llvm::cl::list<const llvm::PassInfo *, bool, PassNameParser>
PassOptionList;
}
// Print IR out before/after specified passes.
static PassOptionList
@ -106,8 +109,6 @@ static bool ShouldPrintAfterPass(const PassInfo *PI) {
return PrintAfterAll || ShouldPrintBeforeOrAfterPass(PI, PrintAfter);
}
} // End of llvm namespace
/// isPassDebuggingExecutionsOrMore - Return true if -debug-pass=Executions
/// or higher is specified.
bool PMDataManager::isPassDebuggingExecutionsOrMore() const {
@ -149,7 +150,6 @@ void PassManagerPrettyStackEntry::print(raw_ostream &OS) const {
namespace {
//===----------------------------------------------------------------------===//
// BBPassManager
//
@ -206,10 +206,10 @@ public:
};
char BBPassManager::ID = 0;
}
} // End anonymous namespace
namespace llvm {
namespace legacy {
//===----------------------------------------------------------------------===//
// FunctionPassManagerImpl
//
@ -277,7 +277,10 @@ public:
void FunctionPassManagerImpl::anchor() {}
char FunctionPassManagerImpl::ID = 0;
} // End of legacy namespace
} // End of llvm namespace
namespace {
//===----------------------------------------------------------------------===//
// MPPassManager
//
@ -372,6 +375,10 @@ public:
};
char MPPassManager::ID = 0;
} // End anonymous namespace
namespace llvm {
namespace legacy {
//===----------------------------------------------------------------------===//
// PassManagerImpl
//
@ -437,6 +444,7 @@ public:
void PassManagerImpl::anchor() {}
char PassManagerImpl::ID = 0;
} // End of legacy namespace
} // End of llvm namespace
namespace {

2
unittests/IR/CMakeLists.txt
View File

@ -10,9 +10,9 @@ set(IRSources
DominatorTreeTest.cpp
IRBuilderTest.cpp
InstructionsTest.cpp
LegacyPassManagerTest.cpp
MDBuilderTest.cpp
MetadataTest.cpp
PassManagerTest.cpp
PatternMatch.cpp
TypeBuilderTest.cpp
TypesTest.cpp

9
unittests/IR/PassManagerTest.cpp → unittests/IR/LegacyPassManagerTest.cpp
View File

@ -1,4 +1,4 @@
//===- llvm/unittest/IR/PassManager.cpp - PassManager unit tests ----------===//
//===- llvm/unittest/IR/LegacyPassManager.cpp - Legacy PassManager tests --===//
//
// The LLVM Compiler Infrastructure
//
@ -6,6 +6,13 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This unit test exercises the legacy pass manager infrastructure. We use the
// old names as well to ensure that the source-level compatibility wrapper
// works for out-of-tree code that expects to include llvm/PassManager.h and
// subclass the core pass classes.
//
//===----------------------------------------------------------------------===//
#include "llvm/PassManager.h"
#include "llvm/ADT/SmallVector.h"