From 792699c46ef9bfc47dd459bbfa7e71bcb2cee29a Mon Sep 17 00:00:00 2001 From: Tanya Lattner Date: Mon, 24 May 2004 06:11:51 +0000 Subject: [PATCH] Added MachineFunction parent* to MachineBasicBlock. Customized ilist template to set the parent when a MachineBasicBlock is added to a MachineFunction. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@13716 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/CodeGen/MachineBasicBlock.h | 7 ++--- include/llvm/CodeGen/MachineFunction.h | 33 ++++++++++++++++++++++++ lib/CodeGen/MachineBasicBlock.cpp | 29 +++++++++++---------- lib/CodeGen/MachineFunction.cpp | 19 ++++++++++++++ 4 files changed, 71 insertions(+), 17 deletions(-) diff --git a/include/llvm/CodeGen/MachineBasicBlock.h b/include/llvm/CodeGen/MachineBasicBlock.h index a035ba14776..4dfda90ae80 100644 --- a/include/llvm/CodeGen/MachineBasicBlock.h +++ b/include/llvm/CodeGen/MachineBasicBlock.h @@ -64,10 +64,11 @@ public: std::vector Predecessors; std::vector Successors; int Number; + MachineFunction *Parent; public: MachineBasicBlock(const BasicBlock *bb = 0) : Prev(0), Next(0), BB(bb), - Number(-1) { + Number(-1), Parent(0) { Insts.parent = this; } ~MachineBasicBlock() {} @@ -79,8 +80,8 @@ public: /// getParent - Return the MachineFunction containing this basic block. /// - const MachineFunction *getParent() const; - MachineFunction *getParent(); + const MachineFunction *getParent() const { return Parent; } + MachineFunction *getParent() { return Parent; } typedef ilist::iterator iterator; typedef ilist::const_iterator const_iterator; diff --git a/include/llvm/CodeGen/MachineFunction.h b/include/llvm/CodeGen/MachineFunction.h index cb9958bb1f4..dcec822f8e9 100644 --- a/include/llvm/CodeGen/MachineFunction.h +++ b/include/llvm/CodeGen/MachineFunction.h @@ -23,6 +23,39 @@ namespace llvm { +// ilist_traits +template <> +class ilist_traits { + // this is only set by the MachineFunction owning the ilist + friend class MachineFunction; + MachineFunction* parent; + +public: + ilist_traits() : parent(0) { } + + static MachineBasicBlock* getPrev(MachineBasicBlock* N) { return N->Prev; } + static MachineBasicBlock* getNext(MachineBasicBlock* N) { return N->Next; } + + static const MachineBasicBlock* + getPrev(const MachineBasicBlock* N) { return N->Prev; } + + static const MachineBasicBlock* + getNext(const MachineBasicBlock* N) { return N->Next; } + + static void setPrev(MachineBasicBlock* N, MachineBasicBlock* prev) { N->Prev = prev; } + static void setNext(MachineBasicBlock* N, MachineBasicBlock* next) { N->Next = next; } + + static MachineBasicBlock* createNode(); + void addNodeToList(MachineBasicBlock* N); + void removeNodeFromList(MachineBasicBlock* N); + void transferNodesFromList( + iplist >& toList, + ilist_iterator first, + ilist_iterator last); +}; + + + class Function; class TargetMachine; class SSARegMap; diff --git a/lib/CodeGen/MachineBasicBlock.cpp b/lib/CodeGen/MachineBasicBlock.cpp index 64f735c48e6..c0b144d26c3 100644 --- a/lib/CodeGen/MachineBasicBlock.cpp +++ b/lib/CodeGen/MachineBasicBlock.cpp @@ -20,29 +20,25 @@ #include "Support/LeakDetector.h" using namespace llvm; -const MachineFunction *MachineBasicBlock::getParent() const { - // Get the parent by getting the Function parent of the basic block, and - // getting the MachineFunction from it. - return &MachineFunction::get(getBasicBlock()->getParent()); -} - -MachineFunction *MachineBasicBlock::getParent() { - // Get the parent by getting the Function parent of the basic block, and - // getting the MachineFunction from it. - return &MachineFunction::get(getBasicBlock()->getParent()); -} - // MBBs start out as #-1. When a MBB is added to a MachineFunction, it // gets the next available unique MBB number. If it is removed from a // MachineFunction, it goes back to being #-1. void ilist_traits::addNodeToList (MachineBasicBlock* N) { - N->Number = N->getParent ()->getNextMBBNumber (); + assert(N->Parent == 0 && "machine instruction already in a basic block"); + N->Parent = parent; + N->Number = parent->getNextMBBNumber(); + LeakDetector::removeGarbageObject(N); + + } void ilist_traits::removeNodeFromList (MachineBasicBlock* N) { + assert(N->Parent != 0 && "machine instruction not in a basic block"); + N->Parent = 0; N->Number = -1; + LeakDetector::addGarbageObject(N); } @@ -93,8 +89,13 @@ void MachineBasicBlock::dump() const void MachineBasicBlock::print(std::ostream &OS) const { + if(!getParent()) { + OS << "Can't print out MachineBasicBlock because parent MachineFunction is null\n"; + return; + } const BasicBlock *LBB = getBasicBlock(); - OS << "\n" << LBB->getName() << " (" << (const void*)LBB << "):\n"; + if(LBB) + OS << "\n" << LBB->getName() << " (" << (const void*)LBB << "):\n"; for (const_iterator I = begin(); I != end(); ++I) { OS << "\t"; I->print(OS, getParent()->getTarget()); diff --git a/lib/CodeGen/MachineFunction.cpp b/lib/CodeGen/MachineFunction.cpp index f0b06378cad..a3e9211f5c3 100644 --- a/lib/CodeGen/MachineFunction.cpp +++ b/lib/CodeGen/MachineFunction.cpp @@ -24,6 +24,8 @@ #include "llvm/Target/TargetFrameInfo.h" #include "llvm/Function.h" #include "llvm/iOther.h" +#include "Support/LeakDetector.h" + using namespace llvm; static AnnotationID MF_AID( @@ -84,6 +86,22 @@ FunctionPass *llvm::createMachineCodeDeleter() { //===---------------------------------------------------------------------===// // MachineFunction implementation //===---------------------------------------------------------------------===// +MachineBasicBlock* ilist_traits::createNode() +{ + MachineBasicBlock* dummy = new MachineBasicBlock(); + LeakDetector::removeGarbageObject(dummy); + return dummy; +} + +void ilist_traits::transferNodesFromList( + iplist >& toList, + ilist_iterator first, + ilist_iterator last) +{ + if (parent != toList.parent) + for (; first != last; ++first) + first->Parent = toList.parent; +} MachineFunction::MachineFunction(const Function *F, const TargetMachine &TM) @@ -92,6 +110,7 @@ MachineFunction::MachineFunction(const Function *F, MFInfo = new MachineFunctionInfo(*this); FrameInfo = new MachineFrameInfo(); ConstantPool = new MachineConstantPool(); + BasicBlocks.parent = this; } MachineFunction::~MachineFunction() {