ExtractFunction.cpp revision efdc0b505712d1ca4460def27e51c430f033d58d
1//===- ExtractFunction.cpp - Extract a function from Program --------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements several methods that are used to extract functions, 11// loops, or portions of a module from the rest of the module. 12// 13//===----------------------------------------------------------------------===// 14 15#include "BugDriver.h" 16#include "llvm/Constant.h" 17#include "llvm/Module.h" 18#include "llvm/PassManager.h" 19#include "llvm/Pass.h" 20#include "llvm/Type.h" 21#include "llvm/Analysis/Verifier.h" 22#include "llvm/Transforms/IPO.h" 23#include "llvm/Transforms/Scalar.h" 24#include "llvm/Transforms/Utils/Cloning.h" 25#include "llvm/Target/TargetData.h" 26#include "Support/CommandLine.h" 27#include "Support/Debug.h" 28#include "Support/FileUtilities.h" 29using namespace llvm; 30 31namespace llvm { 32 bool DisableSimplifyCFG = false; 33} // End llvm namespace 34 35namespace { 36 cl::opt<bool> 37 NoDCE ("disable-dce", 38 cl::desc("Do not use the -dce pass to reduce testcases")); 39 cl::opt<bool, true> 40 NoSCFG("disable-simplifycfg", cl::location(DisableSimplifyCFG), 41 cl::desc("Do not use the -simplifycfg pass to reduce testcases")); 42} 43 44/// deleteInstructionFromProgram - This method clones the current Program and 45/// deletes the specified instruction from the cloned module. It then runs a 46/// series of cleanup passes (ADCE and SimplifyCFG) to eliminate any code which 47/// depends on the value. The modified module is then returned. 48/// 49Module *BugDriver::deleteInstructionFromProgram(const Instruction *I, 50 unsigned Simplification) const { 51 Module *Result = CloneModule(Program); 52 53 const BasicBlock *PBB = I->getParent(); 54 const Function *PF = PBB->getParent(); 55 56 Module::iterator RFI = Result->begin(); // Get iterator to corresponding fn 57 std::advance(RFI, std::distance(PF->getParent()->begin(), 58 Module::const_iterator(PF))); 59 60 Function::iterator RBI = RFI->begin(); // Get iterator to corresponding BB 61 std::advance(RBI, std::distance(PF->begin(), Function::const_iterator(PBB))); 62 63 BasicBlock::iterator RI = RBI->begin(); // Get iterator to corresponding inst 64 std::advance(RI, std::distance(PBB->begin(), BasicBlock::const_iterator(I))); 65 Instruction *TheInst = RI; // Got the corresponding instruction! 66 67 // If this instruction produces a value, replace any users with null values 68 if (TheInst->getType() != Type::VoidTy) 69 TheInst->replaceAllUsesWith(Constant::getNullValue(TheInst->getType())); 70 71 // Remove the instruction from the program. 72 TheInst->getParent()->getInstList().erase(TheInst); 73 74 // Spiff up the output a little bit. 75 PassManager Passes; 76 // Make sure that the appropriate target data is always used... 77 Passes.add(new TargetData("bugpoint", Result)); 78 79 /// FIXME: If this used runPasses() like the methods below, we could get rid 80 /// of the -disable-* options! 81 if (Simplification > 1 && !NoDCE) 82 Passes.add(createDeadCodeEliminationPass()); 83 if (Simplification && !DisableSimplifyCFG) 84 Passes.add(createCFGSimplificationPass()); // Delete dead control flow 85 86 Passes.add(createVerifierPass()); 87 Passes.run(*Result); 88 return Result; 89} 90 91static const PassInfo *getPI(Pass *P) { 92 const PassInfo *PI = P->getPassInfo(); 93 delete P; 94 return PI; 95} 96 97/// performFinalCleanups - This method clones the current Program and performs 98/// a series of cleanups intended to get rid of extra cruft on the module 99/// before handing it to the user... 100/// 101Module *BugDriver::performFinalCleanups(Module *M, bool MayModifySemantics) { 102 // Make all functions external, so GlobalDCE doesn't delete them... 103 for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) 104 I->setLinkage(GlobalValue::ExternalLinkage); 105 106 std::vector<const PassInfo*> CleanupPasses; 107 CleanupPasses.push_back(getPI(createFunctionResolvingPass())); 108 CleanupPasses.push_back(getPI(createGlobalDCEPass())); 109 CleanupPasses.push_back(getPI(createDeadTypeEliminationPass())); 110 111 if (MayModifySemantics) 112 CleanupPasses.push_back(getPI(createDeadArgHackingPass())); 113 else 114 CleanupPasses.push_back(getPI(createDeadArgEliminationPass())); 115 116 std::swap(Program, M); 117 std::string Filename; 118 bool Failed = runPasses(CleanupPasses, Filename); 119 std::swap(Program, M); 120 121 if (Failed) { 122 std::cerr << "Final cleanups failed. Sorry. :( Please report a bug!\n"; 123 } else { 124 delete M; 125 M = ParseInputFile(Filename); 126 if (M == 0) { 127 std::cerr << getToolName() << ": Error reading bytecode file '" 128 << Filename << "'!\n"; 129 exit(1); 130 } 131 removeFile(Filename); 132 } 133 return M; 134} 135 136 137/// ExtractLoop - Given a module, extract up to one loop from it into a new 138/// function. This returns null if there are no extractable loops in the 139/// program or if the loop extractor crashes. 140Module *BugDriver::ExtractLoop(Module *M) { 141 std::vector<const PassInfo*> LoopExtractPasses; 142 LoopExtractPasses.push_back(getPI(createSingleLoopExtractorPass())); 143 144 std::swap(Program, M); 145 std::string Filename; 146 bool Failed = runPasses(LoopExtractPasses, Filename); 147 std::swap(Program, M); 148 149 if (Failed) { 150 std::cerr << "Loop extraction failed. Sorry. :( Please report a bug!\n"; 151 return 0; 152 } else { 153 Module *NewM = ParseInputFile(Filename); 154 if (NewM == 0) { 155 std::cerr << getToolName() << ": Error reading bytecode file '" 156 << Filename << "'!\n"; 157 exit(1); 158 } 159 removeFile(Filename); 160 161 // Check to see if we created any new functions. If not, no loops were 162 // extracted and we should return null. 163 if (M->size() != NewM->size()) { 164 delete NewM; 165 return 0; 166 } 167 168 return NewM; 169 } 170} 171 172 173// DeleteFunctionBody - "Remove" the function by deleting all of its basic 174// blocks, making it external. 175// 176void llvm::DeleteFunctionBody(Function *F) { 177 // delete the body of the function... 178 F->deleteBody(); 179 assert(F->isExternal() && "This didn't make the function external!"); 180} 181 182/// SplitFunctionsOutOfModule - Given a module and a list of functions in the 183/// module, split the functions OUT of the specified module, and place them in 184/// the new module. 185/// 186/// FIXME: this could be made DRAMATICALLY more efficient for large programs if 187/// we just MOVED functions from one module to the other, instead of cloning the 188/// whole module, then proceeding to delete an entire module's worth of stuff. 189/// 190Module *llvm::SplitFunctionsOutOfModule(Module *M, 191 const std::vector<Function*> &F) { 192 // Make sure functions & globals are all external so that linkage 193 // between the two modules will work. 194 for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) 195 I->setLinkage(GlobalValue::ExternalLinkage); 196 for (Module::giterator I = M->gbegin(), E = M->gend(); I != E; ++I) 197 I->setLinkage(GlobalValue::ExternalLinkage); 198 199 Module *New = CloneModule(M); 200 201 // Make sure global initializers exist only in the safe module (CBE->.so) 202 for (Module::giterator I = New->gbegin(), E = New->gend(); I != E; ++I) 203 I->setInitializer(0); // Delete the initializer to make it external 204 205 // Remove the Test functions from the Safe module 206 for (unsigned i = 0, e = F.size(); i != e; ++i) { 207 Function *TNOF = M->getFunction(F[i]->getName(), F[i]->getFunctionType()); 208 DEBUG(std::cerr << "Removing function " << F[i]->getName() << "\n"); 209 assert(TNOF && "Function doesn't exist in module!"); 210 DeleteFunctionBody(TNOF); // Function is now external in this module! 211 } 212 213 // Remove the Safe functions from the Test module 214 for (Module::iterator I = New->begin(), E = New->end(); I != E; ++I) { 215 bool funcFound = false; 216 for (std::vector<Function*>::const_iterator FI = F.begin(), Fe = F.end(); 217 FI != Fe; ++FI) 218 if (I->getName() == (*FI)->getName()) funcFound = true; 219 220 if (!funcFound) 221 DeleteFunctionBody(I); 222 } 223 return New; 224} 225