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