This is an archive of the discontinued LLVM Phabricator instance.

Differential D9685

Fix #include cycle between Pass.h and PassSupport.h
AbandonedPublic

Authored by rsmith on May 11 2015, 3:50 PM.

Details

Reviewers
chandlerc
Summary

Pass.h #includes PassSupport.h and PassAnalysisSupport.h. Each of those #includes Pass.h. This makes the modules build unhappy when local submodule visibility is enabled.

The approach taken here is:

  • Move the definition of the Pass base class and related types to PassBase.h
  • Change the other two headers to include PassBase.h instead of Pass.h

This way including Pass.h gets the full Pass interface, and PassBase.h gets just the base Pass classes. One functional difference is that including PassSupport does *not* provide PassAnalysisSupport and vice versa. I'm doing a build right now to see if I need to add includes of those two anywhere as a result.

Diff Detail

Repository
rL LLVM

Event Timeline

rsmith updated this revision to Diff 25519.May 11 2015, 3:50 PM
rsmith retitled this revision from to Fix #include cycle between Pass.h and PassSupport.h.
rsmith updated this object.
rsmith edited the test plan for this revision. (Show Details)
rsmith added a reviewer: chandlerc.
rsmith set the repository for this revision to rL LLVM.
rsmith added a subscriber: Unknown Object (MLST).
chandlerc requested changes to this revision.May 11 2015, 4:16 PM
chandlerc edited edge metadata.
chandlerc added inline comments.
include/llvm/Pass.h
18

Can you sink this into llvm/IR/ and call it LegacyPass.h?

And sink the other files' actual content into llvm/IR/LegacyFoo.h files?

And then these will all be pure forwarding headers?

This revision now requires changes to proceed.May 11 2015, 4:16 PM
rsmith abandoned this revision.Jul 13 2015, 7:35 PM

Revision Contents

PathSize
include/
llvm/
366 lines
2 lines
16 lines
2 lines
1 line

Diff 25519

include/llvm/Pass.h

//===- llvm/Pass.h - Base class for Passes ----------------------*- C++ -*-===// //===- llvm/Pass.h - Pass support -------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
Context not available.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines a base class that indicates that a specified class is a // This file is a forwarding header to provide the Pass interface and related
// transformation pass implementation. // classes.
// //
// Passes are designed this way so that it is possible to run passes in a cache
// and organizationally optimal order without having to specify it at the front
// end. This allows arbitrary passes to be strung together and have them
// executed as efficiently as possible.
//
// Passes should extend one of the classes below, depending on the guarantees
// that it can make about what will be modified as it is run. For example, most
// global optimizations should derive from FunctionPass, because they do not add
// or delete functions, they operate on the internals of the function.
//
// Note that this file #includes PassSupport.h and PassAnalysisSupport.h (at the
// bottom), so the APIs exposed by these files are also automatically available
// to all users of this file.
//
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_PASS_H #ifndef LLVM_PASS_H
#define LLVM_PASS_H #define LLVM_PASS_H
#include "llvm/Support/Compiler.h" #include "llvm/PassBase.h"
chandlercUnsubmitted
Not Done
ReplyInline Actions

Can you sink this into llvm/IR/ and call it LegacyPass.h?

And sink the other files' actual content into llvm/IR/LegacyFoo.h files?

And then these will all be pure forwarding headers?

