6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-15 04:30:12 +00:00
Code Issues Projects Releases Wiki Activity

This code was both incredibly complex and incredibly broken. Fix it.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@12456 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2004-03-16 23:23:11 +00:00
parent df22f9c41b
commit c1a0623e86
1 changed files with 58 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -8,156 +8,76 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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 and replaces it with a slot in
// the stack frame, allocated via alloca. It returns the pointer to the // the stack frame, allocated via alloca. It returns the pointer to the
// AllocaInst inserted. // AllocaInst inserted. After this function is called on an instruction, we are
// guaranteed that the only user of the instruction is a store that is
// immediately after it.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/Transforms/Utils/Local.h" #include "llvm/Transforms/Utils/Local.h"
#include "llvm/Function.h" #include "llvm/Function.h"
#include "llvm/iMemory.h" #include "llvm/Instructions.h"
#include "llvm/iPHINode.h"
#include "llvm/iTerminators.h"
#include "llvm/Type.h"
#include "Support/hash_set"
using namespace llvm; using namespace llvm;
typedef hash_set<PHINode*> PhiSet; /// DemoteRegToStack - This function takes a virtual register computed by an
typedef hash_set<PHINode*>::iterator PhiSetIterator; /// Instruction and replaces it with a slot in the stack frame, allocated via
/// alloca. This allows the CFG to be changed around without fear of
/// invalidating the SSA information for the value. It returns the pointer to
/// the alloca inserted to create a stack slot for I.
///
AllocaInst* llvm::DemoteRegToStack(Instruction &I) {
if (I.use_empty()) return 0; // nothing to do!
// Helper function to push a phi *and* all its operands to the worklist! // Create a stack slot to hold the value.
// Do not push an instruction if it is already in the result set of Phis to go. Function *F = I.getParent()->getParent();
static inline void PushOperandsOnWorkList(std::vector<Instruction*>& workList, AllocaInst *Slot = new AllocaInst(I.getType(), 0, I.getName(),
PhiSet& phisToGo, PHINode* phiN) { F->getEntryBlock().begin());
for (User::op_iterator OI = phiN->op_begin(), OE = phiN->op_end();
OI != OE; ++OI) {
Instruction* opI = cast<Instruction>(OI);
if (!isa<PHINode>(opI) || !phisToGo.count(cast<PHINode>(opI)))
workList.push_back(opI);
}
}
static void FindPhis(Instruction& X, PhiSet& phisToGo) { // Change all of the users of the instruction to read from the stack slot
std::vector<Instruction*> workList; // instead.
workList.push_back(&X); while (!I.use_empty()) {
Instruction *U = cast<Instruction>(I.use_back());
// Handle the case that X itself is a Phi! if (PHINode *PN = dyn_cast<PHINode>(U)) {
if (PHINode* phiX = dyn_cast<PHINode>(&X)) { // If this is a PHI node, we can't insert a load of the value before the
phisToGo.insert(phiX); // use. Instead, insert the load in the predecessor block corresponding
PushOperandsOnWorkList(workList, phisToGo, phiX); // to the incoming value.
} //
// Note that if there are multiple edges from a basic block to this PHI
// Now use a worklist to find all phis reachable from X, and // node that we'll insert multiple loads. Since DemoteRegToStack requires
// (recursively) all phis reachable from operands of such phis. // a mem2reg pass after it (to produce reasonable code), we don't care.
while (!workList.empty()) { for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
Instruction *I = workList.back(); if (PN->getIncomingValue(i) == &I) {
workList.pop_back(); // Insert the load into the predecessor block
for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI!=E; ++UI) Value *V = new LoadInst(Slot, I.getName()+".reload",
if (PHINode* phiN = dyn_cast<PHINode>(*UI)) PN->getIncomingBlock(i)->getTerminator());
if (phisToGo.find(phiN) == phisToGo.end()) { PN->setIncomingValue(i, V);
// Seeing this phi for the first time: it must go!
phisToGo.insert(phiN);
workList.push_back(phiN);
PushOperandsOnWorkList(workList, phisToGo, phiN);
} }
}
}
} else {
// Insert loads before all uses of I, except uses in Phis // If this is a normal instruction, just insert a load.
// since all such Phis *must* be deleted. Value *V = new LoadInst(Slot, I.getName()+".reload", U);
static void LoadBeforeUses(Instruction* def, AllocaInst* XSlot) { U->replaceUsesOfWith(&I, V);
for (unsigned nPhis = 0; def->use_size() - nPhis > 0; ) {
Instruction* useI = cast<Instruction>(def->use_back());
if (!isa<PHINode>(useI)) {
LoadInst* loadI =
new LoadInst(XSlot, std::string("Load")+XSlot->getName(), useI);
useI->replaceUsesOfWith(def, loadI);
} else
++nPhis;
}
}
static void AddLoadsAndStores(AllocaInst* XSlot, Instruction& X,
PhiSet& phisToGo) {
for (PhiSetIterator PI=phisToGo.begin(), PE=phisToGo.end(); PI != PE; ++PI) {
PHINode* pn = *PI;
// First, insert loads before all uses except uses in Phis.
// Do this first because new stores will appear as uses also!
LoadBeforeUses(pn, XSlot);
// For every incoming operand of the Phi, insert a store either
// just after the instruction defining the value or just before the
// predecessor of the Phi if the value is a formal, not an instruction.
//
for (unsigned i=0, N=pn->getNumIncomingValues(); i < N; ++i) {
Value* phiOp = pn->getIncomingValue(i);
if (phiOp != &X &&
(!isa<PHINode>(phiOp) || !phisToGo.count(cast<PHINode>(phiOp)))) {
// This operand is not a phi that will be deleted: need to store.
assert(!isa<TerminatorInst>(phiOp));
Instruction* storeBefore;
if (Instruction* I = dyn_cast<Instruction>(phiOp)) {
// phiOp is an instruction, store its result right after it.
assert(I->getNext() && "Non-terminator without successor?");
storeBefore = I->getNext();
} else {
// If not, it must be a formal: store it at the end of the
// predecessor block of the Phi (*not* at function entry!).
storeBefore = pn->getIncomingBlock(i)->getTerminator();
}
// Create instr. to store the value of phiOp before `insertBefore'
StoreInst* storeI = new StoreInst(phiOp, XSlot, storeBefore);
}
} }
} }
}
//---------------------------------------------------------------------------- // Insert stores of the computed value into the stack slot. We have to be
// function DemoteRegToStack() // careful is I is an invoke instruction though, because we can't insert the
// // store AFTER the terminator instruction.
// This function takes a virtual register computed by an if (!isa<TerminatorInst>(I)) {
// Instruction& X and replaces it with a slot in the stack frame, BasicBlock::iterator InsertPt = &I;
// allocated via alloca. It has to: for (++InsertPt; isa<PHINode>(InsertPt); ++InsertPt)
// (1) Identify all Phi operations that have X as an operand and /* empty */; // Don't insert before any PHI nodes.
// transitively other Phis that use such Phis; new StoreInst(&I, Slot, InsertPt);
// (2) Store all values merged with X via Phi operations to the stack slot; } else {
// (3) Load the value from the stack slot just before any use of X or any // FIXME: We cannot yet demote invoke instructions to the stack, because
// of the Phis that were eliminated; and // doing so would require breaking critical edges. This should be fixed
// (4) Delete all the Phis, which should all now be dead. // eventually.
// assert(0 &&
// Returns the pointer to the alloca inserted to create a stack slot for X. "Cannot demote the value computed by an invoke instruction yet!");
// }
AllocaInst* llvm::DemoteRegToStack(Instruction& X) {
if (X.getType() == Type::VoidTy) return Slot;
return 0; // nothing to do!
// Find all Phis involving X or recursively using such Phis or Phis
// involving operands of such Phis (essentially all Phis in the "web" of X)
PhiSet phisToGo;
FindPhis(X, phisToGo);
// Create a stack slot to hold X
Function* parentFunc = X.getParent()->getParent();
AllocaInst *XSlot = new AllocaInst(X.getType(), 0, X.getName(),
parentFunc->getEntryBlock().begin());
// Insert loads before all uses of X and (*only then*) insert store after X
assert(X.getNext() && "Non-terminator (since non-void) with no successor?");
LoadBeforeUses(&X, XSlot);
StoreInst* storeI = new StoreInst(&X, XSlot, X.getNext());
// Do the same for all the phis that will be deleted
AddLoadsAndStores(XSlot, X, phisToGo);
// Delete the phis and return the alloca instruction
for (PhiSetIterator PI = phisToGo.begin(), E = phisToGo.end(); PI != E; ++PI)
(*PI)->getParent()->getInstList().erase(*PI);
return XSlot;
} }