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/raw_ostream.h"
  24 #include "llvm/Support/TargetSelect.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;
  81   Options.LessPreciseFPMADOption = EnableFPMAD;
  82   Options.NoFramePointerElim = DisableFPElim;
  83   Options.AllowFPOpFusion = FuseFPOps;
  84   Options.UnsafeFPMath = EnableUnsafeFPMath;
  85   Options.NoInfsFPMath = EnableNoInfsFPMath;
  86   Options.NoNaNsFPMath = EnableNoNaNsFPMath;
  87   Options.HonorSignDependentRoundingFPMathOption =
  88     EnableHonorSignDependentRoundingFPMath;
  89   Options.UseSoftFloat = GenerateSoftFloatCalls;
  90   if (FloatABIForCalls != FloatABI::Default)
  91     Options.FloatABIType = FloatABIForCalls;
  92   Options.NoZerosInBSS = DontPlaceZerosInBSS;
  93   Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt;
  94   Options.DisableTailCalls = DisableTailCalls;
  95   Options.StackAlignmentOverride = OverrideStackAlignment;
  96   Options.TrapFuncName = TrapFuncName;
  97   Options.PositionIndependentExecutable = EnablePIE;
  98   Options.EnableSegmentedStacks = SegmentedStacks;
  99   Options.UseInitArray = UseInitArray;
 100
 101   unsigned BaseArg = 0;
 102
 103   LTOCodeGenerator CodeGen;
 104
 105   CodeGen.setCodePICModel(LTO_CODEGEN_PIC_MODEL_DYNAMIC);
 106   CodeGen.setDebugInfo(LTO_DEBUG_MODEL_DWARF);
 107   CodeGen.setTargetOptions(Options);
 108
 109   llvm::StringSet<llvm::MallocAllocator> DSOSymbolsSet;
 110   for (unsigned i = 0; i < DSOSymbols.size(); ++i)
 111     DSOSymbolsSet.insert(DSOSymbols[i]);
 112
 113   std::vector<std::string> KeptDSOSyms;
 114
 115   for (unsigned i = BaseArg; i < InputFilenames.size(); ++i) {
 116     std::string error;
 117     OwningPtr<LTOModule> Module(LTOModule::makeLTOModule(InputFilenames[i].c_str(),
 118                                                          Options, error));
 119     if (!error.empty()) {
 120       errs() << argv[0] << ": error loading file '" << InputFilenames[i]
 121              << "': " << error << "\n";
 122       return 1;
 123     }
 124
 125
 126     if (!CodeGen.addModule(Module.get(), error)) {
 127       errs() << argv[0] << ": error adding file '" << InputFilenames[i]
 128              << "': " << error << "\n";
 129       return 1;
 130     }
 131
 132     unsigned NumSyms = Module->getSymbolCount();
 133     for (unsigned I = 0; I < NumSyms; ++I) {
 134       StringRef Name = Module->getSymbolName(I);
 135       if (!DSOSymbolsSet.count(Name))
 136         continue;
 137       lto_symbol_attributes Attrs = Module->getSymbolAttributes(I);
 138       unsigned Scope = Attrs & LTO_SYMBOL_SCOPE_MASK;
 139       if (Scope != LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN)
 140         KeptDSOSyms.push_back(Name);
 141     }
 142   }
 143
 144   // Add all the exported symbols to the table of symbols to preserve.
 145   for (unsigned i = 0; i < ExportedSymbols.size(); ++i)
 146     CodeGen.addMustPreserveSymbol(ExportedSymbols[i].c_str());
 147
 148   // Add all the dso symbols to the table of symbols to expose.
 149   for (unsigned i = 0; i < KeptDSOSyms.size(); ++i)
 150     CodeGen.addMustPreserveSymbol(KeptDSOSyms[i].c_str());
 151
 152   if (!OutputFilename.empty()) {
 153     size_t len = 0;
 154     std::string ErrorInfo;
 155     const void *Code = CodeGen.compile(&len, DisableOpt, DisableInline,
 156                                        DisableGVNLoadPRE, ErrorInfo);
 157     if (Code == NULL) {
 158       errs() << argv[0]
 159              << ": error compiling the code: " << ErrorInfo << "\n";
 160       return 1;
 161     }
 162
 163     raw_fd_ostream FileStream(OutputFilename.c_str(), ErrorInfo,
 164                               sys::fs::F_Binary);
 165     if (!ErrorInfo.empty()) {
 166       errs() << argv[0] << ": error opening the file '" << OutputFilename
 167              << "': " << ErrorInfo << "\n";
 168       return 1;
 169     }
 170
 171     FileStream.write(reinterpret_cast<const char *>(Code), len);
 172   } else {
 173     std::string ErrorInfo;
 174     const char *OutputName = NULL;
 175     if (!CodeGen.compile_to_file(&OutputName, DisableOpt, DisableInline,
 176                                  DisableGVNLoadPRE, ErrorInfo)) {
 177       errs() << argv[0]
 178              << ": error compiling the code: " << ErrorInfo
 179              << "\n";
 180       return 1;
 181     }
 182
 183     outs() << "Wrote native object file '" << OutputName << "'\n";
 184   }
 185
 186   return 0;
 187 }