-
-
-// doOneCleanupPass - Do one pass over the input method, fixing stuff up.
-//
-bool CleanupGCCOutput::doOneCleanupPass(Method *M) {
- bool Changed = false;
- for (Method::iterator MI = M->begin(), ME = M->end(); MI != ME; ++MI) {
- BasicBlock *BB = *MI;
- BasicBlock::InstListType &BIL = BB->getInstList();
-
- for (BasicBlock::iterator BI = BB->begin(); BI != BB->end();) {
- Instruction *I = *BI;
-
- if (CallInst *CI = dyn_cast<CallInst>(I)) {
- if (CI->getCalledValue() == Malloc) { // Replace call to malloc?
- MallocInst *MallocI = new MallocInst(PtrArrSByte, CI->getOperand(1),
- CI->getName());
- CI->setName("");
- BI = BIL.insert(BI, MallocI)+1;
- ReplaceInstWithInst(BIL, BI, new CastInst(MallocI, PtrSByte));
- Changed = true;
- continue; // Skip the ++BI
- } else if (CI->getCalledValue() == Free) { // Replace call to free?
- ReplaceInstWithInst(BIL, BI, new FreeInst(CI->getOperand(1)));
- Changed = true;
- continue; // Skip the ++BI
- }
- }
-
- ++BI;
- }
- }
-
- return Changed;
-}
-
-
-// FixCastsAndPHIs - The LLVM GCC has a tendancy to intermix Cast instructions
-// in with the PHI nodes. These cast instructions are potentially there for two
-// different reasons:
-//
-// 1. The cast could be for an early PHI, and be accidentally inserted before
-// another PHI node. In this case, the PHI node should be moved to the end
-// of the PHI nodes in the basic block. We know that it is this case if
-// the source for the cast is a PHI node in this basic block.
-//
-// 2. If not #1, the cast must be a source argument for one of the PHI nodes
-// in the current basic block. If this is the case, the cast should be
-// lifted into the basic block for the appropriate predecessor.
-//
-static inline bool FixCastsAndPHIs(BasicBlock *BB) {
- bool Changed = false;
-
- BasicBlock::iterator InsertPos = BB->begin();
-
- // Find the end of the interesting instructions...
- while (isa<PHINode>(*InsertPos) || isa<CastInst>(*InsertPos)) ++InsertPos;
-
- // Back the InsertPos up to right after the last PHI node.
- while (InsertPos != BB->begin() && isa<CastInst>(*(InsertPos-1))) --InsertPos;
-
- // No PHI nodes, quick exit.
- if (InsertPos == BB->begin()) return false;
-
- // Loop over all casts trapped between the PHI's...
- BasicBlock::iterator I = BB->begin();
- while (I != InsertPos) {
- if (CastInst *CI = dyn_cast<CastInst>(*I)) { // Fix all cast instructions
- Value *Src = CI->getOperand(0);
-
- // Move the cast instruction to the current insert position...
- --InsertPos; // New position for cast to go...
- swap(*InsertPos, *I); // Cast goes down, PHI goes up
-
- if (isa<PHINode>(Src) && // Handle case #1
- cast<PHINode>(Src)->getParent() == BB) {
- // We're done for case #1
- } else { // Handle case #2
- // In case #2, we have to do a few things:
- // 1. Remove the cast from the current basic block.
- // 2. Identify the PHI node that the cast is for.
- // 3. Find out which predecessor the value is for.
- // 4. Move the cast to the end of the basic block that it SHOULD be
- //
-
- // Remove the cast instruction from the basic block. The remove only
- // invalidates iterators in the basic block that are AFTER the removed
- // element. Because we just moved the CastInst to the InsertPos, no
- // iterators get invalidated.
- //
- BB->getInstList().remove(InsertPos);
-
- // Find the PHI node. Since this cast was generated specifically for a
- // PHI node, there can only be a single PHI node using it.
- //
- assert(CI->use_size() == 1 && "Exactly one PHI node should use cast!");
- PHINode *PN = cast<PHINode>(*CI->use_begin());
-
- // Find out which operand of the PHI it is...
- unsigned i;
- for (i = 0; i < PN->getNumIncomingValues(); ++i)
- if (PN->getIncomingValue(i) == CI)
- break;
- assert(i != PN->getNumIncomingValues() && "PHI doesn't use cast!");
-
- // Get the predecessor the value is for...
- BasicBlock *Pred = PN->getIncomingBlock(i);
-
- // Reinsert the cast right before the terminator in Pred.
- Pred->getInstList().insert(Pred->end()-1, CI);
- }
- } else {
- ++I;
- }
- }
-
-
- return Changed;
-}
-
-// RefactorPredecessor - When we find out that a basic block is a repeated
-// predecessor in a PHI node, we have to refactor the method until there is at
-// most a single instance of a basic block in any predecessor list.
-//
-static inline void RefactorPredecessor(BasicBlock *BB, BasicBlock *Pred) {
- Method *M = BB->getParent();
- assert(find(BB->pred_begin(), BB->pred_end(), Pred) != BB->pred_end() &&
- "Pred is not a predecessor of BB!");
-
- // Create a new basic block, adding it to the end of the method.
- BasicBlock *NewBB = new BasicBlock("", M);
-
- // Add an unconditional branch to BB to the new block.
- NewBB->getInstList().push_back(new BranchInst(BB));
-
- // Get the terminator that causes a branch to BB from Pred.
- TerminatorInst *TI = Pred->getTerminator();
-
- // Find the first use of BB in the terminator...
- User::op_iterator OI = find(TI->op_begin(), TI->op_end(), BB);
- assert(OI != TI->op_end() && "Pred does not branch to BB!!!");
-
- // Change the use of BB to point to the new stub basic block
- *OI = NewBB;
-
- // Now we need to loop through all of the PHI nodes in BB and convert their
- // first incoming value for Pred to reference the new basic block instead.
- //
- for (BasicBlock::iterator I = BB->begin();
- PHINode *PN = dyn_cast<PHINode>(*I); ++I) {
- int BBIdx = PN->getBasicBlockIndex(Pred);
- assert(BBIdx != -1 && "PHI node doesn't have an entry for Pred!");
-
- // The value that used to look like it came from Pred now comes from NewBB
- PN->setIncomingBlock((unsigned)BBIdx, NewBB);
- }
-}
-
-
-// CheckIncomingValueFor - Make sure that the specified PHI node has an entry
-// for the provided basic block. If it doesn't, add one and return true.
-//
-static inline void CheckIncomingValueFor(PHINode *PN, BasicBlock *BB) {
- if (PN->getBasicBlockIndex(BB) != -1) return; // Already has value
-
- Value *NewVal = 0;
- const Type *Ty = PN->getType();
-
- if (const PointerType *PT = dyn_cast<PointerType>(Ty))
- NewVal = ConstPoolPointerNull::get(PT);
- else if (Ty == Type::BoolTy)
- NewVal = ConstPoolBool::True;
- else if (Ty == Type::FloatTy || Ty == Type::DoubleTy)
- NewVal = ConstPoolFP::get(Ty, 42);
- else if (Ty->isIntegral())
- NewVal = ConstPoolInt::get(Ty, 42);
-
- assert(NewVal && "Unknown PHI node type!");
- PN->addIncoming(NewVal, BB);
-}
-
-// fixLocalProblems - Loop through the method and fix problems with the PHI
-// nodes in the current method. The two problems that are handled are:
-//
-// 1. PHI nodes with multiple entries for the same predecessor. GCC sometimes
-// generates code that looks like this:
-//
-// bb7: br bool %cond1004, label %bb8, label %bb8
-// bb8: %reg119 = phi uint [ 0, %bb7 ], [ 1, %bb7 ]
-//
-// which is completely illegal LLVM code. To compensate for this, we insert
-// an extra basic block, and convert the code to look like this:
-//
-// bb7: br bool %cond1004, label %bbX, label %bb8
-// bbX: br label bb8
-// bb8: %reg119 = phi uint [ 0, %bbX ], [ 1, %bb7 ]
-//
-//
-// 2. PHI nodes with fewer arguments than predecessors.
-// These can be generated by GCC if a variable is uninitalized over a path
-// in the CFG. We fix this by adding an entry for the missing predecessors
-// that is initialized to either 42 for a numeric/FP value, or null if it's
-// a pointer value. This problem can be generated by code that looks like
-// this:
-// int foo(int y) {
-// int X;
-// if (y) X = 1;
-// return X;
-// }
-//
-static bool fixLocalProblems(Method *M) {
- bool Changed = false;
- // Don't use iterators because invalidation gets messy...
- for (unsigned MI = 0; MI < M->size(); ++MI) {
- BasicBlock *BB = M->getBasicBlocks()[MI];
-
- Changed |= FixCastsAndPHIs(BB);
-
- if (isa<PHINode>(BB->front())) {
- const vector<BasicBlock*> Preds(BB->pred_begin(), BB->pred_end());
-
- // Handle Problem #1. Sort the list of predecessors so that it is easy to
- // decide whether or not duplicate predecessors exist.
- vector<BasicBlock*> SortedPreds(Preds);
- sort(SortedPreds.begin(), SortedPreds.end());
-
- // Loop over the predecessors, looking for adjacent BB's that are equal.
- BasicBlock *LastOne = 0;
- for (unsigned i = 0; i < Preds.size(); ++i) {
- if (SortedPreds[i] == LastOne) { // Found a duplicate.
- RefactorPredecessor(BB, SortedPreds[i]);
- Changed = true;
- }
- LastOne = SortedPreds[i];
- }
-
- // Loop over all of the PHI nodes in the current BB. These PHI nodes are
- // guaranteed to be at the beginning of the basic block.
- //
- for (BasicBlock::iterator I = BB->begin();
- PHINode *PN = dyn_cast<PHINode>(*I); ++I) {
-
- // Handle problem #2.
- if (PN->getNumIncomingValues() != Preds.size()) {
- assert(PN->getNumIncomingValues() <= Preds.size() &&
- "Can't handle extra arguments to PHI nodes!");
- for (unsigned i = 0; i < Preds.size(); ++i)
- CheckIncomingValueFor(PN, Preds[i]);
- Changed = true;
- }
- }
- }
- }
- return Changed;
-}
-
-
-
-
-// doPerMethodWork - This method simplifies the specified method hopefully.
-//
-bool CleanupGCCOutput::doPerMethodWork(Method *M) {
- bool Changed = fixLocalProblems(M);
- while (doOneCleanupPass(M)) Changed = true;
- return Changed;
-}