ExtractGV.cpp revision 198892
1228753Smm//===-- ExtractGV.cpp - Global Value extraction pass ----------------------===// 2228753Smm// 3228753Smm// The LLVM Compiler Infrastructure 4228753Smm// 5228753Smm// This file is distributed under the University of Illinois Open Source 6228753Smm// License. See LICENSE.TXT for details. 7228753Smm// 8228753Smm//===----------------------------------------------------------------------===// 9228753Smm// 10228753Smm// This pass extracts global values 11228753Smm// 12228753Smm//===----------------------------------------------------------------------===// 13228753Smm 14228753Smm#include "llvm/Instructions.h" 15#include "llvm/LLVMContext.h" 16#include "llvm/Module.h" 17#include "llvm/Pass.h" 18#include "llvm/Constants.h" 19#include "llvm/Transforms/IPO.h" 20#include <algorithm> 21using namespace llvm; 22 23namespace { 24 /// @brief A pass to extract specific functions and their dependencies. 25 class GVExtractorPass : public ModulePass { 26 std::vector<GlobalValue*> Named; 27 bool deleteStuff; 28 bool reLink; 29 public: 30 static char ID; // Pass identification, replacement for typeid 31 32 /// FunctionExtractorPass - If deleteFn is true, this pass deletes as the 33 /// specified function. Otherwise, it deletes as much of the module as 34 /// possible, except for the function specified. 35 /// 36 explicit GVExtractorPass(std::vector<GlobalValue*>& GVs, bool deleteS = true, 37 bool relinkCallees = false) 38 : ModulePass(&ID), Named(GVs), deleteStuff(deleteS), 39 reLink(relinkCallees) {} 40 41 bool runOnModule(Module &M) { 42 if (Named.size() == 0) { 43 return false; // Nothing to extract 44 } 45 46 47 if (deleteStuff) 48 return deleteGV(); 49 M.setModuleInlineAsm(""); 50 return isolateGV(M); 51 } 52 53 bool deleteGV() { 54 for (std::vector<GlobalValue*>::iterator GI = Named.begin(), 55 GE = Named.end(); GI != GE; ++GI) { 56 if (Function* NamedFunc = dyn_cast<Function>(*GI)) { 57 // If we're in relinking mode, set linkage of all internal callees to 58 // external. This will allow us extract function, and then - link 59 // everything together 60 if (reLink) { 61 for (Function::iterator B = NamedFunc->begin(), BE = NamedFunc->end(); 62 B != BE; ++B) { 63 for (BasicBlock::iterator I = B->begin(), E = B->end(); 64 I != E; ++I) { 65 if (CallInst* callInst = dyn_cast<CallInst>(&*I)) { 66 Function* Callee = callInst->getCalledFunction(); 67 if (Callee && Callee->hasLocalLinkage()) 68 Callee->setLinkage(GlobalValue::ExternalLinkage); 69 } 70 } 71 } 72 } 73 74 NamedFunc->setLinkage(GlobalValue::ExternalLinkage); 75 NamedFunc->deleteBody(); 76 assert(NamedFunc->isDeclaration() && "This didn't make the function external!"); 77 } else { 78 if (!(*GI)->isDeclaration()) { 79 cast<GlobalVariable>(*GI)->setInitializer(0); //clear the initializer 80 (*GI)->setLinkage(GlobalValue::ExternalLinkage); 81 } 82 } 83 } 84 return true; 85 } 86 87 bool isolateGV(Module &M) { 88 // Mark all globals internal 89 // FIXME: what should we do with private linkage? 90 for (Module::global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I) 91 if (!I->isDeclaration()) { 92 I->setLinkage(GlobalValue::InternalLinkage); 93 } 94 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) 95 if (!I->isDeclaration()) { 96 I->setLinkage(GlobalValue::InternalLinkage); 97 } 98 99 // Make sure our result is globally accessible... 100 // by putting them in the used array 101 { 102 std::vector<Constant *> AUGs; 103 const Type *SBP= 104 Type::getInt8PtrTy(M.getContext()); 105 for (std::vector<GlobalValue*>::iterator GI = Named.begin(), 106 GE = Named.end(); GI != GE; ++GI) { 107 (*GI)->setLinkage(GlobalValue::ExternalLinkage); 108 AUGs.push_back(ConstantExpr::getBitCast(*GI, SBP)); 109 } 110 ArrayType *AT = ArrayType::get(SBP, AUGs.size()); 111 Constant *Init = ConstantArray::get(AT, AUGs); 112 GlobalValue *gv = new GlobalVariable(M, AT, false, 113 GlobalValue::AppendingLinkage, 114 Init, "llvm.used"); 115 gv->setSection("llvm.metadata"); 116 } 117 118 // All of the functions may be used by global variables or the named 119 // globals. Loop through them and create a new, external functions that 120 // can be "used", instead of ones with bodies. 121 std::vector<Function*> NewFunctions; 122 123 Function *Last = --M.end(); // Figure out where the last real fn is. 124 125 for (Module::iterator I = M.begin(); ; ++I) { 126 if (std::find(Named.begin(), Named.end(), &*I) == Named.end()) { 127 Function *New = Function::Create(I->getFunctionType(), 128 GlobalValue::ExternalLinkage); 129 New->copyAttributesFrom(I); 130 131 // If it's not the named function, delete the body of the function 132 I->dropAllReferences(); 133 134 M.getFunctionList().push_back(New); 135 NewFunctions.push_back(New); 136 New->takeName(I); 137 } 138 139 if (&*I == Last) break; // Stop after processing the last function 140 } 141 142 // Now that we have replacements all set up, loop through the module, 143 // deleting the old functions, replacing them with the newly created 144 // functions. 145 if (!NewFunctions.empty()) { 146 unsigned FuncNum = 0; 147 Module::iterator I = M.begin(); 148 do { 149 if (std::find(Named.begin(), Named.end(), &*I) == Named.end()) { 150 // Make everything that uses the old function use the new dummy fn 151 I->replaceAllUsesWith(NewFunctions[FuncNum++]); 152 153 Function *Old = I; 154 ++I; // Move the iterator to the new function 155 156 // Delete the old function! 157 M.getFunctionList().erase(Old); 158 159 } else { 160 ++I; // Skip the function we are extracting 161 } 162 } while (&*I != NewFunctions[0]); 163 } 164 165 return true; 166 } 167 }; 168 169 char GVExtractorPass::ID = 0; 170} 171 172ModulePass *llvm::createGVExtractionPass(std::vector<GlobalValue*>& GVs, 173 bool deleteFn, bool relinkCallees) { 174 return new GVExtractorPass(GVs, deleteFn, relinkCallees); 175} 176