void getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
AU.addRequired<MachineDominatorTree>();
- MachineFunctionPass::getAnalysisUsage(AU);
}
bool runOnMachineFunction(MachineFunction &mf);
};
class MachineFunction : private Annotation {
- Function *Fn;
+ const Function *Fn;
const TargetMachine &Target;
// RegInfo - Information about each register in use in the function.
unsigned Alignment;
public:
- MachineFunction(Function *Fn, const TargetMachine &TM);
+ MachineFunction(const Function *Fn, const TargetMachine &TM);
~MachineFunction();
/// getFunction - Return the LLVM function that this machine code represents
///
- Function *getFunction() const { return Fn; }
+ const Function *getFunction() const { return Fn; }
/// getTarget - Return the target machine this machine code is compiled with
///
///
void dump() const;
+ /// construct - Allocate and initialize a MachineFunction for a given Function
+ /// and Target
+ ///
+ static MachineFunction& construct(const Function *F, const TargetMachine &TM);
+
+ /// destruct - Destroy the MachineFunction corresponding to a given Function
+ ///
+ static void destruct(const Function *F);
+
+ /// get - Return a handle to a MachineFunction corresponding to the given
+ /// Function. This should not be called before "construct()" for a given
+ /// Function.
+ ///
+ static MachineFunction& get(const Function *F);
+
// Provide accessors for the MachineBasicBlock list...
typedef BasicBlockListType::iterator iterator;
typedef BasicBlockListType::const_iterator const_iterator;
+++ /dev/null
-//===-- MachineFunctionAnalysis.h - Owner of MachineFunctions ----*-C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file declares the MachineFunctionAnalysis class.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CODEGEN_MACHINE_FUNCTION_ANALYSIS_H
-#define LLVM_CODEGEN_MACHINE_FUNCTION_ANALYSIS_H
-
-#include "llvm/Pass.h"
-#include "llvm/Target/TargetMachine.h"
-
-namespace llvm {
-
-class MachineFunction;
-
-/// MachineFunctionAnalysis - This class is a Pass that manages a
-/// MachineFunction object.
-struct MachineFunctionAnalysis : public FunctionPass {
-private:
- const TargetMachine &TM;
- CodeGenOpt::Level OptLevel;
- MachineFunction *MF;
-
-public:
- static char ID;
- explicit MachineFunctionAnalysis(TargetMachine &tm,
- CodeGenOpt::Level OL = CodeGenOpt::Default);
-
-
- MachineFunction &getMF() const { return *MF; }
- CodeGenOpt::Level getOptLevel() const { return OptLevel; }
-
-private:
- virtual bool runOnFunction(Function &F);
- virtual void releaseMemory();
- virtual void getAnalysisUsage(AnalysisUsage &AU) const;
-};
-
-} // End llvm namespace
-
-#endif
namespace llvm {
-/// MachineFunctionPass - This class adapts the FunctionPass interface to
-/// allow convenient creation of passes that operate on the MachineFunction
-/// representation. Instead of overriding runOnFunction, subclasses
-/// override runOnMachineFunction.
-class MachineFunctionPass : public FunctionPass {
-protected:
+ // FIXME: This pass should declare that the pass does not invalidate any LLVM
+ // passes.
+struct MachineFunctionPass : public FunctionPass {
explicit MachineFunctionPass(intptr_t ID) : FunctionPass(ID) {}
explicit MachineFunctionPass(void *ID) : FunctionPass(ID) {}
+protected:
/// runOnMachineFunction - This method must be overloaded to perform the
/// desired machine code transformation or analysis.
///
virtual bool runOnMachineFunction(MachineFunction &MF) = 0;
- /// getAnalysisUsage - Subclasses that override getAnalysisUsage
- /// must call this.
- virtual void getAnalysisUsage(AnalysisUsage &AU) const;
-
-private:
+public:
bool runOnFunction(Function &F);
};
/// by seeing if the labels map to the same reduced label.
FunctionPass *createDebugLabelFoldingPass();
+ /// MachineCodeDeletion Pass - This pass deletes all of the machine code for
+ /// the current function, which should happen after the function has been
+ /// emitted to a .s file or to memory.
+ FunctionPass *createMachineCodeDeleter();
+
/// getRegisterAllocator - This creates an instance of the register allocator
/// for the Sparc.
FunctionPass *getRegisterAllocator(TargetMachine &T);
#include "llvm/Pass.h"
#include "llvm/Constant.h"
#include "llvm/CodeGen/SelectionDAG.h"
-#include "llvm/CodeGen/MachineFunctionPass.h"
namespace llvm {
class FastISel;
/// SelectionDAGISel - This is the common base class used for SelectionDAG-based
/// pattern-matching instruction selectors.
-class SelectionDAGISel : public MachineFunctionPass {
+class SelectionDAGISel : public FunctionPass {
public:
const TargetMachine &TM;
TargetLowering &TLI;
virtual void getAnalysisUsage(AnalysisUsage &AU) const;
- virtual bool runOnMachineFunction(MachineFunction &MF);
+ virtual bool runOnFunction(Function &Fn);
unsigned MakeReg(MVT VT);
#include "llvm/GlobalValue.h"
#include "llvm/BasicBlock.h"
#include "llvm/Argument.h"
+#include "llvm/Support/Annotation.h"
#include "llvm/Attributes.h"
namespace llvm {
mutable ilist_node<Argument> Sentinel;
};
-class Function : public GlobalValue,
+class Function : public GlobalValue, public Annotable,
public ilist_node<Function> {
public:
typedef iplist<Argument> ArgumentListType;
#include "llvm/Analysis/LoopPass.h"
#include "llvm/CodeGen/Passes.h"
#include "llvm/CodeGen/GCStrategy.h"
-#include "llvm/CodeGen/MachineFunctionAnalysis.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetRegistry.h"
PM.add(createGCInfoDeleter());
+ // Delete machine code for this function
+ PM.add(createMachineCodeDeleter());
+
return false; // success!
}
PM.add(createGCInfoDeleter());
+ // Delete machine code for this function
+ PM.add(createMachineCodeDeleter());
+
return false; // success!
}
PM.add(createGCInfoDeleter());
+ // Delete machine code for this function
+ PM.add(createMachineCodeDeleter());
+
return false; // success!
}
PM.add(createGCInfoDeleter());
+ // Delete machine code for this function
+ PM.add(createMachineCodeDeleter());
+
return false; // success!
}
PM.add(createGCInfoDeleter());
+ // Delete machine code for this function
+ PM.add(createMachineCodeDeleter());
+
return false; // success!
}
// Standard Lower-Level Passes.
- // Set up a MachineFunction for the rest of CodeGen to work on.
- PM.add(new MachineFunctionAnalysis(*this, OptLevel));
-
// Enable FastISel with -fast, but allow that to be overridden.
if (EnableFastISelOption == cl::BOU_TRUE ||
(OptLevel == CodeGenOpt::None && EnableFastISelOption != cl::BOU_FALSE))
void LiveVariables::getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequiredID(UnreachableMachineBlockElimID);
AU.setPreservesAll();
- MachineFunctionPass::getAnalysisUsage(AU);
}
void LiveVariables::VarInfo::dump() const {
#include <sstream>
using namespace llvm;
+bool MachineFunctionPass::runOnFunction(Function &F) {
+ // Do not codegen any 'available_externally' functions at all, they have
+ // definitions outside the translation unit.
+ if (F.hasAvailableExternallyLinkage())
+ return false;
+
+ return runOnMachineFunction(MachineFunction::get(&F));
+}
+
namespace {
struct VISIBILITY_HIDDEN Printer : public MachineFunctionPass {
static char ID;
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
- MachineFunctionPass::getAnalysisUsage(AU);
}
bool runOnMachineFunction(MachineFunction &MF) {
return new Printer(OS, Banner);
}
+namespace {
+ struct VISIBILITY_HIDDEN Deleter : public MachineFunctionPass {
+ static char ID;
+ Deleter() : MachineFunctionPass(&ID) {}
+
+ const char *getPassName() const { return "Machine Code Deleter"; }
+
+ bool runOnMachineFunction(MachineFunction &MF) {
+ // Delete the annotation from the function now.
+ MachineFunction::destruct(MF.getFunction());
+ return true;
+ }
+ };
+ char Deleter::ID = 0;
+}
+
+/// MachineCodeDeletion Pass - This pass deletes all of the machine code for
+/// the current function, which should happen after the function has been
+/// emitted to a .s file or to memory.
+FunctionPass *llvm::createMachineCodeDeleter() {
+ return new Deleter();
+}
+
+
+
//===---------------------------------------------------------------------===//
// MachineFunction implementation
//===---------------------------------------------------------------------===//
MBB->getParent()->DeleteMachineBasicBlock(MBB);
}
-MachineFunction::MachineFunction(Function *F,
+MachineFunction::MachineFunction(const Function *F,
const TargetMachine &TM)
: Annotation(AnnotationManager::getID("CodeGen::MachineCodeForFunction")),
Fn(F), Target(TM) {
#endif // NDEBUG
}
+// The next two methods are used to construct and to retrieve
+// the MachineCodeForFunction object for the given function.
+// construct() -- Allocates and initializes for a given function and target
+// get() -- Returns a handle to the object.
+// This should not be called before "construct()"
+// for a given Function.
+//
+MachineFunction&
+MachineFunction::construct(const Function *Fn, const TargetMachine &Tar)
+{
+ AnnotationID MF_AID =
+ AnnotationManager::getID("CodeGen::MachineCodeForFunction");
+ assert(Fn->getAnnotation(MF_AID) == 0 &&
+ "Object already exists for this function!");
+ MachineFunction* mcInfo = new MachineFunction(Fn, Tar);
+ Fn->addAnnotation(mcInfo);
+ return *mcInfo;
+}
+
+void MachineFunction::destruct(const Function *Fn) {
+ AnnotationID MF_AID =
+ AnnotationManager::getID("CodeGen::MachineCodeForFunction");
+ bool Deleted = Fn->deleteAnnotation(MF_AID);
+ assert(Deleted && "Machine code did not exist for function!");
+ Deleted = Deleted; // silence warning when no assertions.
+}
+
+MachineFunction& MachineFunction::get(const Function *F)
+{
+ AnnotationID MF_AID =
+ AnnotationManager::getID("CodeGen::MachineCodeForFunction");
+ MachineFunction *mc = (MachineFunction*)F->getAnnotation(MF_AID);
+ assert(mc && "Call construct() method first to allocate the object");
+ return *mc;
+}
+
/// addLiveIn - Add the specified physical register as a live-in value and
/// create a corresponding virtual register for it.
unsigned MachineFunction::addLiveIn(unsigned PReg,
+++ /dev/null
-//===-- MachineFunctionAnalysis.cpp ---------------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains the definitions of the MachineFunctionAnalysis members.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/CodeGen/MachineFunctionAnalysis.h"
-#include "llvm/CodeGen/MachineFunction.h"
-using namespace llvm;
-
-// Register this pass with PassInfo directly to avoid having to define
-// a default constructor.
-static PassInfo
-X("Machine Function Analysis", "machine-function-analysis",
- intptr_t(&MachineFunctionAnalysis::ID), 0,
- /*CFGOnly=*/false, /*is_analysis=*/true);
-
-char MachineFunctionAnalysis::ID = 0;
-
-MachineFunctionAnalysis::MachineFunctionAnalysis(TargetMachine &tm,
- CodeGenOpt::Level OL) :
- FunctionPass(&ID), TM(tm), OptLevel(OL), MF(0) {
-}
-
-bool MachineFunctionAnalysis::runOnFunction(Function &F) {
- assert(!MF && "MachineFunctionAnalysis already initialized!");
- MF = new MachineFunction(&F, TM);
- return false;
-}
-
-void MachineFunctionAnalysis::releaseMemory() {
- delete MF;
- MF = 0;
-}
-
-void MachineFunctionAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
- AU.setPreservesAll();
-}
+++ /dev/null
-//===-- MachineFunctionPass.cpp -------------------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains the definitions of the MachineFunctionPass members.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/Analysis/ScalarEvolution.h"
-#include "llvm/Analysis/IVUsers.h"
-#include "llvm/Analysis/LiveValues.h"
-#include "llvm/Analysis/LoopDependenceAnalysis.h"
-#include "llvm/Analysis/MemoryDependenceAnalysis.h"
-#include "llvm/CodeGen/MachineFunctionAnalysis.h"
-#include "llvm/CodeGen/MachineFunctionPass.h"
-using namespace llvm;
-
-bool MachineFunctionPass::runOnFunction(Function &F) {
- // Do not codegen any 'available_externally' functions at all, they have
- // definitions outside the translation unit.
- if (F.hasAvailableExternallyLinkage())
- return false;
-
- MachineFunction &MF = getAnalysis<MachineFunctionAnalysis>().getMF();
- return runOnMachineFunction(MF);
-}
-
-void MachineFunctionPass::getAnalysisUsage(AnalysisUsage &AU) const {
- AU.addRequired<MachineFunctionAnalysis>();
-
- // MachineFunctionPass preserves all LLVM IR passes, but there's no
- // high-level way to express this. Instead, just list a bunch of
- // passes explicitly.
- AU.addPreserved<AliasAnalysis>();
- AU.addPreserved<ScalarEvolution>();
- AU.addPreserved<IVUsers>();
- AU.addPreserved<LoopDependenceAnalysis>();
- AU.addPreserved<MemoryDependenceAnalysis>();
- AU.addPreserved<LiveValues>();
- AU.addPreserved<MachineFunctionAnalysis>();
- AU.setPreservesCFG();
-
- FunctionPass::getAnalysisUsage(AU);
-}
void MachineLoopInfo::getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
AU.addRequired<MachineDominatorTree>();
- MachineFunctionPass::getAnalysisUsage(AU);
}
void getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
- MachineFunctionPass::getAnalysisUsage(AU);
}
bool runOnMachineFunction(MachineFunction &MF);
#if 0
void PEI::getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.setPreservesCFG();
if (ShrinkWrapping || ShrinkWrapFunc != "") {
AU.addRequired<MachineLoopInfo>();
AU.addRequired<MachineDominatorTree>();
#include "llvm/CodeGen/GCStrategy.h"
#include "llvm/CodeGen/GCMetadata.h"
#include "llvm/CodeGen/MachineFunction.h"
-#include "llvm/CodeGen/MachineFunctionAnalysis.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineJumpTableInfo.h"
//===----------------------------------------------------------------------===//
SelectionDAGISel::SelectionDAGISel(TargetMachine &tm, CodeGenOpt::Level OL) :
- MachineFunctionPass(&ID), TM(tm), TLI(*tm.getTargetLowering()),
+ FunctionPass(&ID), TM(tm), TLI(*tm.getTargetLowering()),
FuncInfo(new FunctionLoweringInfo(TLI)),
CurDAG(new SelectionDAG(TLI, *FuncInfo)),
SDL(new SelectionDAGLowering(*CurDAG, TLI, *FuncInfo, OL)),
AU.addRequired<GCModuleInfo>();
AU.addRequired<DwarfWriter>();
AU.setPreservesAll();
- MachineFunctionPass::getAnalysisUsage(AU);
}
-bool SelectionDAGISel::runOnMachineFunction(MachineFunction &mf) {
- Function &Fn = *mf.getFunction();
-
+bool SelectionDAGISel::runOnFunction(Function &Fn) {
// Do some sanity-checking on the command-line options.
assert((!EnableFastISelVerbose || EnableFastISel) &&
"-fast-isel-verbose requires -fast-isel");
if (Fn.hasAvailableExternallyLinkage())
return false;
+
// Get alias analysis for load/store combining.
AA = &getAnalysis<AliasAnalysis>();
TargetMachine &TM = TLI.getTargetMachine();
- MF = &mf;
+ MF = &MachineFunction::construct(&Fn, TM);
const TargetInstrInfo &TII = *TM.getInstrInfo();
const TargetRegisterInfo &TRI = *TM.getRegisterInfo();
SPUtli(*tm.getTargetLowering())
{ }
- virtual bool runOnMachineFunction(MachineFunction &MF) {
+ virtual bool runOnFunction(Function &Fn) {
// Make sure we re-emit a set of the global base reg if necessary
GlobalBaseReg = 0;
- SelectionDAGISel::runOnMachineFunction(MF);
+ SelectionDAGISel::runOnFunction(Fn);
return true;
}
#include "PPCHazardRecognizers.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineFunction.h"
-#include "llvm/CodeGen/MachineFunctionAnalysis.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/SelectionDAG.h"
#include "llvm/CodeGen/SelectionDAGISel.h"
PPCLowering(*TM.getTargetLowering()),
PPCSubTarget(*TM.getSubtargetImpl()) {}
- virtual bool runOnMachineFunction(MachineFunction &MF) {
+ virtual bool runOnFunction(Function &Fn) {
+ // Do not codegen any 'available_externally' functions at all, they have
+ // definitions outside the translation unit.
+ if (Fn.hasAvailableExternallyLinkage())
+ return false;
+
// Make sure we re-emit a set of the global base reg if necessary
GlobalBaseReg = 0;
- SelectionDAGISel::runOnMachineFunction(MF);
+ SelectionDAGISel::runOnFunction(Fn);
- InsertVRSaveCode(MF);
+ InsertVRSaveCode(Fn);
return true;
}
/// SelectionDAGISel when it has created a SelectionDAG for us to codegen.
virtual void InstructionSelect();
- void InsertVRSaveCode(MachineFunction &MF);
+ void InsertVRSaveCode(Function &Fn);
virtual const char *getPassName() const {
return "PowerPC DAG->DAG Pattern Instruction Selection";
/// InsertVRSaveCode - Once the entire function has been instruction selected,
/// all virtual registers are created and all machine instructions are built,
/// check to see if we need to save/restore VRSAVE. If so, do it.
-void PPCDAGToDAGISel::InsertVRSaveCode(MachineFunction &Fn) {
+void PPCDAGToDAGISel::InsertVRSaveCode(Function &F) {
// Check to see if this function uses vector registers, which means we have to
// save and restore the VRSAVE register and update it with the regs we use.
//
// In this case, there will be virtual registers of vector type type created
// by the scheduler. Detect them now.
+ MachineFunction &Fn = MachineFunction::get(&F);
bool HasVectorVReg = false;
for (unsigned i = TargetRegisterInfo::FirstVirtualRegister,
e = RegInfo->getLastVirtReg()+1; i != e; ++i)
projects / oota-llvm.git / commitdiff