X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fllvm-extract%2Fllvm-extract.cpp;h=2ed11c52b2b3a35b978a4f152e02555e5d11f46d;hb=30ba82933c433611e05b07ef95da36bba8721b8b;hp=a78d1fd9b994dcec878d5959f8087ad7a7a68aab;hpb=6a1359229df442842e9015dc6387a9114df83b4a;p=oota-llvm.git diff --git a/tools/llvm-extract/llvm-extract.cpp b/tools/llvm-extract/llvm-extract.cpp index a78d1fd9b99..2ed11c52b2b 100644 --- a/tools/llvm-extract/llvm-extract.cpp +++ b/tools/llvm-extract/llvm-extract.cpp @@ -1,107 +1,238 @@ +//===- 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. // //===----------------------------------------------------------------------===// +#include "llvm/LLVMContext.h" #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/Assembly/PrintModulePass.h" +#include "llvm/Bitcode/ReaderWriter.h" +#include "llvm/Transforms/IPO.h" +#include "llvm/Target/TargetData.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/IRReader.h" +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/PrettyStackTrace.h" +#include "llvm/Support/ToolOutputFile.h" +#include "llvm/Support/SystemUtils.h" +#include "llvm/Support/Signals.h" +#include "llvm/Support/Regex.h" +#include "llvm/ADT/SmallPtrSet.h" +#include "llvm/ADT/SetVector.h" #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; - - // Make sure it's globally accessable... - Named->setInternalLinkage(false); - - // 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; - } +// InputFilename - The filename to read from. +static cl::opt +InputFilename(cl::Positional, cl::desc(""), + cl::init("-"), cl::value_desc("filename")); - // 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; - } -}; +static cl::opt +OutputFilename("o", cl::desc("Specify output filename"), + cl::value_desc("filename"), cl::init("-")); + +static cl::opt +Force("f", cl::desc("Enable binary output on terminals")); + +static cl::opt +DeleteFn("delete", cl::desc("Delete specified Globals from Module")); + +// ExtractFuncs - The functions to extract from the module. +static cl::list +ExtractFuncs("func", cl::desc("Specify function to extract"), + cl::ZeroOrMore, cl::value_desc("function")); + +// ExtractRegExpFuncs - The functions, matched via regular expression, to +// extract from the module. +static cl::list +ExtractRegExpFuncs("rfunc", cl::desc("Specify function(s) to extract using a " + "regular expression"), + cl::ZeroOrMore, cl::value_desc("rfunction")); +// ExtractGlobals - The globals to extract from the module. +static cl::list +ExtractGlobals("glob", cl::desc("Specify global to extract"), + cl::ZeroOrMore, cl::value_desc("global")); + +// ExtractRegExpGlobals - The globals, matched via regular expression, to +// extract from the module... +static cl::list +ExtractRegExpGlobals("rglob", cl::desc("Specify global(s) to extract using a " + "regular expression"), + cl::ZeroOrMore, cl::value_desc("rglobal")); + +static cl::opt +OutputAssembly("S", + cl::desc("Write output as LLVM assembly"), cl::Hidden); int main(int argc, char **argv) { - cl::ParseCommandLineOptions(argc, argv, " llvm extractor\n"); + // Print a stack trace if we signal out. + sys::PrintStackTraceOnErrorSignal(); + PrettyStackTraceProgram X(argc, argv); + + LLVMContext &Context = getGlobalContext(); + llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. + cl::ParseCommandLineOptions(argc, argv, "llvm extractor\n"); + + // Use lazy loading, since we only care about selected global values. + SMDiagnostic Err; + std::auto_ptr M; + M.reset(getLazyIRFileModule(InputFilename, Err, Context)); - std::auto_ptr M(ParseBytecodeFile(InputFilename)); if (M.get() == 0) { - std::cerr << "bytecode didn't read correctly.\n"; + Err.print(argv[0], errs()); return 1; } - // In addition to just parsing the input from GCC, we also want to spiff it up - // a little bit. Do this now. - // + // Use SetVector to avoid duplicates. + SetVector GVs; + + // Figure out which globals we should extract. + for (size_t i = 0, e = ExtractGlobals.size(); i != e; ++i) { + GlobalValue *GV = M->getNamedGlobal(ExtractGlobals[i]); + if (!GV) { + errs() << argv[0] << ": program doesn't contain global named '" + << ExtractGlobals[i] << "'!\n"; + return 1; + } + GVs.insert(GV); + } + + // Extract globals via regular expression matching. + for (size_t i = 0, e = ExtractRegExpGlobals.size(); i != e; ++i) { + std::string Error; + Regex RegEx(ExtractRegExpGlobals[i]); + if (!RegEx.isValid(Error)) { + errs() << argv[0] << ": '" << ExtractRegExpGlobals[i] << "' " + "invalid regex: " << Error; + } + bool match = false; + for (Module::global_iterator GV = M->global_begin(), + E = M->global_end(); GV != E; GV++) { + if (RegEx.match(GV->getName())) { + GVs.insert(&*GV); + match = true; + } + } + if (!match) { + errs() << argv[0] << ": program doesn't contain global named '" + << ExtractRegExpGlobals[i] << "'!\n"; + return 1; + } + } + + // Figure out which functions we should extract. + for (size_t i = 0, e = ExtractFuncs.size(); i != e; ++i) { + GlobalValue *GV = M->getFunction(ExtractFuncs[i]); + if (!GV) { + errs() << argv[0] << ": program doesn't contain function named '" + << ExtractFuncs[i] << "'!\n"; + return 1; + } + GVs.insert(GV); + } + // Extract functions via regular expression matching. + for (size_t i = 0, e = ExtractRegExpFuncs.size(); i != e; ++i) { + std::string Error; + StringRef RegExStr = ExtractRegExpFuncs[i]; + Regex RegEx(RegExStr); + if (!RegEx.isValid(Error)) { + errs() << argv[0] << ": '" << ExtractRegExpFuncs[i] << "' " + "invalid regex: " << Error; + } + bool match = false; + for (Module::iterator F = M->begin(), E = M->end(); F != E; + F++) { + if (RegEx.match(F->getName())) { + GVs.insert(&*F); + match = true; + } + } + if (!match) { + errs() << argv[0] << ": program doesn't contain global named '" + << ExtractRegExpFuncs[i] << "'!\n"; + return 1; + } + } + + // Materialize requisite global values. + if (!DeleteFn) + for (size_t i = 0, e = GVs.size(); i != e; ++i) { + GlobalValue *GV = GVs[i]; + if (GV->isMaterializable()) { + std::string ErrInfo; + if (GV->Materialize(&ErrInfo)) { + errs() << argv[0] << ": error reading input: " << ErrInfo << "\n"; + return 1; + } + } + } + else { + // Deleting. Materialize every GV that's *not* in GVs. + SmallPtrSet GVSet(GVs.begin(), GVs.end()); + for (Module::global_iterator I = M->global_begin(), E = M->global_end(); + I != E; ++I) { + GlobalVariable *G = I; + if (!GVSet.count(G) && G->isMaterializable()) { + std::string ErrInfo; + if (G->Materialize(&ErrInfo)) { + errs() << argv[0] << ": error reading input: " << ErrInfo << "\n"; + return 1; + } + } + } + for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) { + Function *F = I; + if (!GVSet.count(F) && F->isMaterializable()) { + std::string ErrInfo; + if (F->Materialize(&ErrInfo)) { + errs() << argv[0] << ": error reading input: " << ErrInfo << "\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 + + std::vector Gvs(GVs.begin(), GVs.end()); + + Passes.add(createGVExtractionPass(Gvs, DeleteFn)); + if (!DeleteFn) + Passes.add(createGlobalDCEPass()); // Delete unreachable globals + Passes.add(createStripDeadDebugInfoPass()); // Remove dead debug info + Passes.add(createStripDeadPrototypesPass()); // Remove dead func decls + + std::string ErrorInfo; + tool_output_file Out(OutputFilename.c_str(), ErrorInfo, + raw_fd_ostream::F_Binary); + if (!ErrorInfo.empty()) { + errs() << ErrorInfo << '\n'; + return 1; + } + + if (OutputAssembly) + Passes.add(createPrintModulePass(&Out.os())); + else if (Force || !CheckBitcodeOutputToConsole(Out.os(), true)) + Passes.add(createBitcodeWriterPass(Out.os())); + + Passes.run(*M.get()); + + // Declare success. + Out.keep(); - Passes.run(M.get()); return 0; }