tools/llvm-extract/llvm-extract.cpp

   1 //===- llvm-extract.cpp - LLVM function extraction utility ----------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This utility changes the input module to only contain a single function,
  11 // which is primarily used for debugging transformations.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/ADT/SetVector.h"
  16 #include "llvm/ADT/SmallPtrSet.h"
  17 #include "llvm/Bitcode/BitcodeWriterPass.h"
  18 #include "llvm/IR/DataLayout.h"
  19 #include "llvm/IR/IRPrintingPasses.h"
  20 #include "llvm/IR/LLVMContext.h"
  21 #include "llvm/IR/Module.h"
  22 #include "llvm/IRReader/IRReader.h"
  23 #include "llvm/PassManager.h"
  24 #include "llvm/Support/CommandLine.h"
  25 #include "llvm/Support/FileSystem.h"
  26 #include "llvm/Support/ManagedStatic.h"
  27 #include "llvm/Support/PrettyStackTrace.h"
  28 #include "llvm/Support/Regex.h"
  29 #include "llvm/Support/Signals.h"
  30 #include "llvm/Support/SourceMgr.h"
  31 #include "llvm/Support/SystemUtils.h"
  32 #include "llvm/Support/ToolOutputFile.h"
  33 #include "llvm/Transforms/IPO.h"
  34 #include <memory>
  35 using namespace llvm;
  36
  37 // InputFilename - The filename to read from.
  38 static cl::opt<std::string>
  39 InputFilename(cl::Positional, cl::desc("<input bitcode file>"),
  40               cl::init("-"), cl::value_desc("filename"));
  41
  42 static cl::opt<std::string>
  43 OutputFilename("o", cl::desc("Specify output filename"),
  44                cl::value_desc("filename"), cl::init("-"));
  45
  46 static cl::opt<bool>
  47 Force("f", cl::desc("Enable binary output on terminals"));
  48
  49 static cl::opt<bool>
  50 DeleteFn("delete", cl::desc("Delete specified Globals from Module"));
  51
  52 // ExtractFuncs - The functions to extract from the module.
  53 static cl::list<std::string>
  54 ExtractFuncs("func", cl::desc("Specify function to extract"),
  55              cl::ZeroOrMore, cl::value_desc("function"));
  56
  57 // ExtractRegExpFuncs - The functions, matched via regular expression, to
  58 // extract from the module.
  59 static cl::list<std::string>
  60 ExtractRegExpFuncs("rfunc", cl::desc("Specify function(s) to extract using a "
  61                                      "regular expression"),
  62                    cl::ZeroOrMore, cl::value_desc("rfunction"));
  63
  64 // ExtractAlias - The alias to extract from the module.
  65 static cl::list<std::string>
  66 ExtractAliases("alias", cl::desc("Specify alias to extract"),
  67                cl::ZeroOrMore, cl::value_desc("alias"));
  68
  69
  70 // ExtractRegExpAliases - The aliases, matched via regular expression, to
  71 // extract from the module.
  72 static cl::list<std::string>
  73 ExtractRegExpAliases("ralias", cl::desc("Specify alias(es) to extract using a "
  74                                         "regular expression"),
  75                      cl::ZeroOrMore, cl::value_desc("ralias"));
  76
  77 // ExtractGlobals - The globals to extract from the module.
  78 static cl::list<std::string>
  79 ExtractGlobals("glob", cl::desc("Specify global to extract"),
  80                cl::ZeroOrMore, cl::value_desc("global"));
  81
  82 // ExtractRegExpGlobals - The globals, matched via regular expression, to
  83 // extract from the module...
  84 static cl::list<std::string>
  85 ExtractRegExpGlobals("rglob", cl::desc("Specify global(s) to extract using a "
  86                                        "regular expression"),
  87                      cl::ZeroOrMore, cl::value_desc("rglobal"));
  88
  89 static cl::opt<bool>
  90 OutputAssembly("S",
  91                cl::desc("Write output as LLVM assembly"), cl::Hidden);
  92
  93 int main(int argc, char **argv) {
  94   // Print a stack trace if we signal out.
  95   sys::PrintStackTraceOnErrorSignal();
  96   PrettyStackTraceProgram X(argc, argv);
  97
  98   LLVMContext &Context = getGlobalContext();
  99   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
 100   cl::ParseCommandLineOptions(argc, argv, "llvm extractor\n");
 101
 102   // Use lazy loading, since we only care about selected global values.
 103   SMDiagnostic Err;
 104   std::unique_ptr<Module> M;
 105   M.reset(getLazyIRFileModule(InputFilename, Err, Context));
 106
 107   if (!M.get()) {
 108     Err.print(argv[0], errs());
 109     return 1;
 110   }
 111
 112   // Use SetVector to avoid duplicates.
 113   SetVector<GlobalValue *> GVs;
 114
 115   // Figure out which aliases we should extract.
 116   for (size_t i = 0, e = ExtractAliases.size(); i != e; ++i) {
 117     GlobalAlias *GA = M->getNamedAlias(ExtractAliases[i]);
 118     if (!GA) {
 119       errs() << argv[0] << ": program doesn't contain alias named '"
 120              << ExtractAliases[i] << "'!\n";
 121       return 1;
 122     }
 123     GVs.insert(GA);
 124   }
 125
 126   // Extract aliases via regular expression matching.
 127   for (size_t i = 0, e = ExtractRegExpAliases.size(); i != e; ++i) {
 128     std::string Error;
 129     Regex RegEx(ExtractRegExpAliases[i]);
 130     if (!RegEx.isValid(Error)) {
 131       errs() << argv[0] << ": '" << ExtractRegExpAliases[i] << "' "
 132         "invalid regex: " << Error;
 133     }
 134     bool match = false;
 135     for (Module::alias_iterator GA = M->alias_begin(), E = M->alias_end();
 136          GA != E; GA++) {
 137       if (RegEx.match(GA->getName())) {
 138         GVs.insert(&*GA);
 139         match = true;
 140       }
 141     }
 142     if (!match) {
 143       errs() << argv[0] << ": program doesn't contain global named '"
 144              << ExtractRegExpAliases[i] << "'!\n";
 145       return 1;
 146     }
 147   }
 148
 149   // Figure out which globals we should extract.
 150   for (size_t i = 0, e = ExtractGlobals.size(); i != e; ++i) {
 151     GlobalValue *GV = M->getNamedGlobal(ExtractGlobals[i]);
 152     if (!GV) {
 153       errs() << argv[0] << ": program doesn't contain global named '"
 154              << ExtractGlobals[i] << "'!\n";
 155       return 1;
 156     }
 157     GVs.insert(GV);
 158   }
 159
 160   // Extract globals via regular expression matching.
 161   for (size_t i = 0, e = ExtractRegExpGlobals.size(); i != e; ++i) {
 162     std::string Error;
 163     Regex RegEx(ExtractRegExpGlobals[i]);
 164     if (!RegEx.isValid(Error)) {
 165       errs() << argv[0] << ": '" << ExtractRegExpGlobals[i] << "' "
 166         "invalid regex: " << Error;
 167     }
 168     bool match = false;
 169     for (Module::global_iterator GV = M->global_begin(),
 170            E = M->global_end(); GV != E; GV++) {
 171       if (RegEx.match(GV->getName())) {
 172         GVs.insert(&*GV);
 173         match = true;
 174       }
 175     }
 176     if (!match) {
 177       errs() << argv[0] << ": program doesn't contain global named '"
 178              << ExtractRegExpGlobals[i] << "'!\n";
 179       return 1;
 180     }
 181   }
 182
 183   // Figure out which functions we should extract.
 184   for (size_t i = 0, e = ExtractFuncs.size(); i != e; ++i) {
 185     GlobalValue *GV = M->getFunction(ExtractFuncs[i]);
 186     if (!GV) {
 187       errs() << argv[0] << ": program doesn't contain function named '"
 188              << ExtractFuncs[i] << "'!\n";
 189       return 1;
 190     }
 191     GVs.insert(GV);
 192   }
 193   // Extract functions via regular expression matching.
 194   for (size_t i = 0, e = ExtractRegExpFuncs.size(); i != e; ++i) {
 195     std::string Error;
 196     StringRef RegExStr = ExtractRegExpFuncs[i];
 197     Regex RegEx(RegExStr);
 198     if (!RegEx.isValid(Error)) {
 199       errs() << argv[0] << ": '" << ExtractRegExpFuncs[i] << "' "
 200         "invalid regex: " << Error;
 201     }
 202     bool match = false;
 203     for (Module::iterator F = M->begin(), E = M->end(); F != E;
 204          F++) {
 205       if (RegEx.match(F->getName())) {
 206         GVs.insert(&*F);
 207         match = true;
 208       }
 209     }
 210     if (!match) {
 211       errs() << argv[0] << ": program doesn't contain global named '"
 212              << ExtractRegExpFuncs[i] << "'!\n";
 213       return 1;
 214     }
 215   }
 216
 217   // Materialize requisite global values.
 218   if (!DeleteFn)
 219     for (size_t i = 0, e = GVs.size(); i != e; ++i) {
 220       GlobalValue *GV = GVs[i];
 221       if (GV->isMaterializable()) {
 222         std::string ErrInfo;
 223         if (GV->Materialize(&ErrInfo)) {
 224           errs() << argv[0] << ": error reading input: " << ErrInfo << "\n";
 225           return 1;
 226         }
 227       }
 228     }
 229   else {
 230     // Deleting. Materialize every GV that's *not* in GVs.
 231     SmallPtrSet<GlobalValue *, 8> GVSet(GVs.begin(), GVs.end());
 232     for (Module::global_iterator I = M->global_begin(), E = M->global_end();
 233          I != E; ++I) {
 234       GlobalVariable *G = I;
 235       if (!GVSet.count(G) && G->isMaterializable()) {
 236         std::string ErrInfo;
 237         if (G->Materialize(&ErrInfo)) {
 238           errs() << argv[0] << ": error reading input: " << ErrInfo << "\n";
 239           return 1;
 240         }
 241       }
 242     }
 243     for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) {
 244       Function *F = I;
 245       if (!GVSet.count(F) && F->isMaterializable()) {
 246         std::string ErrInfo;
 247         if (F->Materialize(&ErrInfo)) {
 248           errs() << argv[0] << ": error reading input: " << ErrInfo << "\n";
 249           return 1;
 250         }
 251       }
 252     }
 253   }
 254
 255   // In addition to deleting all other functions, we also want to spiff it
 256   // up a little bit.  Do this now.
 257   PassManager Passes;
 258   Passes.add(new DataLayoutPass(M.get())); // Use correct DataLayout
 259
 260   std::vector<GlobalValue*> Gvs(GVs.begin(), GVs.end());
 261
 262   Passes.add(createGVExtractionPass(Gvs, DeleteFn));
 263   if (!DeleteFn)
 264     Passes.add(createGlobalDCEPass());           // Delete unreachable globals
 265   Passes.add(createStripDeadDebugInfoPass());    // Remove dead debug info
 266   Passes.add(createStripDeadPrototypesPass());   // Remove dead func decls
 267
 268   std::string ErrorInfo;
 269   tool_output_file Out(OutputFilename.c_str(), ErrorInfo, sys::fs::F_None);
 270   if (!ErrorInfo.empty()) {
 271     errs() << ErrorInfo << '\n';
 272     return 1;
 273   }
 274
 275   if (OutputAssembly)
 276     Passes.add(createPrintModulePass(Out.os()));
 277   else if (Force || !CheckBitcodeOutputToConsole(Out.os(), true))
 278     Passes.add(createBitcodeWriterPass(Out.os()));
 279
 280   Passes.run(*M.get());
 281
 282   // Declare success.
 283   Out.keep();
 284
 285   return 0;
 286 }