From d245a8ae470e2ee84d138379f793095646c590e5 Mon Sep 17 00:00:00 2001 From: Andrew Lenharth Date: Fri, 7 Mar 2008 19:51:57 +0000 Subject: [PATCH] add a pass that can extract all kinds of global values, not just functions. Update llvm-extract to use it and optionally extract a global variable if you want it too git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@48015 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Transforms/IPO.h | 9 ++ lib/Transforms/IPO/ExtractGV.cpp | 174 ++++++++++++++++++++++++++++++++++++ tools/llvm-extract/llvm-extract.cpp | 30 +++++-- 3 files changed, 206 insertions(+), 7 deletions(-) create mode 100644 lib/Transforms/IPO/ExtractGV.cpp diff --git a/include/llvm/Transforms/IPO.h b/include/llvm/Transforms/IPO.h index 8d59fa6355c..f9890ac6d09 100644 --- a/include/llvm/Transforms/IPO.h +++ b/include/llvm/Transforms/IPO.h @@ -24,6 +24,7 @@ class ModulePass; class Pass; class Function; class BasicBlock; +class GlobalValue; //===----------------------------------------------------------------------===// // @@ -85,6 +86,14 @@ ModulePass *createGlobalDCEPass(); ModulePass *createFunctionExtractionPass(Function *F, bool deleteFn = false, bool relinkCallees = false); +//===----------------------------------------------------------------------===// +/// createGVExtractionPass - If deleteFn is true, this pass deletes as +/// the specified global values. Otherwise, it deletes as much of the module as +/// possible, except for the global values specified. +/// +ModulePass *createGVExtractionPass(std::vector& GVs, bool + deleteFn = false, + bool relinkCallees = false); //===----------------------------------------------------------------------===// /// createFunctionInliningPass - Return a new pass object that uses a heuristic diff --git a/lib/Transforms/IPO/ExtractGV.cpp b/lib/Transforms/IPO/ExtractGV.cpp new file mode 100644 index 00000000000..a230dd1db88 --- /dev/null +++ b/lib/Transforms/IPO/ExtractGV.cpp @@ -0,0 +1,174 @@ +//===-- ExtractGV.cpp - Global Value extraction pass ----------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This pass extracts global values +// +//===----------------------------------------------------------------------===// + +#include "llvm/Instructions.h" +#include "llvm/Module.h" +#include "llvm/Pass.h" +#include "llvm/Constants.h" +#include "llvm/Transforms/IPO.h" +#include "llvm/Support/Compiler.h" +using namespace llvm; + +namespace { + /// @brief A pass to extract specific functions and their dependencies. + class VISIBILITY_HIDDEN GVExtractorPass : public ModulePass { + std::vector Named; + bool deleteStuff; + bool reLink; + public: + static char ID; // Pass identification, replacement for typeid + + /// FunctionExtractorPass - If deleteFn is true, this pass deletes as the + /// specified function. Otherwise, it deletes as much of the module as + /// possible, except for the function specified. + /// + explicit GVExtractorPass(std::vector& GVs, bool deleteS = true, + bool relinkCallees = false) + : ModulePass((intptr_t)&ID), Named(GVs), deleteStuff(deleteS), + reLink(relinkCallees) {} + + bool runOnModule(Module &M) { + if (Named.size() == 0) { + return false; // Nothing to extract + } + + if (deleteStuff) + return deleteGV(); + M.setModuleInlineAsm(""); + return isolateGV(M); + } + + bool deleteGV() { + for (std::vector::iterator GI = Named.begin(), + GE = Named.end(); GI != GE; ++GI) { + if (Function* NamedFunc = dyn_cast(&*GI)) { + // If we're in relinking mode, set linkage of all internal callees to + // external. This will allow us extract function, and then - link + // everything together + if (reLink) { + for (Function::iterator B = NamedFunc->begin(), BE = NamedFunc->end(); + B != BE; ++B) { + for (BasicBlock::iterator I = B->begin(), E = B->end(); + I != E; ++I) { + if (CallInst* callInst = dyn_cast(&*I)) { + Function* Callee = callInst->getCalledFunction(); + if (Callee && Callee->hasInternalLinkage()) + Callee->setLinkage(GlobalValue::ExternalLinkage); + } + } + } + } + + NamedFunc->setLinkage(GlobalValue::ExternalLinkage); + NamedFunc->deleteBody(); + assert(NamedFunc->isDeclaration() && "This didn't make the function external!"); + } else { + if (!(*GI)->isDeclaration()) { + cast(*GI)->setInitializer(0); //clear the initializer + (*GI)->setLinkage(GlobalValue::ExternalLinkage); + } + } + } + return true; + } + + bool isolateGV(Module &M) { + // Mark all globals internal + for (Module::global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I) + if (!I->isDeclaration()) { + I->setLinkage(GlobalValue::InternalLinkage); + } + for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) + if (!I->isDeclaration()) { + I->setLinkage(GlobalValue::InternalLinkage); + } + + // Make sure our result is globally accessible... + // by putting them in the used array + { + std::vector AUGs; + const Type *SBP= PointerType::getUnqual(Type::Int8Ty); + for (std::vector::iterator GI = Named.begin(), + GE = Named.end(); GI != GE; ++GI) { + (*GI)->setLinkage(GlobalValue::ExternalLinkage); + AUGs.push_back(ConstantExpr::getBitCast(*GI, SBP)); + } + ArrayType *AT = ArrayType::get(SBP, AUGs.size()); + Constant *Init = ConstantArray::get(AT, AUGs); + GlobalValue *gv = new GlobalVariable(AT, false, + GlobalValue::AppendingLinkage, + Init, "llvm.used", &M); + gv->setSection("llvm.metadata"); + } + + // All of the functions may be used by global variables or the named + // globals. Loop through them and create a new, external functions that + // can be "used", instead of ones with bodies. + std::vector NewFunctions; + + Function *Last = --M.end(); // Figure out where the last real fn is. + + for (Module::iterator I = M.begin(); ; ++I) { + if (std::find(Named.begin(), Named.end(), &*I) == Named.end()) { + Function *New = new Function(I->getFunctionType(), + GlobalValue::ExternalLinkage); + New->setCallingConv(I->getCallingConv()); + New->setParamAttrs(I->getParamAttrs()); + if (I->hasCollector()) + New->setCollector(I->getCollector()); + + // If it's not the named function, delete the body of the function + I->dropAllReferences(); + + M.getFunctionList().push_back(New); + NewFunctions.push_back(New); + New->takeName(I); + } + + if (&*I == Last) break; // Stop after processing the last function + } + + // Now that we have replacements all set up, loop through the module, + // deleting the old functions, replacing them with the newly created + // functions. + if (!NewFunctions.empty()) { + unsigned FuncNum = 0; + Module::iterator I = M.begin(); + do { + if (std::find(Named.begin(), Named.end(), &*I) == Named.end()) { + // Make everything that uses the old function use the new dummy fn + I->replaceAllUsesWith(NewFunctions[FuncNum++]); + + Function *Old = I; + ++I; // Move the iterator to the new function + + // Delete the old function! + M.getFunctionList().erase(Old); + + } else { + ++I; // Skip the function we are extracting + } + } while (&*I != NewFunctions[0]); + } + + return true; + } + }; + + char GVExtractorPass::ID = 0; +} + +ModulePass *llvm::createGVExtractionPass(std::vector& GVs, + bool deleteFn, bool relinkCallees) { + return new GVExtractorPass(GVs, deleteFn, relinkCallees); +} diff --git a/tools/llvm-extract/llvm-extract.cpp b/tools/llvm-extract/llvm-extract.cpp index 67f686e6733..7a16acfc071 100644 --- a/tools/llvm-extract/llvm-extract.cpp +++ b/tools/llvm-extract/llvm-extract.cpp @@ -39,17 +39,22 @@ static cl::opt Force("f", cl::desc("Overwrite output files")); static cl::opt -DeleteFn("delete", cl::desc("Delete specified function from Module")); +DeleteFn("delete", cl::desc("Delete specified Globals from Module")); static cl::opt Relink("relink", cl::desc("Turn external linkage for callees of function to delete")); -// ExtractFunc - The function to extract from the module... defaults to main. +// ExtractFunc - The function to extract from the module... static cl::opt -ExtractFunc("func", cl::desc("Specify function to extract"), cl::init("main"), +ExtractFunc("func", cl::desc("Specify function to extract"), cl::init(""), cl::value_desc("function")); +// ExtractGlobal - The global to extract from the module... +static cl::opt +ExtractGlobal("glob", cl::desc("Specify global to extract"), cl::init(""), + cl::value_desc("global")); + int main(int argc, char **argv) { llvm_shutdown_obj X; // Call llvm_shutdown() on exit. cl::ParseCommandLineOptions(argc, argv, "llvm extractor\n"); @@ -72,10 +77,17 @@ int main(int argc, char **argv) { } // Figure out which function we should extract - Function *F = M.get()->getFunction(ExtractFunc); - if (F == 0) { + GlobalVariable *G = ExtractGlobal.size() ? + M.get()->getNamedGlobal(ExtractGlobal) : 0; + + // Figure out which function we should extract + Function *F = ExtractFunc.size() ? + M.get()->getFunction(ExtractFunc) : + M.get()->getFunction("main"); + + if (F == 0 && G == 0) { cerr << argv[0] << ": program doesn't contain function named '" - << ExtractFunc << "'!\n"; + << ExtractFunc << "' or a global named '" << ExtractGlobal << "'!\n"; return 1; } @@ -84,7 +96,11 @@ int main(int argc, char **argv) { PassManager Passes; Passes.add(new TargetData(M.get())); // Use correct TargetData // Either isolate the function or delete it from the Module - Passes.add(createFunctionExtractionPass(F, DeleteFn, Relink)); + std::vector GVs; + if (F) GVs.push_back(F); + if (G) GVs.push_back(G); + + Passes.add(createGVExtractionPass(GVs, DeleteFn, Relink)); if (!DeleteFn) Passes.add(createGlobalDCEPass()); // Delete unreachable globals Passes.add(createDeadTypeEliminationPass()); // Remove dead types... -- 2.11.0