RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-01-24 12:55:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

When extracting a basic block that ends in an 'invoke' instruction, we need to

Browse Source 
extract its associated landing pad block as well. However, that landing pad
block may have more than one predecessor. So split the landing pad block so that
individual landing pads have only one predecessor.

This type of transformation may produce a false positive with bugpoint.

llvm-svn: 140173
This commit is contained in:
Bill Wendling 2011-09-20 19:10:24 +00:00
parent 66d2eeb730
commit 1ac89f2739
1 changed files with 46 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
lib/Transforms/IPO/LoopExtractor.cpp
View File

@ -23,6 +23,7 @@
#include "llvm/Analysis/LoopPass.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Utils/FunctionUtils.h"
#include "llvm/ADT/Statistic.h"
#include <fstream>
@ -53,12 +54,12 @@ namespace {
char LoopExtractor::ID = 0;
INITIALIZE_PASS_BEGIN(LoopExtractor, "loop-extract",
"Extract loops into new functions", false, false)
"Extract loops into new functions", false, false)
INITIALIZE_PASS_DEPENDENCY(BreakCriticalEdges)
INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
INITIALIZE_PASS_DEPENDENCY(DominatorTree)
INITIALIZE_PASS_END(LoopExtractor, "loop-extract",
"Extract loops into new functions", false, false)
"Extract loops into new functions", false, false)
namespace {
/// SingleLoopExtractor - For bugpoint.
@ -149,6 +150,7 @@ namespace {
/// BlocksToNotExtract list.
class BlockExtractorPass : public ModulePass {
void LoadFile(const char *Filename);
void SplitLandingPadPreds(Function *F);
std::vector<BasicBlock*> BlocksToNotExtract;
std::vector<std::pair<std::string, std::string> > BlocksToNotExtractByName;
@ -171,8 +173,7 @@ INITIALIZE_PASS(BlockExtractorPass, "extract-blocks",
// createBlockExtractorPass - This pass extracts all blocks (except those
// specified in the argument list) from the functions in the module.
//
ModulePass *llvm::createBlockExtractorPass()
{
ModulePass *llvm::createBlockExtractorPass() {
return new BlockExtractorPass();
}
@ -194,6 +195,37 @@ void BlockExtractorPass::LoadFile(const char *Filename) {
}
}
/// SplitLandingPadPreds - The landing pad needs to be extracted with the invoke
/// instruction. The critical edge breaker will refuse to break critical edges
/// to a landing pad. So do them here. After this method runs, all landing pads
/// should have only one predecessor.
void BlockExtractorPass::SplitLandingPadPreds(Function *F) {
for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I) {
InvokeInst *II = dyn_cast<InvokeInst>(I);
if (!II) continue;
BasicBlock *Parent = II->getParent();
BasicBlock *LPad = II->getUnwindDest();
// Look through the landing pad's predecessors. If one of them ends in an
// 'invoke', then we want to split the landing pad.
bool Split = false;
for (pred_iterator
PI = pred_begin(LPad), PE = pred_end(LPad); PI != PE; ++PI) {
BasicBlock *BB = *PI;
if (BB->isLandingPad() && BB != Parent &&
isa<InvokeInst>(Parent->getTerminator())) {
Split = true;
break;
}
}
if (!Split) continue;
SmallVector<BasicBlock*, 2> NewBBs;
SplitLandingPadPredecessors(LPad, Parent, ".1", ".2", 0, NewBBs);
}
}
bool BlockExtractorPass::runOnModule(Module &M) {
std::set<BasicBlock*> TranslatedBlocksToNotExtract;
for (unsigned i = 0, e = BlocksToNotExtract.size(); i != e; ++i) {
@ -236,13 +268,20 @@ bool BlockExtractorPass::runOnModule(Module &M) {
// Now that we know which blocks to not extract, figure out which ones we WANT
// to extract.
std::vector<BasicBlock*> BlocksToExtract;
for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F)
for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
SplitLandingPadPreds(&*F);
for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
if (!TranslatedBlocksToNotExtract.count(BB))
BlocksToExtract.push_back(BB);
}
for (unsigned i = 0, e = BlocksToExtract.size(); i != e; ++i)
ExtractBasicBlock(BlocksToExtract[i]);
for (unsigned i = 0, e = BlocksToExtract.size(); i != e; ++i) {
SmallVector<BasicBlock*, 2> BlocksToExtractVec;
BlocksToExtractVec.push_back(BlocksToExtract[i]);
if (const InvokeInst *II = dyn_cast<InvokeInst>(BlocksToExtract[i]))
BlocksToExtractVec.push_back(II->getUnwindDest());
ExtractBasicBlock(BlocksToExtractVec);
}
return !BlocksToExtract.empty();
}