X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fllvm-extract%2Fllvm-extract.cpp;h=360630b41dc049013915707fb2748ddcbde0d690;hb=56867520990a4fea1353d55f71bb74a0126554e6;hp=4730f54250a7413c21ccb9089689792f3aee5477;hpb=5ff62e90d0bc321206023897edc1e2691cb0fbb6;p=oota-llvm.git diff --git a/tools/llvm-extract/llvm-extract.cpp b/tools/llvm-extract/llvm-extract.cpp index 4730f54250a..360630b41dc 100644 --- a/tools/llvm-extract/llvm-extract.cpp +++ b/tools/llvm-extract/llvm-extract.cpp @@ -1,5 +1,11 @@ +//===- llvm-extract.cpp - LLVM function extraction utility ----------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// //===----------------------------------------------------------------------===// -// LLVM extract Utility // // This utility changes the input module to only contain a single function, // which is primarily used for debugging transformations. @@ -8,107 +14,119 @@ #include "llvm/Module.h" #include "llvm/PassManager.h" -#include "llvm/Bytecode/Reader.h" -#include "llvm/Bytecode/WriteBytecodePass.h" -#include "llvm/GlobalVariable.h" -#include "llvm/Function.h" -#include "llvm/Transforms/IPO/GlobalDCE.h" -#include "llvm/Transforms/ConstantMerge.h" -#include "llvm/Transforms/CleanupGCCOutput.h" -#include "Support/CommandLine.h" +#include "llvm/Bitcode/ReaderWriter.h" +#include "llvm/Transforms/IPO.h" +#include "llvm/Target/TargetData.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/MemoryBuffer.h" +#include "llvm/System/Signals.h" +#include #include +#include +using namespace llvm; // InputFilename - The filename to read from. -static cl::opt -InputFilename(cl::Positional, cl::desc(""), +static cl::opt +InputFilename(cl::Positional, cl::desc(""), cl::init("-"), cl::value_desc("filename")); - -// ExtractFunc - The function to extract from the module... defaults to main. -static cl::opt -ExtractFunc("func", cl::desc("Specify function to extract"), cl::init("main"), +static cl::opt +OutputFilename("o", cl::desc("Specify output filename"), + cl::value_desc("filename"), cl::init("-")); + +static cl::opt +Force("f", cl::desc("Overwrite output files")); + +static cl::opt +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... +static cl::opt +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")); -struct FunctionExtractorPass : public Pass { - const char *getPassName() const { return "Function Extractor"; } - - bool run(Module &M) { - // Mark all global variables to be internal - for (Module::giterator I = M.gbegin(), E = M.gend(); I != E; ++I) - I->setInternalLinkage(true); - - Function *Named = 0; - - // Loop over all of the functions in the module, dropping all references in - // functions that are not the named function. - for (Module::iterator I = M.begin(), E = M.end(); I != E;) - // Check to see if this is the named function! - if (!Named && I->getName() == ExtractFunc) { - // Yes, it is. Keep track of it... - Named = I; - - // Make sure it's globally accessable... - Named->setInternalLinkage(false); - - // Remove the named function from the module. - M.getFunctionList().remove(I); - } else { - // Nope it's not the named function, delete the body of the function - I->dropAllReferences(); - ++I; - } - - // All of the functions that still have uses now must be used by global - // variables or the named function. Loop through them and create a new, - // external function for the used ones... making all uses point to the new - // functions. - std::vector NewFunctions; - - for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) - if (!I->use_empty()) { - Function *New = new Function(I->getFunctionType(), false, I->getName()); - I->replaceAllUsesWith(New); - NewFunctions.push_back(New); - } - - // Now the module only has unused functions with their references dropped. - // Delete them all now! - M.getFunctionList().clear(); - - // Re-insert the named function... - if (Named) - M.getFunctionList().push_back(Named); - else - std::cerr << "Warning: Function '" << ExtractFunc << "' not found!\n"; - - // Insert all of the function stubs... - M.getFunctionList().insert(M.end(), NewFunctions.begin(), - NewFunctions.end()); - return true; +int main(int argc, char **argv) { + llvm_shutdown_obj X; // Call llvm_shutdown() on exit. + cl::ParseCommandLineOptions(argc, argv, "llvm extractor\n"); + sys::PrintStackTraceOnErrorSignal(); + + std::auto_ptr M; + + MemoryBuffer *Buffer = MemoryBuffer::getFileOrSTDIN(InputFilename); + if (Buffer == 0) { + cerr << argv[0] << ": Error reading file '" + InputFilename + "'\n"; + return 1; + } else { + M.reset(ParseBitcodeFile(Buffer)); + } + delete Buffer; + + if (M.get() == 0) { + cerr << argv[0] << ": bitcode didn't read correctly.\n"; + return 1; } -}; + // Figure out which function we should extract + GlobalVariable *G = ExtractGlobal.size() ? + M.get()->getNamedGlobal(ExtractGlobal) : 0; -int main(int argc, char **argv) { - cl::ParseCommandLineOptions(argc, argv, " llvm extractor\n"); + // Figure out which function we should extract + if (!ExtractFunc.size() && !ExtractGlobal.size()) ExtractFunc = "main"; + Function *F = M.get()->getFunction(ExtractFunc); - std::auto_ptr M(ParseBytecodeFile(InputFilename)); - if (M.get() == 0) { - std::cerr << "bytecode didn't read correctly.\n"; + if (F == 0 && G == 0) { + cerr << argv[0] << ": program doesn't contain function named '" + << ExtractFunc << "' or a global named '" << ExtractGlobal << "'!\n"; return 1; } - // In addition to just parsing the input from GCC, we also want to spiff it up - // a little bit. Do this now. - // + // In addition to deleting all other functions, we also want to spiff it + // up a little bit. Do this now. PassManager Passes; - Passes.add(new FunctionExtractorPass()); - Passes.add(createGlobalDCEPass()); // Delete unreachable globals - Passes.add(createConstantMergePass()); // Merge dup global constants - Passes.add(createCleanupGCCOutputPass()); // Fix gccisms - Passes.add(new WriteBytecodePass(&std::cout)); // Write bytecode to file... + Passes.add(new TargetData(M.get())); // Use correct TargetData + // Either isolate the function or delete it from the Module + 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... + Passes.add(createStripDeadPrototypesPass()); // Remove dead func decls + + std::ostream *Out = 0; + + if (OutputFilename != "-") { // Not stdout? + if (!Force && std::ifstream(OutputFilename.c_str())) { + // If force is not specified, make sure not to overwrite a file! + cerr << argv[0] << ": error opening '" << OutputFilename + << "': file exists!\n" + << "Use -f command line argument to force output\n"; + return 1; + } + std::ios::openmode io_mode = std::ios::out | std::ios::trunc | + std::ios::binary; + Out = new std::ofstream(OutputFilename.c_str(), io_mode); + } else { // Specified stdout + // FIXME: cout is not binary! + Out = &std::cout; + } + Passes.add(CreateBitcodeWriterPass(*Out)); Passes.run(*M.get()); + + if (Out != &std::cout) + delete Out; return 0; }