X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fllvm-extract%2Fllvm-extract.cpp;h=360630b41dc049013915707fb2748ddcbde0d690;hb=84701836bfb1889e2e26e361ebd5d29d972ab396;hp=7a6a1c101ecaa6d93d2f57f3181893a8d65cc194;hpb=579d91411acac4ad68e65376050b1f1729e63ec5;p=oota-llvm.git diff --git a/tools/llvm-extract/llvm-extract.cpp b/tools/llvm-extract/llvm-extract.cpp index 7a6a1c101ec..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,97 +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; -static cl::String InputFilename("", "Specify input bytecode file", 0, "-"); -static cl::String ExtractFunc("func", "Specify function to extract", 0, "main"); - -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; - - // Remove the named function from the module. - M->getFunctionList().remove(I); - E = M->end(); - } 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().delete_all(); - - // 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; - } -}; +// InputFilename - The filename to read from. +static cl::opt +InputFilename(cl::Positional, cl::desc(""), + cl::init("-"), cl::value_desc("filename")); + +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")); int main(int argc, char **argv) { - cl::ParseCommandLineOptions(argc, argv, " llvm extractor\n"); + llvm_shutdown_obj X; // Call llvm_shutdown() on exit. + cl::ParseCommandLineOptions(argc, argv, "llvm extractor\n"); + sys::PrintStackTraceOnErrorSignal(); - std::auto_ptr M(ParseBytecodeFile(InputFilename)); + 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) { - std::cerr << "bytecode didn't read correctly.\n"; + cerr << argv[0] << ": bitcode didn't read correctly.\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. - // + // Figure out which function we should extract + GlobalVariable *G = ExtractGlobal.size() ? + M.get()->getNamedGlobal(ExtractGlobal) : 0; + + // Figure out which function we should extract + if (!ExtractFunc.size() && !ExtractGlobal.size()) ExtractFunc = "main"; + Function *F = M.get()->getFunction(ExtractFunc); + + 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 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()); - Passes.run(M.get()); + if (Out != &std::cout) + delete Out; return 0; }