6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-21 02:24:22 +00:00
Code Issues Projects Releases Wiki Activity

Minor cleanups, no functional changes

Browse Source 
Rename Function::getEntryNode -> getEntryBlock


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@8623 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2003-09-20 14:36:23 +00:00
parent b912491329
commit ab4536e353
1 changed files with 67 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
lib/Transforms/Utils/DemoteRegToStack.cpp
View File

@ -1,4 +1,4 @@
//===- DemoteRegToStack.cpp - Move a virtual reg. to stack ------*- C++ -*-===// //===- DemoteRegToStack.cpp - Move a virtual reg. to stack ----------------===//
// //
// This file provide the function DemoteRegToStack(). This function takes a // This file provide the function DemoteRegToStack(). This function takes a
// virtual register computed by an Instruction& X and replaces it with a slot in // virtual register computed by an Instruction& X and replaces it with a slot in
@ -16,11 +16,6 @@
#include "Support/hash_set" #include "Support/hash_set"
#include <stack> #include <stack>
//----------------------------------------------------------------------------
// function DemoteRegToStack()
//
//----------------------------------------------------------------------------
typedef hash_set<PHINode*> PhiSet; typedef hash_set<PHINode*> PhiSet;
typedef hash_set<PHINode*>::iterator PhiSetIterator; typedef hash_set<PHINode*>::iterator PhiSetIterator;
@ -36,41 +31,37 @@ inline void PushOperandsOnWorkList(std::stack<Instruction*>& workList,
workList.push(opI); workList.push(opI);
} }
void FindPhis(Instruction& X, PhiSet& phisToGo) static void FindPhis(Instruction& X, PhiSet& phisToGo) {
{
std::stack<Instruction*> workList; std::stack<Instruction*> workList;
workList.push(&X); workList.push(&X);
// Handle the case that X itself is a Phi! // Handle the case that X itself is a Phi!
if (PHINode* phiX = dyn_cast<PHINode>(&X)) if (PHINode* phiX = dyn_cast<PHINode>(&X)) {
{ phisToGo.insert(phiX);
phisToGo.insert(phiX); PushOperandsOnWorkList(workList, phisToGo, phiX);
PushOperandsOnWorkList(workList, phisToGo, phiX); }
}
// Now use a worklist to find all phis reachable from X, and // Now use a worklist to find all phis reachable from X, and
// (recursively) all phis reachable from operands of such phis. // (recursively) all phis reachable from operands of such phis.
for (Instruction* workI; !workList.empty(); workList.pop()) for (Instruction* workI; !workList.empty(); workList.pop()) {
{ workI = workList.top();
workI = workList.top(); for (Value::use_iterator UI=workI->use_begin(), UE=workI->use_end();
for (Value::use_iterator UI=workI->use_begin(), UE=workI->use_end(); UI != UE; ++UI)
UI != UE; ++UI) if (PHINode* phiN = dyn_cast<PHINode>(*UI))
if (PHINode* phiN = dyn_cast<PHINode>(*UI)) if (phisToGo.find(phiN) == phisToGo.end()) {
if (phisToGo.find(phiN) == phisToGo.end()) // Seeing this phi for the first time: it must go!
{ // Seeing this phi for the first time: it must go! phisToGo.insert(phiN);
phisToGo.insert(phiN); workList.push(phiN);
workList.push(phiN); PushOperandsOnWorkList(workList, phisToGo, phiN);
PushOperandsOnWorkList(workList, phisToGo, phiN); }
} }
}
} }
// Create the Alloca for X // Create the Alloca for X
AllocaInst* CreateAllocaForX(Instruction& X) static AllocaInst* CreateAllocaForX(Instruction& X) {
{
Function* parentFunc = X.getParent()->getParent(); Function* parentFunc = X.getParent()->getParent();
Instruction* entryInst = parentFunc->getEntryNode().begin(); Instruction* entryInst = parentFunc->getEntryBlock().begin();
return new AllocaInst(X.getType(), /*arraySize*/ NULL, return new AllocaInst(X.getType(), /*arraySize*/ NULL,
X.hasName()? X.getName()+std::string("OnStack") X.hasName()? X.getName()+std::string("OnStack")
: "DemotedTmp", : "DemotedTmp",
@ -79,72 +70,63 @@ AllocaInst* CreateAllocaForX(Instruction& X)
// Insert loads before all uses of I, except uses in Phis // Insert loads before all uses of I, except uses in Phis
// since all such Phis *must* be deleted. // since all such Phis *must* be deleted.
void LoadBeforeUses(Instruction* def, AllocaInst* XSlot) static void LoadBeforeUses(Instruction* def, AllocaInst* XSlot) {
{ for (unsigned nPhis = 0; def->use_size() - nPhis > 0; ) {
for (unsigned nPhis = 0; def->use_size() - nPhis > 0; )
{
Instruction* useI = cast<Instruction>(def->use_back()); Instruction* useI = cast<Instruction>(def->use_back());
if (!isa<PHINode>(useI)) if (!isa<PHINode>(useI)) {
{ LoadInst* loadI =
LoadInst* loadI = new LoadInst(XSlot, std::string("Load")+XSlot->getName(), useI);
new LoadInst(XSlot, std::string("Load")+XSlot->getName(), useI); useI->replaceUsesOfWith(def, loadI);
useI->replaceUsesOfWith(def, loadI); } else
}
else
++nPhis; ++nPhis;
} }
} }
void AddLoadsAndStores(AllocaInst* XSlot, Instruction& X, PhiSet& phisToGo) static void AddLoadsAndStores(AllocaInst* XSlot, Instruction& X,
{ PhiSet& phisToGo) {
for (PhiSetIterator PI=phisToGo.begin(), PE=phisToGo.end(); PI != PE; ++PI) for (PhiSetIterator PI=phisToGo.begin(), PE=phisToGo.end(); PI != PE; ++PI) {
{ PHINode* pn = *PI;
PHINode* pn = *PI;
// First, insert loads before all uses except uses in Phis. // First, insert loads before all uses except uses in Phis.
// Do this first because new stores will appear as uses also! // Do this first because new stores will appear as uses also!
LoadBeforeUses(pn, XSlot); LoadBeforeUses(pn, XSlot);
// For every incoming operand of the Phi, insert a store either // For every incoming operand of the Phi, insert a store either
// just after the instruction defining the value or just before the // just after the instruction defining the value or just before the
// predecessor of the Phi if the value is a formal, not an instruction. // predecessor of the Phi if the value is a formal, not an instruction.
// //
for (unsigned i=0, N=pn->getNumIncomingValues(); i < N; ++i) for (unsigned i=0, N=pn->getNumIncomingValues(); i < N; ++i) {
{ Value* phiOp = pn->getIncomingValue(i);
Value* phiOp = pn->getIncomingValue(i); if (phiOp != &X &&
if (phiOp != &X && (!isa<PHINode>(phiOp) ||
(!isa<PHINode>(phiOp) || phisToGo.find(cast<PHINode>(phiOp)) == phisToGo.end())) {
phisToGo.find(cast<PHINode>(phiOp)) == phisToGo.end())) // This operand is not a phi that will be deleted: need to store.
{ // This operand is not a phi that will be deleted: need to store. assert(!isa<TerminatorInst>(phiOp));
assert(!isa<TerminatorInst>(phiOp));
Instruction* storeBefore; Instruction* storeBefore;
if (Instruction* I = dyn_cast<Instruction>(phiOp)) if (Instruction* I = dyn_cast<Instruction>(phiOp)) {
{ // phiOp is an instruction, store its result right after it. // phiOp is an instruction, store its result right after it.
assert(I->getNext() && "Non-terminator without successor?"); assert(I->getNext() && "Non-terminator without successor?");
storeBefore = I->getNext(); storeBefore = I->getNext();
} } else {
else // If not, it must be a formal: store it at the end of the
{ // If not, it must be a formal: store it at the end of the // predecessor block of the Phi (*not* at function entry!).
// predecessor block of the Phi (*not* at function entry!). storeBefore = pn->getIncomingBlock(i)->getTerminator();
storeBefore = pn->getIncomingBlock(i)->getTerminator();
}
// Create instr. to store the value of phiOp before `insertBefore'
StoreInst* storeI = new StoreInst(phiOp, XSlot, storeBefore);
}
} }
// Create instr. to store the value of phiOp before `insertBefore'
StoreInst* storeI = new StoreInst(phiOp, XSlot, storeBefore);
}
} }
}
} }
void DeletePhis(PhiSet& phisToGo) static void DeletePhis(PhiSet& phisToGo) {
{ for (PhiSetIterator PI=phisToGo.begin(), PE=phisToGo.end(); PI != PE; ++PI) {
for (PhiSetIterator PI=phisToGo.begin(), PE=phisToGo.end(); PI != PE; ++PI) assert((*PI)->use_size() == 0 && "This PHI should be DEAD!");
{ (*PI)->getParent()->getInstList().remove(*PI);
assert((*PI)->use_size() == 0 && "This PHI should be DEAD!"); delete *PI;
(*PI)->getParent()->getInstList().remove(*PI); }
delete *PI;
}
phisToGo.clear(); phisToGo.clear();
} }
@ -164,8 +146,7 @@ void DeletePhis(PhiSet& phisToGo)
// Returns the pointer to the alloca inserted to create a stack slot for X. // Returns the pointer to the alloca inserted to create a stack slot for X.
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
AllocaInst* DemoteRegToStack(Instruction& X) AllocaInst* DemoteRegToStack(Instruction& X) {
{
if (X.getType() == Type::VoidTy) if (X.getType() == Type::VoidTy)
return NULL; // nothing to do! return NULL; // nothing to do!