X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fllvm-extract%2Fllvm-extract.cpp;h=8da63fb1797ea7b212f042f26dfc44acfdb0b776;hb=12af22e8cc217827cf4f118b0f5e4ebbda9925ae;hp=e904beac80c599de71fad7e13730c83df1b8a477;hpb=50e3a20b54be93fce84f70075730b8d38c0318d7;p=oota-llvm.git diff --git a/tools/llvm-extract/llvm-extract.cpp b/tools/llvm-extract/llvm-extract.cpp index e904beac80c..8da63fb1797 100644 --- a/tools/llvm-extract/llvm-extract.cpp +++ b/tools/llvm-extract/llvm-extract.cpp @@ -1,111 +1,281 @@ +//===- 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/Module.h" +#include "llvm/ADT/SetVector.h" +#include "llvm/ADT/SmallPtrSet.h" +#include "llvm/Bitcode/BitcodeWriterPass.h" +#include "llvm/IR/DataLayout.h" +#include "llvm/IR/IRPrintingPasses.h" +#include "llvm/IR/LLVMContext.h" +#include "llvm/IR/Module.h" +#include "llvm/IRReader/IRReader.h" #include "llvm/PassManager.h" -#include "llvm/Bytecode/Reader.h" -#include "llvm/Bytecode/WriteBytecodePass.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/FileSystem.h" +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/PrettyStackTrace.h" +#include "llvm/Support/Regex.h" +#include "llvm/Support/Signals.h" +#include "llvm/Support/SourceMgr.h" +#include "llvm/Support/SystemUtils.h" +#include "llvm/Support/ToolOutputFile.h" #include "llvm/Transforms/IPO.h" -#include "Support/CommandLine.h" #include +using namespace llvm; // InputFilename - The filename to read from. static cl::opt -InputFilename(cl::Positional, cl::desc(""), +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"), - cl::value_desc("function")); - - -struct FunctionExtractorPass : public Pass { - 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; +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")); + +// ExtractAlias - The alias to extract from the module. +static cl::list +ExtractAliases("alias", cl::desc("Specify alias to extract"), + cl::ZeroOrMore, cl::value_desc("alias")); + + +// ExtractRegExpAliases - The aliases, matched via regular expression, to +// extract from the module. +static cl::list +ExtractRegExpAliases("ralias", cl::desc("Specify alias(es) to extract using a " + "regular expression"), + cl::ZeroOrMore, cl::value_desc("ralias")); + +// 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) { + // 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::unique_ptr M = getLazyIRFileModule(InputFilename, Err, Context); + + if (!M.get()) { + Err.print(argv[0], errs()); + return 1; + } + + // Use SetVector to avoid duplicates. + SetVector GVs; + + // Figure out which aliases we should extract. + for (size_t i = 0, e = ExtractAliases.size(); i != e; ++i) { + GlobalAlias *GA = M->getNamedAlias(ExtractAliases[i]); + if (!GA) { + errs() << argv[0] << ": program doesn't contain alias named '" + << ExtractAliases[i] << "'!\n"; + return 1; + } + GVs.insert(GA); + } + + // Extract aliases via regular expression matching. + for (size_t i = 0, e = ExtractRegExpAliases.size(); i != e; ++i) { + std::string Error; + Regex RegEx(ExtractRegExpAliases[i]); + if (!RegEx.isValid(Error)) { + errs() << argv[0] << ": '" << ExtractRegExpAliases[i] << "' " + "invalid regex: " << Error; + } + bool match = false; + for (Module::alias_iterator GA = M->alias_begin(), E = M->alias_end(); + GA != E; GA++) { + if (RegEx.match(GA->getName())) { + GVs.insert(&*GA); + match = true; + } + } + if (!match) { + errs() << argv[0] << ": program doesn't contain global named '" + << ExtractRegExpAliases[i] << "'!\n"; + return 1; + } + } + + // 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 (auto &GV : M->globals()) { + 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; + } + } - // 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); + // 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; } - - // 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; + } + 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 (auto &G : M->globals()) { + if (!GVSet.count(&G) && G.isMaterializable()) { + std::string ErrInfo; + if (G.Materialize(&ErrInfo)) { + errs() << argv[0] << ": error reading input: " << ErrInfo << "\n"; + return 1; + } + } + } + for (auto &F : *M) { + if (!GVSet.count(&F) && F.isMaterializable()) { + std::string ErrInfo; + if (F.Materialize(&ErrInfo)) { + errs() << argv[0] << ": error reading input: " << ErrInfo << "\n"; + return 1; + } + } + } + } -static RegisterPass X("extract", "Function Extractor"); + // 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 DataLayoutPass(M.get())); // Use correct DataLayout + std::vector Gvs(GVs.begin(), GVs.end()); -int main(int argc, char **argv) { - cl::ParseCommandLineOptions(argc, argv, " llvm extractor\n"); + 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::auto_ptr M(ParseBytecodeFile(InputFilename)); - if (M.get() == 0) { - std::cerr << argv[0] << ": bytecode didn't read correctly.\n"; + std::error_code EC; + tool_output_file Out(OutputFilename, EC, sys::fs::F_None); + if (EC) { + errs() << EC.message() << '\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. - // - PassManager Passes; - Passes.add(new FunctionExtractorPass()); - Passes.add(createGlobalDCEPass()); // Delete unreachable globals - Passes.add(createConstantMergePass()); // Merge dup global constants - Passes.add(createDeadTypeEliminationPass()); // Remove dead types... - Passes.add(new WriteBytecodePass(&std::cout)); // Write bytecode to file... + 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(); + return 0; }