chandlerc: Can you sink this into llvm/IR/ and call it LegacyPass.h? And sink the other files' actual…
#include <string>
namespace llvm {
class BasicBlock;
class Function;
class Module;
class AnalysisUsage;
class PassInfo;
class ImmutablePass;
class PMStack;
class AnalysisResolver;
class PMDataManager;
class raw_ostream;
class StringRef;
// AnalysisID - Use the PassInfo to identify a pass...
typedef const void* AnalysisID;
/// Different types of internal pass managers. External pass managers
/// (PassManager and FunctionPassManager) are not represented here.
/// Ordering of pass manager types is important here.
enum PassManagerType {
PMT_Unknown = 0,
PMT_ModulePassManager = 1, ///< MPPassManager
PMT_CallGraphPassManager, ///< CGPassManager
PMT_FunctionPassManager, ///< FPPassManager
PMT_LoopPassManager, ///< LPPassManager
PMT_RegionPassManager, ///< RGPassManager
PMT_BasicBlockPassManager, ///< BBPassManager
PMT_Last
};
// Different types of passes.
enum PassKind {
PT_BasicBlock,
PT_Region,
PT_Loop,
PT_Function,
PT_CallGraphSCC,
PT_Module,
PT_PassManager
};
//===----------------------------------------------------------------------===//
/// Pass interface - Implemented by all 'passes'. Subclass this if you are an
/// interprocedural optimization or you do not fit into any of the more
/// constrained passes described below.
///
class Pass {
AnalysisResolver *Resolver; // Used to resolve analysis
const void *PassID;
PassKind Kind;
void operator=(const Pass&) = delete;
Pass(const Pass &) = delete;
public:
explicit Pass(PassKind K, char &pid)
: Resolver(nullptr), PassID(&pid), Kind(K) { }
virtual ~Pass();
PassKind getPassKind() const { return Kind; }
/// getPassName - Return a nice clean name for a pass. This usually
/// implemented in terms of the name that is registered by one of the
/// Registration templates, but can be overloaded directly.
///
virtual const char *getPassName() const;
/// getPassID - Return the PassID number that corresponds to this pass.
AnalysisID getPassID() const {
return PassID;
}
/// doInitialization - Virtual method overridden by subclasses to do
/// any necessary initialization before any pass is run.
///
virtual bool doInitialization(Module &) { return false; }
/// doFinalization - Virtual method overriden by subclasses to do any
/// necessary clean up after all passes have run.
///
virtual bool doFinalization(Module &) { return false; }
/// print - Print out the internal state of the pass. This is called by
/// Analyze to print out the contents of an analysis. Otherwise it is not
/// necessary to implement this method. Beware that the module pointer MAY be
/// null. This automatically forwards to a virtual function that does not
/// provide the Module* in case the analysis doesn't need it it can just be
/// ignored.
///
virtual void print(raw_ostream &O, const Module *M) const;
void dump() const; // dump - Print to stderr.
/// createPrinterPass - Get a Pass appropriate to print the IR this
/// pass operates on (Module, Function or MachineFunction).
virtual Pass *createPrinterPass(raw_ostream &O,
const std::string &Banner) const = 0;
/// Each pass is responsible for assigning a pass manager to itself.
/// PMS is the stack of available pass manager.
virtual void assignPassManager(PMStack &,
PassManagerType) {}
/// Check if available pass managers are suitable for this pass or not.
virtual void preparePassManager(PMStack &);
/// Return what kind of Pass Manager can manage this pass.
virtual PassManagerType getPotentialPassManagerType() const;
// Access AnalysisResolver
void setResolver(AnalysisResolver *AR);
AnalysisResolver *getResolver() const { return Resolver; }
/// getAnalysisUsage - This function should be overriden by passes that need
/// analysis information to do their job. If a pass specifies that it uses a
/// particular analysis result to this function, it can then use the
/// getAnalysis<AnalysisType>() function, below.
///
virtual void getAnalysisUsage(AnalysisUsage &) const;
/// releaseMemory() - This member can be implemented by a pass if it wants to
/// be able to release its memory when it is no longer needed. The default
/// behavior of passes is to hold onto memory for the entire duration of their
/// lifetime (which is the entire compile time). For pipelined passes, this
/// is not a big deal because that memory gets recycled every time the pass is
/// invoked on another program unit. For IP passes, it is more important to
/// free memory when it is unused.
///
/// Optionally implement this function to release pass memory when it is no
/// longer used.
///
virtual void releaseMemory();
/// getAdjustedAnalysisPointer - This method is used when a pass implements
/// an analysis interface through multiple inheritance. If needed, it should
/// override this to adjust the this pointer as needed for the specified pass
/// info.
virtual void *getAdjustedAnalysisPointer(AnalysisID ID);
virtual ImmutablePass *getAsImmutablePass();
virtual PMDataManager *getAsPMDataManager();
/// verifyAnalysis() - This member can be implemented by a analysis pass to
/// check state of analysis information.
virtual void verifyAnalysis() const;
// dumpPassStructure - Implement the -debug-passes=PassStructure option
virtual void dumpPassStructure(unsigned Offset = 0);
// lookupPassInfo - Return the pass info object for the specified pass class,
// or null if it is not known.
static const PassInfo *lookupPassInfo(const void *TI);
// lookupPassInfo - Return the pass info object for the pass with the given
// argument string, or null if it is not known.
static const PassInfo *lookupPassInfo(StringRef Arg);
// createPass - Create a object for the specified pass class,
// or null if it is not known.
static Pass *createPass(AnalysisID ID);
/// getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to
/// get analysis information that might be around, for example to update it.
/// This is different than getAnalysis in that it can fail (if the analysis
/// results haven't been computed), so should only be used if you can handle
/// the case when the analysis is not available. This method is often used by
/// transformation APIs to update analysis results for a pass automatically as
/// the transform is performed.
///
template<typename AnalysisType> AnalysisType *
getAnalysisIfAvailable() const; // Defined in PassAnalysisSupport.h
/// mustPreserveAnalysisID - This method serves the same function as
/// getAnalysisIfAvailable, but works if you just have an AnalysisID. This
/// obviously cannot give you a properly typed instance of the class if you
/// don't have the class name available (use getAnalysisIfAvailable if you
/// do), but it can tell you if you need to preserve the pass at least.
///
bool mustPreserveAnalysisID(char &AID) const;
/// getAnalysis<AnalysisType>() - This function is used by subclasses to get
/// to the analysis information that they claim to use by overriding the
/// getAnalysisUsage function.
///
template<typename AnalysisType>
AnalysisType &getAnalysis() const; // Defined in PassAnalysisSupport.h
template<typename AnalysisType>
AnalysisType &getAnalysis(Function &F); // Defined in PassAnalysisSupport.h
template<typename AnalysisType>
AnalysisType &getAnalysisID(AnalysisID PI) const;
template<typename AnalysisType>
AnalysisType &getAnalysisID(AnalysisID PI, Function &F);
};
//===----------------------------------------------------------------------===//
/// ModulePass class - This class is used to implement unstructured
/// interprocedural optimizations and analyses. ModulePasses may do anything
/// they want to the program.
///
class ModulePass : public Pass {
public:
/// createPrinterPass - Get a module printer pass.
Pass *createPrinterPass(raw_ostream &O,
const std::string &Banner) const override;
/// runOnModule - Virtual method overriden by subclasses to process the module
/// being operated on.
virtual bool runOnModule(Module &M) = 0;
void assignPassManager(PMStack &PMS, PassManagerType T) override;
/// Return what kind of Pass Manager can manage this pass.
PassManagerType getPotentialPassManagerType() const override;
explicit ModulePass(char &pid) : Pass(PT_Module, pid) {}
// Force out-of-line virtual method.
~ModulePass() override;
};
//===----------------------------------------------------------------------===//
/// ImmutablePass class - This class is used to provide information that does
/// not need to be run. This is useful for things like target information and
/// "basic" versions of AnalysisGroups.
///
class ImmutablePass : public ModulePass {
public:
/// initializePass - This method may be overriden by immutable passes to allow
/// them to perform various initialization actions they require. This is
/// primarily because an ImmutablePass can "require" another ImmutablePass,
/// and if it does, the overloaded version of initializePass may get access to
/// these passes with getAnalysis<>.
///
virtual void initializePass();
ImmutablePass *getAsImmutablePass() override { return this; }
/// ImmutablePasses are never run.
///
bool runOnModule(Module &) override { return false; }
explicit ImmutablePass(char &pid)
: ModulePass(pid) {}
// Force out-of-line virtual method.
~ImmutablePass() override;
};
//===----------------------------------------------------------------------===//
/// FunctionPass class - This class is used to implement most global
/// optimizations. Optimizations should subclass this class if they meet the
/// following constraints:
///
/// 1. Optimizations are organized globally, i.e., a function at a time
/// 2. Optimizing a function does not cause the addition or removal of any
/// functions in the module
///
class FunctionPass : public Pass {
public:
explicit FunctionPass(char &pid) : Pass(PT_Function, pid) {}
/// createPrinterPass - Get a function printer pass.
Pass *createPrinterPass(raw_ostream &O,
const std::string &Banner) const override;
/// runOnFunction - Virtual method overriden by subclasses to do the
/// per-function processing of the pass.
///
virtual bool runOnFunction(Function &F) = 0;
void assignPassManager(PMStack &PMS, PassManagerType T) override;
/// Return what kind of Pass Manager can manage this pass.
PassManagerType getPotentialPassManagerType() const override;
protected:
/// skipOptnoneFunction - This function has Attribute::OptimizeNone
/// and most transformation passes should skip it.
bool skipOptnoneFunction(const Function &F) const;
};
//===----------------------------------------------------------------------===//
/// BasicBlockPass class - This class is used to implement most local
/// optimizations. Optimizations should subclass this class if they
/// meet the following constraints:
/// 1. Optimizations are local, operating on either a basic block or
/// instruction at a time.
/// 2. Optimizations do not modify the CFG of the contained function, or any
/// other basic block in the function.
/// 3. Optimizations conform to all of the constraints of FunctionPasses.
///
class BasicBlockPass : public Pass {
public:
explicit BasicBlockPass(char &pid) : Pass(PT_BasicBlock, pid) {}
/// createPrinterPass - Get a basic block printer pass.
Pass *createPrinterPass(raw_ostream &O,
const std::string &Banner) const override;
using llvm::Pass::doInitialization;
using llvm::Pass::doFinalization;
/// doInitialization - Virtual method overridden by BasicBlockPass subclasses
/// to do any necessary per-function initialization.
///
virtual bool doInitialization(Function &);
/// runOnBasicBlock - Virtual method overriden by subclasses to do the
/// per-basicblock processing of the pass.
///
virtual bool runOnBasicBlock(BasicBlock &BB) = 0;
/// doFinalization - Virtual method overriden by BasicBlockPass subclasses to
/// do any post processing needed after all passes have run.
///
virtual bool doFinalization(Function &);
void assignPassManager(PMStack &PMS, PassManagerType T) override;
/// Return what kind of Pass Manager can manage this pass.
PassManagerType getPotentialPassManagerType() const override;
protected:
/// skipOptnoneFunction - Containing function has Attribute::OptimizeNone
/// and most transformation passes should skip it.
bool skipOptnoneFunction(const BasicBlock &BB) const;
};
/// If the user specifies the -time-passes argument on an LLVM tool command line
/// then the value of this boolean will be true, otherwise false.
/// @brief This is the storage for the -time-passes option.
extern bool TimePassesIsEnabled;
} // End llvm namespace
// Include support files that contain important APIs commonly used by Passes,
// but that we want to separate out to make it easier to read the header files.
//
#include "llvm/PassSupport.h" #include "llvm/PassSupport.h"
#include "llvm/PassAnalysisSupport.h" #include "llvm/PassAnalysisSupport.h"
Context not available.

