tools/llvm-lto/llvm-lto.cpp

   1 //===-- llvm-lto: a simple command-line program to link modules with LTO --===//
   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 program takes in a list of bitcode files, links them, performs link-time
  11 // optimization, and outputs an object file.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/ADT/StringSet.h"
  16 #include "llvm/CodeGen/CommandFlags.h"
  17 #include "llvm/LTO/LTOCodeGenerator.h"
  18 #include "llvm/LTO/LTOModule.h"
  19 #include "llvm/Support/CommandLine.h"
  20 #include "llvm/Support/ManagedStatic.h"
  21 #include "llvm/Support/PrettyStackTrace.h"
  22 #include "llvm/Support/Signals.h"
  23 #include "llvm/Support/TargetSelect.h"
  24 #include "llvm/Support/raw_ostream.h"
  25
  26 using namespace llvm;
  27
  28 static cl::opt<bool>
  29 DisableOpt("disable-opt", cl::init(false),
  30   cl::desc("Do not run any optimization passes"));
  31
  32 static cl::opt<bool>
  33 DisableInline("disable-inlining", cl::init(false),
  34   cl::desc("Do not run the inliner pass"));
  35
  36 static cl::opt<bool>
  37 DisableGVNLoadPRE("disable-gvn-loadpre", cl::init(false),
  38   cl::desc("Do not run the GVN load PRE pass"));
  39
  40 static cl::list<std::string>
  41 InputFilenames(cl::Positional, cl::OneOrMore,
  42   cl::desc("<input bitcode files>"));
  43
  44 static cl::opt<std::string>
  45 OutputFilename("o", cl::init(""),
  46   cl::desc("Override output filename"),
  47   cl::value_desc("filename"));
  48
  49 static cl::list<std::string>
  50 ExportedSymbols("exported-symbol",
  51   cl::desc("Symbol to export from the resulting object file"),
  52   cl::ZeroOrMore);
  53
  54 static cl::list<std::string>
  55 DSOSymbols("dso-symbol",
  56   cl::desc("Symbol to put in the symtab in the resulting dso"),
  57   cl::ZeroOrMore);
  58
  59 namespace {
  60 struct ModuleInfo {
  61   std::vector<bool> CanBeHidden;
  62 };
  63 }
  64
  65 int main(int argc, char **argv) {
  66   // Print a stack trace if we signal out.
  67   sys::PrintStackTraceOnErrorSignal();
  68   PrettyStackTraceProgram X(argc, argv);
  69
  70   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
  71   cl::ParseCommandLineOptions(argc, argv, "llvm LTO linker\n");
  72
  73   // Initialize the configured targets.
  74   InitializeAllTargets();
  75   InitializeAllTargetMCs();
  76   InitializeAllAsmPrinters();
  77   InitializeAllAsmParsers();
  78
  79   // set up the TargetOptions for the machine
  80   TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
  81
  82   unsigned BaseArg = 0;
  83
  84   LTOCodeGenerator CodeGen;
  85
  86   switch (RelocModel) {
  87   case Reloc::Static:
  88     CodeGen.setCodePICModel(LTO_CODEGEN_PIC_MODEL_STATIC);
  89     break;
  90   case Reloc::PIC_:
  91     CodeGen.setCodePICModel(LTO_CODEGEN_PIC_MODEL_DYNAMIC);
  92     break;
  93   case Reloc::DynamicNoPIC:
  94     CodeGen.setCodePICModel(LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC);
  95     break;
  96   default:
  97     CodeGen.setCodePICModel(LTO_CODEGEN_PIC_MODEL_DEFAULT);
  98   }
  99
 100   CodeGen.setDebugInfo(LTO_DEBUG_MODEL_DWARF);
 101   CodeGen.setTargetOptions(Options);
 102
 103   llvm::StringSet<llvm::MallocAllocator> DSOSymbolsSet;
 104   for (unsigned i = 0; i < DSOSymbols.size(); ++i)
 105     DSOSymbolsSet.insert(DSOSymbols[i]);
 106
 107   std::vector<std::string> KeptDSOSyms;
 108
 109   for (unsigned i = BaseArg; i < InputFilenames.size(); ++i) {
 110     std::string error;
 111     std::unique_ptr<LTOModule> Module(
 112         LTOModule::makeLTOModule(InputFilenames[i].c_str(), Options, error));
 113     if (!error.empty()) {
 114       errs() << argv[0] << ": error loading file '" << InputFilenames[i]
 115              << "': " << error << "\n";
 116       return 1;
 117     }
 118
 119
 120     if (!CodeGen.addModule(Module.get(), error)) {
 121       errs() << argv[0] << ": error adding file '" << InputFilenames[i]
 122              << "': " << error << "\n";
 123       return 1;
 124     }
 125
 126     unsigned NumSyms = Module->getSymbolCount();
 127     for (unsigned I = 0; I < NumSyms; ++I) {
 128       StringRef Name = Module->getSymbolName(I);
 129       if (!DSOSymbolsSet.count(Name))
 130         continue;
 131       lto_symbol_attributes Attrs = Module->getSymbolAttributes(I);
 132       unsigned Scope = Attrs & LTO_SYMBOL_SCOPE_MASK;
 133       if (Scope != LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN)
 134         KeptDSOSyms.push_back(Name);
 135     }
 136   }
 137
 138   // Add all the exported symbols to the table of symbols to preserve.
 139   for (unsigned i = 0; i < ExportedSymbols.size(); ++i)
 140     CodeGen.addMustPreserveSymbol(ExportedSymbols[i].c_str());
 141
 142   // Add all the dso symbols to the table of symbols to expose.
 143   for (unsigned i = 0; i < KeptDSOSyms.size(); ++i)
 144     CodeGen.addMustPreserveSymbol(KeptDSOSyms[i].c_str());
 145
 146   std::string attrs;
 147   for (unsigned i = 0; i < MAttrs.size(); ++i) {
 148     if (i > 0)
 149       attrs.append(",");
 150     attrs.append(MAttrs[i]);
 151   }
 152
 153   if (!attrs.empty())
 154     CodeGen.setAttr(attrs.c_str());
 155
 156   if (!OutputFilename.empty()) {
 157     size_t len = 0;
 158     std::string ErrorInfo;
 159     const void *Code = CodeGen.compile(&len, DisableOpt, DisableInline,
 160                                        DisableGVNLoadPRE, ErrorInfo);
 161     if (!Code) {
 162       errs() << argv[0]
 163              << ": error compiling the code: " << ErrorInfo << "\n";
 164       return 1;
 165     }
 166
 167     raw_fd_ostream FileStream(OutputFilename.c_str(), ErrorInfo,
 168                               sys::fs::F_None);
 169     if (!ErrorInfo.empty()) {
 170       errs() << argv[0] << ": error opening the file '" << OutputFilename
 171              << "': " << ErrorInfo << "\n";
 172       return 1;
 173     }
 174
 175     FileStream.write(reinterpret_cast<const char *>(Code), len);
 176   } else {
 177     std::string ErrorInfo;
 178     const char *OutputName = nullptr;
 179     if (!CodeGen.compile_to_file(&OutputName, DisableOpt, DisableInline,
 180                                  DisableGVNLoadPRE, ErrorInfo)) {
 181       errs() << argv[0]
 182              << ": error compiling the code: " << ErrorInfo
 183              << "\n";
 184       return 1;
 185     }
 186
 187     outs() << "Wrote native object file '" << OutputName << "'\n";
 188   }
 189
 190   return 0;
 191 }