2004-02-28 11:33:01 +08:00
|
|
|
//===- LoopExtractor.cpp - Extract each loop into a new function ----------===//
|
2005-04-22 07:48:37 +08:00
|
|
|
//
|
2004-03-14 10:34:07 +08:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 04:36:04 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-22 07:48:37 +08:00
|
|
|
//
|
2004-03-14 10:34:07 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2004-02-28 11:33:01 +08:00
|
|
|
//
|
|
|
|
// A pass wrapper around the ExtractLoop() scalar transformation to extract each
|
|
|
|
// top-level loop into its own new function. If the loop is the ONLY loop in a
|
2004-03-02 08:19:09 +08:00
|
|
|
// given function, it is not touched. This is a pass most useful for debugging
|
|
|
|
// via bugpoint.
|
2004-02-28 11:33:01 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
|
|
|
#include "llvm/Analysis/LoopPass.h"
|
2014-01-13 17:26:24 +08:00
|
|
|
#include "llvm/IR/Dominators.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Instructions.h"
|
|
|
|
#include "llvm/IR/Module.h"
|
2004-02-28 11:33:01 +08:00
|
|
|
#include "llvm/Pass.h"
|
2007-11-14 14:47:06 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2017-06-06 19:49:48 +08:00
|
|
|
#include "llvm/Transforms/IPO.h"
|
2004-03-14 12:01:06 +08:00
|
|
|
#include "llvm/Transforms/Scalar.h"
|
2011-09-21 03:10:24 +08:00
|
|
|
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
|
2012-05-04 18:18:49 +08:00
|
|
|
#include "llvm/Transforms/Utils/CodeExtractor.h"
|
2007-11-14 14:47:06 +08:00
|
|
|
#include <fstream>
|
|
|
|
#include <set>
|
2004-02-28 11:33:01 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2014-04-22 10:55:47 +08:00
|
|
|
#define DEBUG_TYPE "loop-extract"
|
|
|
|
|
2006-12-20 06:09:18 +08:00
|
|
|
STATISTIC(NumExtracted, "Number of loops extracted");
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2006-12-20 06:09:18 +08:00
|
|
|
namespace {
|
2009-10-25 14:33:48 +08:00
|
|
|
struct LoopExtractor : public LoopPass {
|
2007-05-06 21:37:16 +08:00
|
|
|
static char ID; // Pass identification, replacement for typeid
|
2004-03-15 04:01:36 +08:00
|
|
|
unsigned NumLoops;
|
|
|
|
|
2016-01-09 03:08:53 +08:00
|
|
|
explicit LoopExtractor(unsigned numLoops = ~0)
|
2010-10-20 01:21:58 +08:00
|
|
|
: LoopPass(ID), NumLoops(numLoops) {
|
|
|
|
initializeLoopExtractorPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2004-03-15 04:01:36 +08:00
|
|
|
|
2015-12-17 02:40:20 +08:00
|
|
|
bool runOnLoop(Loop *L, LPPassManager &) override;
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2014-03-05 17:10:37 +08:00
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
2004-03-18 13:43:18 +08:00
|
|
|
AU.addRequiredID(BreakCriticalEdgesID);
|
|
|
|
AU.addRequiredID(LoopSimplifyID);
|
2014-01-13 21:07:17 +08:00
|
|
|
AU.addRequired<DominatorTreeWrapperPass>();
|
2015-12-17 02:40:20 +08:00
|
|
|
AU.addRequired<LoopInfoWrapperPass>();
|
2004-03-14 10:34:07 +08:00
|
|
|
}
|
|
|
|
};
|
2015-06-23 17:49:53 +08:00
|
|
|
}
|
2004-03-14 10:34:07 +08:00
|
|
|
|
2008-05-13 08:00:25 +08:00
|
|
|
char LoopExtractor::ID = 0;
|
2010-10-13 03:48:12 +08:00
|
|
|
INITIALIZE_PASS_BEGIN(LoopExtractor, "loop-extract",
|
2011-09-21 03:10:24 +08:00
|
|
|
"Extract loops into new functions", false, false)
|
2010-10-13 03:48:12 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(BreakCriticalEdges)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
|
2014-01-13 21:07:17 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
|
2010-10-13 03:48:12 +08:00
|
|
|
INITIALIZE_PASS_END(LoopExtractor, "loop-extract",
|
2011-09-21 03:10:24 +08:00
|
|
|
"Extract loops into new functions", false, false)
|
2004-03-15 04:01:36 +08:00
|
|
|
|
2008-05-13 08:00:25 +08:00
|
|
|
namespace {
|
2004-03-15 04:01:36 +08:00
|
|
|
/// SingleLoopExtractor - For bugpoint.
|
|
|
|
struct SingleLoopExtractor : public LoopExtractor {
|
2007-05-06 21:37:16 +08:00
|
|
|
static char ID; // Pass identification, replacement for typeid
|
2004-03-15 04:01:36 +08:00
|
|
|
SingleLoopExtractor() : LoopExtractor(1) {}
|
|
|
|
};
|
2005-04-22 07:48:37 +08:00
|
|
|
} // End anonymous namespace
|
2004-02-28 11:33:01 +08:00
|
|
|
|
2008-05-13 08:00:25 +08:00
|
|
|
char SingleLoopExtractor::ID = 0;
|
2010-07-22 06:09:45 +08:00
|
|
|
INITIALIZE_PASS(SingleLoopExtractor, "loop-extract-single",
|
2010-10-08 06:25:06 +08:00
|
|
|
"Extract at most one loop into a new function", false, false)
|
2008-05-13 08:00:25 +08:00
|
|
|
|
2005-01-09 01:21:40 +08:00
|
|
|
// createLoopExtractorPass - This pass extracts all natural loops from the
|
|
|
|
// program into a function if it can.
|
|
|
|
//
|
2009-09-28 22:37:51 +08:00
|
|
|
Pass *llvm::createLoopExtractorPass() { return new LoopExtractor(); }
|
2005-01-09 01:21:40 +08:00
|
|
|
|
2015-12-17 02:40:20 +08:00
|
|
|
bool LoopExtractor::runOnLoop(Loop *L, LPPassManager &) {
|
2016-04-23 06:06:11 +08:00
|
|
|
if (skipLoop(L))
|
2014-02-06 08:07:05 +08:00
|
|
|
return false;
|
|
|
|
|
2009-09-28 22:37:51 +08:00
|
|
|
// Only visit top-level loops.
|
|
|
|
if (L->getParentLoop())
|
2004-02-28 11:33:01 +08:00
|
|
|
return false;
|
|
|
|
|
2009-11-06 05:11:53 +08:00
|
|
|
// If LoopSimplify form is not available, stay out of trouble.
|
|
|
|
if (!L->isLoopSimplifyForm())
|
|
|
|
return false;
|
|
|
|
|
2014-01-13 21:07:17 +08:00
|
|
|
DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
|
2015-12-17 02:40:20 +08:00
|
|
|
LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
|
2004-02-28 11:33:01 +08:00
|
|
|
bool Changed = false;
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2009-09-28 22:37:51 +08:00
|
|
|
// If there is more than one top-level loop in this function, extract all of
|
|
|
|
// the loops. Otherwise there is exactly one top-level loop; in this case if
|
|
|
|
// this function is more than a minimal wrapper around the loop, extract
|
|
|
|
// the loop.
|
|
|
|
bool ShouldExtractLoop = false;
|
|
|
|
|
|
|
|
// Extract the loop if the entry block doesn't branch to the loop header.
|
|
|
|
TerminatorInst *EntryTI =
|
|
|
|
L->getHeader()->getParent()->getEntryBlock().getTerminator();
|
|
|
|
if (!isa<BranchInst>(EntryTI) ||
|
|
|
|
!cast<BranchInst>(EntryTI)->isUnconditional() ||
|
2011-09-21 06:23:09 +08:00
|
|
|
EntryTI->getSuccessor(0) != L->getHeader()) {
|
2009-09-28 22:37:51 +08:00
|
|
|
ShouldExtractLoop = true;
|
2011-09-21 06:23:09 +08:00
|
|
|
} else {
|
2009-09-28 22:37:51 +08:00
|
|
|
// Check to see if any exits from the loop are more than just return
|
2011-09-21 06:27:16 +08:00
|
|
|
// blocks.
|
|
|
|
SmallVector<BasicBlock*, 8> ExitBlocks;
|
|
|
|
L->getExitBlocks(ExitBlocks);
|
|
|
|
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
|
|
|
|
if (!isa<ReturnInst>(ExitBlocks[i]->getTerminator())) {
|
|
|
|
ShouldExtractLoop = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ShouldExtractLoop) {
|
2015-08-04 16:21:40 +08:00
|
|
|
// We must omit EH pads. EH pads must accompany the invoke
|
2011-09-21 06:27:16 +08:00
|
|
|
// instruction. But this would result in a loop in the extracted
|
2011-09-21 06:23:09 +08:00
|
|
|
// function. An infinite cycle occurs when it tries to extract that loop as
|
|
|
|
// well.
|
2009-09-28 22:37:51 +08:00
|
|
|
SmallVector<BasicBlock*, 8> ExitBlocks;
|
|
|
|
L->getExitBlocks(ExitBlocks);
|
2011-09-21 06:27:16 +08:00
|
|
|
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
|
2015-08-04 16:21:40 +08:00
|
|
|
if (ExitBlocks[i]->isEHPad()) {
|
2011-09-21 06:23:09 +08:00
|
|
|
ShouldExtractLoop = false;
|
2009-09-28 22:37:51 +08:00
|
|
|
break;
|
2004-03-15 08:02:02 +08:00
|
|
|
}
|
2009-09-28 22:37:51 +08:00
|
|
|
}
|
2011-09-21 06:27:16 +08:00
|
|
|
|
2009-09-28 22:37:51 +08:00
|
|
|
if (ShouldExtractLoop) {
|
|
|
|
if (NumLoops == 0) return Changed;
|
|
|
|
--NumLoops;
|
2012-05-04 18:18:49 +08:00
|
|
|
CodeExtractor Extractor(DT, *L);
|
2014-04-25 13:29:35 +08:00
|
|
|
if (Extractor.extractCodeRegion() != nullptr) {
|
2009-09-28 22:37:51 +08:00
|
|
|
Changed = true;
|
|
|
|
// After extraction, the loop is replaced by a function call, so
|
|
|
|
// we shouldn't try to run any more loop passes on it.
|
2016-01-09 03:08:53 +08:00
|
|
|
LI.markAsRemoved(L);
|
2004-03-15 08:02:02 +08:00
|
|
|
}
|
2009-09-28 22:37:51 +08:00
|
|
|
++NumExtracted;
|
2004-03-15 04:01:36 +08:00
|
|
|
}
|
2004-02-28 11:33:01 +08:00
|
|
|
|
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
2004-03-15 04:01:36 +08:00
|
|
|
// createSingleLoopExtractorPass - This pass extracts one natural loop from the
|
|
|
|
// program into a function if it can. This is used by bugpoint.
|
|
|
|
//
|
2009-09-28 22:37:51 +08:00
|
|
|
Pass *llvm::createSingleLoopExtractorPass() {
|
2004-03-15 04:01:36 +08:00
|
|
|
return new SingleLoopExtractor();
|
2004-02-28 11:33:01 +08:00
|
|
|
}
|
2004-08-13 11:05:17 +08:00
|
|
|
|
|
|
|
|
2008-05-13 08:00:25 +08:00
|
|
|
// BlockFile - A file which contains a list of blocks that should not be
|
|
|
|
// extracted.
|
|
|
|
static cl::opt<std::string>
|
|
|
|
BlockFile("extract-blocks-file", cl::value_desc("filename"),
|
|
|
|
cl::desc("A file containing list of basic blocks to not extract"),
|
|
|
|
cl::Hidden);
|
2007-11-14 14:47:06 +08:00
|
|
|
|
2008-05-13 08:00:25 +08:00
|
|
|
namespace {
|
2004-08-13 11:05:17 +08:00
|
|
|
/// BlockExtractorPass - This pass is used by bugpoint to extract all blocks
|
|
|
|
/// from the module into their own functions except for those specified by the
|
|
|
|
/// BlocksToNotExtract list.
|
2004-09-20 12:48:05 +08:00
|
|
|
class BlockExtractorPass : public ModulePass {
|
2007-11-14 14:47:06 +08:00
|
|
|
void LoadFile(const char *Filename);
|
2011-09-21 03:10:24 +08:00
|
|
|
void SplitLandingPadPreds(Function *F);
|
2007-11-14 14:47:06 +08:00
|
|
|
|
2004-08-13 11:05:17 +08:00
|
|
|
std::vector<BasicBlock*> BlocksToNotExtract;
|
2007-11-14 14:47:06 +08:00
|
|
|
std::vector<std::pair<std::string, std::string> > BlocksToNotExtractByName;
|
2004-08-13 11:05:17 +08:00
|
|
|
public:
|
2007-05-06 21:37:16 +08:00
|
|
|
static char ID; // Pass identification, replacement for typeid
|
2010-08-07 02:33:48 +08:00
|
|
|
BlockExtractorPass() : ModulePass(ID) {
|
2007-11-14 14:47:06 +08:00
|
|
|
if (!BlockFile.empty())
|
|
|
|
LoadFile(BlockFile.c_str());
|
|
|
|
}
|
2004-08-13 11:05:17 +08:00
|
|
|
|
2014-03-05 17:10:37 +08:00
|
|
|
bool runOnModule(Module &M) override;
|
2004-08-13 11:05:17 +08:00
|
|
|
};
|
2015-06-23 17:49:53 +08:00
|
|
|
}
|
2004-08-13 11:05:17 +08:00
|
|
|
|
2008-05-13 08:00:25 +08:00
|
|
|
char BlockExtractorPass::ID = 0;
|
2010-07-22 06:09:45 +08:00
|
|
|
INITIALIZE_PASS(BlockExtractorPass, "extract-blocks",
|
|
|
|
"Extract Basic Blocks From Module (for bugpoint use)",
|
2010-10-08 06:25:06 +08:00
|
|
|
false, false)
|
2008-05-13 08:00:25 +08:00
|
|
|
|
2004-08-13 11:05:17 +08:00
|
|
|
// createBlockExtractorPass - This pass extracts all blocks (except those
|
|
|
|
// specified in the argument list) from the functions in the module.
|
|
|
|
//
|
2011-09-21 03:10:24 +08:00
|
|
|
ModulePass *llvm::createBlockExtractorPass() {
|
2010-07-31 08:32:17 +08:00
|
|
|
return new BlockExtractorPass();
|
2004-08-13 11:05:17 +08:00
|
|
|
}
|
|
|
|
|
2007-11-14 14:47:06 +08:00
|
|
|
void BlockExtractorPass::LoadFile(const char *Filename) {
|
|
|
|
// Load the BlockFile...
|
|
|
|
std::ifstream In(Filename);
|
|
|
|
if (!In.good()) {
|
2009-08-23 15:19:13 +08:00
|
|
|
errs() << "WARNING: BlockExtractor couldn't load file '" << Filename
|
|
|
|
<< "'!\n";
|
2007-11-14 14:47:06 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
while (In) {
|
|
|
|
std::string FunctionName, BlockName;
|
|
|
|
In >> FunctionName;
|
|
|
|
In >> BlockName;
|
|
|
|
if (!BlockName.empty())
|
|
|
|
BlocksToNotExtractByName.push_back(
|
|
|
|
std::make_pair(FunctionName, BlockName));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-21 03:10:24 +08:00
|
|
|
/// 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;
|
2014-07-22 01:06:51 +08:00
|
|
|
for (pred_iterator
|
|
|
|
PI = pred_begin(LPad), PE = pred_end(LPad); PI != PE; ++PI) {
|
|
|
|
BasicBlock *BB = *PI;
|
2011-09-21 03:10:24 +08:00
|
|
|
if (BB->isLandingPad() && BB != Parent &&
|
|
|
|
isa<InvokeInst>(Parent->getTerminator())) {
|
|
|
|
Split = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Split) continue;
|
|
|
|
|
|
|
|
SmallVector<BasicBlock*, 2> NewBBs;
|
2015-01-19 11:03:39 +08:00
|
|
|
SplitLandingPadPredecessors(LPad, Parent, ".1", ".2", NewBBs);
|
2011-09-21 03:10:24 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-09-20 12:48:05 +08:00
|
|
|
bool BlockExtractorPass::runOnModule(Module &M) {
|
2016-04-23 06:06:11 +08:00
|
|
|
if (skipModule(M))
|
|
|
|
return false;
|
|
|
|
|
2004-08-13 11:05:17 +08:00
|
|
|
std::set<BasicBlock*> TranslatedBlocksToNotExtract;
|
|
|
|
for (unsigned i = 0, e = BlocksToNotExtract.size(); i != e; ++i) {
|
|
|
|
BasicBlock *BB = BlocksToNotExtract[i];
|
|
|
|
Function *F = BB->getParent();
|
|
|
|
|
|
|
|
// Map the corresponding function in this module.
|
2007-02-06 04:47:22 +08:00
|
|
|
Function *MF = M.getFunction(F->getName());
|
|
|
|
assert(MF->getFunctionType() == F->getFunctionType() && "Wrong function?");
|
2004-08-13 11:05:17 +08:00
|
|
|
|
|
|
|
// Figure out which index the basic block is in its function.
|
|
|
|
Function::iterator BBI = MF->begin();
|
|
|
|
std::advance(BBI, std::distance(F->begin(), Function::iterator(BB)));
|
2015-10-14 01:51:03 +08:00
|
|
|
TranslatedBlocksToNotExtract.insert(&*BBI);
|
2004-08-13 11:05:17 +08:00
|
|
|
}
|
|
|
|
|
2007-11-14 14:47:06 +08:00
|
|
|
while (!BlocksToNotExtractByName.empty()) {
|
|
|
|
// There's no way to find BBs by name without looking at every BB inside
|
|
|
|
// every Function. Fortunately, this is always empty except when used by
|
|
|
|
// bugpoint in which case correctness is more important than performance.
|
|
|
|
|
|
|
|
std::string &FuncName = BlocksToNotExtractByName.back().first;
|
|
|
|
std::string &BlockName = BlocksToNotExtractByName.back().second;
|
|
|
|
|
2016-06-26 20:28:59 +08:00
|
|
|
for (Function &F : M) {
|
2007-11-14 14:47:06 +08:00
|
|
|
if (F.getName() != FuncName) continue;
|
|
|
|
|
2016-06-26 20:28:59 +08:00
|
|
|
for (BasicBlock &BB : F) {
|
2007-11-14 14:47:06 +08:00
|
|
|
if (BB.getName() != BlockName) continue;
|
|
|
|
|
2016-06-26 20:28:59 +08:00
|
|
|
TranslatedBlocksToNotExtract.insert(&BB);
|
2007-11-14 14:47:06 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
BlocksToNotExtractByName.pop_back();
|
|
|
|
}
|
|
|
|
|
2004-08-13 11:05:17 +08:00
|
|
|
// Now that we know which blocks to not extract, figure out which ones we WANT
|
|
|
|
// to extract.
|
|
|
|
std::vector<BasicBlock*> BlocksToExtract;
|
2016-06-26 20:28:59 +08:00
|
|
|
for (Function &F : M) {
|
|
|
|
SplitLandingPadPreds(&F);
|
|
|
|
for (BasicBlock &BB : F)
|
|
|
|
if (!TranslatedBlocksToNotExtract.count(&BB))
|
|
|
|
BlocksToExtract.push_back(&BB);
|
2011-09-21 03:10:24 +08:00
|
|
|
}
|
2004-08-13 11:05:17 +08:00
|
|
|
|
2016-06-26 20:28:59 +08:00
|
|
|
for (BasicBlock *BlockToExtract : BlocksToExtract) {
|
2011-09-21 03:10:24 +08:00
|
|
|
SmallVector<BasicBlock*, 2> BlocksToExtractVec;
|
2016-06-26 20:28:59 +08:00
|
|
|
BlocksToExtractVec.push_back(BlockToExtract);
|
2011-09-21 04:20:50 +08:00
|
|
|
if (const InvokeInst *II =
|
2016-06-26 20:28:59 +08:00
|
|
|
dyn_cast<InvokeInst>(BlockToExtract->getTerminator()))
|
2011-09-21 03:10:24 +08:00
|
|
|
BlocksToExtractVec.push_back(II->getUnwindDest());
|
2012-05-04 18:18:49 +08:00
|
|
|
CodeExtractor(BlocksToExtractVec).extractCodeRegion();
|
2011-09-21 03:10:24 +08:00
|
|
|
}
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2004-08-13 11:05:17 +08:00
|
|
|
return !BlocksToExtract.empty();
|
|
|
|
}
|