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

Deleting redundant copy of block extractor pass. See also PR1775.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@43694 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Gordon Henriksen 2007-11-05 01:54:05 +00:00
parent 8dec727c1f
commit 4e1be6d5ea
3 changed files with 6 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/Transforms/IPO.h
View File

@ -153,7 +153,7 @@ FunctionPass *createSingleLoopExtractorPass();
/// createBlockExtractorPass - This pass extracts all blocks (except those
/// specified in the argument list) from the functions in the module.
///
ModulePass *createBlockExtractorPass(std::vector<BasicBlock*> &BTNE);
ModulePass *createBlockExtractorPass(const std::vector<BasicBlock*> &BTNE);
/// createOptimizeWellKnownCallsPass - This pass optimizes specific calls to
/// specific well-known (library) functions.

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

@ -151,7 +151,7 @@ namespace {
std::vector<BasicBlock*> BlocksToNotExtract;
public:
static char ID; // Pass identification, replacement for typeid
explicit BlockExtractorPass(std::vector<BasicBlock*> &B)
explicit BlockExtractorPass(const std::vector<BasicBlock*> &B)
: ModulePass((intptr_t)&ID), BlocksToNotExtract(B) {}
BlockExtractorPass() : ModulePass((intptr_t)&ID) {}
@ -166,7 +166,8 @@ namespace {
// createBlockExtractorPass - This pass extracts all blocks (except those
// specified in the argument list) from the functions in the module.
//
ModulePass *llvm::createBlockExtractorPass(std::vector<BasicBlock*> &BTNE) {
ModulePass *llvm::createBlockExtractorPass(const std::vector<BasicBlock*> &BTNE)
{
return new BlockExtractorPass(BTNE);
}

53
tools/bugpoint/ExtractFunction.cpp
View File

@ -297,52 +297,6 @@ Module *llvm::SplitFunctionsOutOfModule(Module *M,
// Basic Block Extraction Code
//===----------------------------------------------------------------------===//
namespace {
std::vector<BasicBlock*> BlocksToNotExtract;
/// 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.
class BlockExtractorPass : public ModulePass {
bool runOnModule(Module &M);
public:
static char ID; // Pass ID, replacement for typeid
BlockExtractorPass() : ModulePass((intptr_t)&ID) {}
};
char BlockExtractorPass::ID = 0;
RegisterPass<BlockExtractorPass>
XX("extract-bbs", "Extract Basic Blocks From Module (for bugpoint use)");
}
bool BlockExtractorPass::runOnModule(Module &M) {
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.
Function *MF = M.getFunction(F->getName());
// 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)));
TranslatedBlocksToNotExtract.insert(BBI);
}
// 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 (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]);
return !BlocksToExtract.empty();
}
/// ExtractMappedBlocksFromModule - Extract all but the specified basic blocks
/// into their own functions. The only detail is that M is actually a module
/// cloned from the one the BBs are in, so some mapping needs to be performed.
@ -351,13 +305,10 @@ bool BlockExtractorPass::runOnModule(Module &M) {
Module *BugDriver::ExtractMappedBlocksFromModule(const
std::vector<BasicBlock*> &BBs,
Module *M) {
// Set the global list so that pass will be able to access it.
BlocksToNotExtract = BBs;
std::vector<const PassInfo*> PI;
PI.push_back(getPI(new BlockExtractorPass()));
// FIXME: BBs is actually ignored. See http://llvm.org/PR1775
PI.push_back(getPI(createBlockExtractorPass(BBs)));
Module *Ret = runPassesOn(M, PI);
BlocksToNotExtract.clear();
if (Ret == 0) {
std::cout << "*** Basic Block extraction failed, please report a bug!\n";
M = swapProgramIn(M);