mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-01 19:29:22 +00:00
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
161 lines
5.6 KiB
C++
161 lines
5.6 KiB
C++
//===- LoopPass.h - LoopPass class ----------------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines LoopPass class. All loop optimization
|
|
// and transformation passes are derived from LoopPass.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_ANALYSIS_LOOPPASS_H
|
|
#define LLVM_ANALYSIS_LOOPPASS_H
|
|
|
|
#include "llvm/Analysis/LoopInfo.h"
|
|
#include "llvm/IR/LegacyPassManagers.h"
|
|
#include "llvm/Pass.h"
|
|
#include <deque>
|
|
|
|
namespace llvm {
|
|
|
|
class LPPassManager;
|
|
class Function;
|
|
class PMStack;
|
|
|
|
class LoopPass : public Pass {
|
|
public:
|
|
explicit LoopPass(char &pid) : Pass(PT_Loop, pid) {}
|
|
|
|
/// getPrinterPass - Get a pass to print the function corresponding
|
|
/// to a Loop.
|
|
Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const;
|
|
|
|
// runOnLoop - This method should be implemented by the subclass to perform
|
|
// whatever action is necessary for the specified Loop.
|
|
virtual bool runOnLoop(Loop *L, LPPassManager &LPM) = 0;
|
|
|
|
using llvm::Pass::doInitialization;
|
|
using llvm::Pass::doFinalization;
|
|
|
|
// Initialization and finalization hooks.
|
|
virtual bool doInitialization(Loop *L, LPPassManager &LPM) {
|
|
return false;
|
|
}
|
|
|
|
// Finalization hook does not supply Loop because at this time
|
|
// loop nest is completely different.
|
|
virtual bool doFinalization() { return false; }
|
|
|
|
// Check if this pass is suitable for the current LPPassManager, if
|
|
// available. This pass P is not suitable for a LPPassManager if P
|
|
// is not preserving higher level analysis info used by other
|
|
// LPPassManager passes. In such case, pop LPPassManager from the
|
|
// stack. This will force assignPassManager() to create new
|
|
// LPPassManger as expected.
|
|
void preparePassManager(PMStack &PMS);
|
|
|
|
/// Assign pass manager to manage this pass
|
|
virtual void assignPassManager(PMStack &PMS,
|
|
PassManagerType PMT);
|
|
|
|
/// Return what kind of Pass Manager can manage this pass.
|
|
virtual PassManagerType getPotentialPassManagerType() const {
|
|
return PMT_LoopPassManager;
|
|
}
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
/// SimpleAnalysis - Provides simple interface to update analysis info
|
|
/// maintained by various passes. Note, if required this interface can
|
|
/// be extracted into a separate abstract class but it would require
|
|
/// additional use of multiple inheritance in Pass class hierarchy, something
|
|
/// we are trying to avoid.
|
|
|
|
/// Each loop pass can override these simple analysis hooks to update
|
|
/// desired analysis information.
|
|
/// cloneBasicBlockAnalysis - Clone analysis info associated with basic block.
|
|
virtual void cloneBasicBlockAnalysis(BasicBlock *F, BasicBlock *T, Loop *L) {}
|
|
|
|
/// deleteAnalysisValue - Delete analysis info associated with value V.
|
|
virtual void deleteAnalysisValue(Value *V, Loop *L) {}
|
|
};
|
|
|
|
class LPPassManager : public FunctionPass, public PMDataManager {
|
|
public:
|
|
static char ID;
|
|
explicit LPPassManager();
|
|
|
|
/// 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 runOnFunction(Function &F);
|
|
|
|
/// Pass Manager itself does not invalidate any analysis info.
|
|
// LPPassManager needs LoopInfo.
|
|
void getAnalysisUsage(AnalysisUsage &Info) const;
|
|
|
|
virtual const char *getPassName() const {
|
|
return "Loop Pass Manager";
|
|
}
|
|
|
|
virtual PMDataManager *getAsPMDataManager() { return this; }
|
|
virtual Pass *getAsPass() { return this; }
|
|
|
|
/// Print passes managed by this manager
|
|
void dumpPassStructure(unsigned Offset);
|
|
|
|
LoopPass *getContainedPass(unsigned N) {
|
|
assert(N < PassVector.size() && "Pass number out of range!");
|
|
LoopPass *LP = static_cast<LoopPass *>(PassVector[N]);
|
|
return LP;
|
|
}
|
|
|
|
virtual PassManagerType getPassManagerType() const {
|
|
return PMT_LoopPassManager;
|
|
}
|
|
|
|
public:
|
|
// Delete loop from the loop queue and loop nest (LoopInfo).
|
|
void deleteLoopFromQueue(Loop *L);
|
|
|
|
// Insert loop into the loop queue and add it as a child of the
|
|
// given parent.
|
|
void insertLoop(Loop *L, Loop *ParentLoop);
|
|
|
|
// Insert a loop into the loop queue.
|
|
void insertLoopIntoQueue(Loop *L);
|
|
|
|
// Reoptimize this loop. LPPassManager will re-insert this loop into the
|
|
// queue. This allows LoopPass to change loop nest for the loop. This
|
|
// utility may send LPPassManager into infinite loops so use caution.
|
|
void redoLoop(Loop *L);
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
/// SimpleAnalysis - Provides simple interface to update analysis info
|
|
/// maintained by various passes. Note, if required this interface can
|
|
/// be extracted into a separate abstract class but it would require
|
|
/// additional use of multiple inheritance in Pass class hierarchy, something
|
|
/// we are trying to avoid.
|
|
|
|
/// cloneBasicBlockSimpleAnalysis - Invoke cloneBasicBlockAnalysis hook for
|
|
/// all passes that implement simple analysis interface.
|
|
void cloneBasicBlockSimpleAnalysis(BasicBlock *From, BasicBlock *To, Loop *L);
|
|
|
|
/// deleteSimpleAnalysisValue - Invoke deleteAnalysisValue hook for all passes
|
|
/// that implement simple analysis interface.
|
|
void deleteSimpleAnalysisValue(Value *V, Loop *L);
|
|
|
|
private:
|
|
std::deque<Loop *> LQ;
|
|
bool skipThisLoop;
|
|
bool redoThisLoop;
|
|
LoopInfo *LI;
|
|
Loop *CurrentLoop;
|
|
};
|
|
|
|
} // End llvm namespace
|
|
|
|
#endif
|