include/llvm/PassAnalysisSupport.h

Context not available.
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Pass.h" #include "llvm/PassBase.h"
#include <vector> #include <vector>
namespace llvm { namespace llvm {
Context not available.

include/llvm/PassBase.h

//===- llvm/Pass.h - Base class for Passes ----------------------*- C++ -*-===// //===- llvm/PassBase.h - Base class for Passes ------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
Context not available.
// global optimizations should derive from FunctionPass, because they do not add // global optimizations should derive from FunctionPass, because they do not add
// or delete functions, they operate on the internals of the function. // or delete functions, they operate on the internals of the function.
// //
// Note that this file #includes PassSupport.h and PassAnalysisSupport.h (at the
// bottom), so the APIs exposed by these files are also automatically available
// to all users of this file.
//
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_PASS_H #ifndef LLVM_PASSBASE_H
#define LLVM_PASS_H #define LLVM_PASSBASE_H
#include "llvm/Support/Compiler.h" #include "llvm/Support/Compiler.h"
#include <string> #include <string>
Context not available.
} // End llvm namespace } // End llvm namespace
// Include support files that contain important APIs commonly used by Passes,
// but that we want to separate out to make it easier to read the header files.
//
#include "llvm/PassSupport.h"
#include "llvm/PassAnalysisSupport.h"
#endif #endif
Context not available.

include/llvm/PassSupport.h

Context not available.
#ifndef LLVM_PASSSUPPORT_H #ifndef LLVM_PASSSUPPORT_H
#define LLVM_PASSSUPPORT_H #define LLVM_PASSSUPPORT_H
#include "Pass.h" #include "PassBase.h"
#include "llvm/InitializePasses.h" #include "llvm/InitializePasses.h"
#include "llvm/PassInfo.h" #include "llvm/PassInfo.h"
#include "llvm/PassRegistry.h" #include "llvm/PassRegistry.h"
Context not available.

include/llvm/module.modulemap

Context not available.
// FIXME: Is this the right place for these? // FIXME: Is this the right place for these?
module Pass { header "Pass.h" export * } module Pass { header "Pass.h" export * }
module PassBase { header "PassBase.h" export * }
module PassSupport { header "PassSupport.h" export * } module PassSupport { header "PassSupport.h" export * }
module PassAnalysisSupport { header "PassAnalysisSupport.h" export * } module PassAnalysisSupport { header "PassAnalysisSupport.h" export * }
module PassRegistry { header "PassRegistry.h" export * } module PassRegistry { header "PassRegistry.h" export * }
Context not available.