contrib/llvm-project/lld/ELF/LTO.cpp

   1 //===- LTO.cpp ------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "LTO.h"
  10 #include "Config.h"
  11 #include "InputFiles.h"
  12 #include "LinkerScript.h"
  13 #include "SymbolTable.h"
  14 #include "Symbols.h"
  15 #include "lld/Common/Args.h"
  16 #include "lld/Common/ErrorHandler.h"
  17 #include "lld/Common/TargetOptionsCommandFlags.h"
  18 #include "llvm/ADT/STLExtras.h"
  19 #include "llvm/ADT/SmallString.h"
  20 #include "llvm/ADT/StringRef.h"
  21 #include "llvm/ADT/Twine.h"
  22 #include "llvm/BinaryFormat/ELF.h"
  23 #include "llvm/Bitcode/BitcodeReader.h"
  24 #include "llvm/Bitcode/BitcodeWriter.h"
  25 #include "llvm/IR/DiagnosticPrinter.h"
  26 #include "llvm/LTO/Caching.h"
  27 #include "llvm/LTO/Config.h"
  28 #include "llvm/LTO/LTO.h"
  29 #include "llvm/Object/SymbolicFile.h"
  30 #include "llvm/Support/CodeGen.h"
  31 #include "llvm/Support/Error.h"
  32 #include "llvm/Support/FileSystem.h"
  33 #include "llvm/Support/MemoryBuffer.h"
  34 #include <algorithm>
  35 #include <cstddef>
  36 #include <memory>
  37 #include <string>
  38 #include <system_error>
  39 #include <vector>
  40
  41 using namespace llvm;
  42 using namespace llvm::object;
  43 using namespace llvm::ELF;
  44 using namespace lld;
  45 using namespace lld::elf;
  46
  47 // Creates an empty file to store a list of object files for final
  48 // linking of distributed ThinLTO.
  49 static std::unique_ptr<raw_fd_ostream> openFile(StringRef file) {
  50   std::error_code ec;
  51   auto ret =
  52       std::make_unique<raw_fd_ostream>(file, ec, sys::fs::OpenFlags::OF_None);
  53   if (ec) {
  54     error("cannot open " + file + ": " + ec.message());
  55     return nullptr;
  56   }
  57   return ret;
  58 }
  59
  60 static std::string getThinLTOOutputFile(StringRef modulePath) {
  61   return lto::getThinLTOOutputFile(
  62       std::string(modulePath), std::string(config->thinLTOPrefixReplace.first),
  63       std::string(config->thinLTOPrefixReplace.second));
  64 }
  65
  66 static lto::Config createConfig() {
  67   lto::Config c;
  68
  69   // LLD supports the new relocations and address-significance tables.
  70   c.Options = initTargetOptionsFromCodeGenFlags();
  71   c.Options.RelaxELFRelocations = true;
  72   c.Options.EmitAddrsig = true;
  73
  74   // Always emit a section per function/datum with LTO.
  75   c.Options.FunctionSections = true;
  76   c.Options.DataSections = true;
  77
  78   // Check if basic block sections must be used.
  79   // Allowed values for --lto-basicblock-sections are "all", "labels",
  80   // "<file name specifying basic block ids>", or none.  This is the equivalent
  81   // of -fbasic-block-sections= flag in clang.
  82   if (!config->ltoBasicBlockSections.empty()) {
  83     if (config->ltoBasicBlockSections == "all") {
  84       c.Options.BBSections = BasicBlockSection::All;
  85     } else if (config->ltoBasicBlockSections == "labels") {
  86       c.Options.BBSections = BasicBlockSection::Labels;
  87     } else if (config->ltoBasicBlockSections == "none") {
  88       c.Options.BBSections = BasicBlockSection::None;
  89     } else {
  90       ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
  91           MemoryBuffer::getFile(config->ltoBasicBlockSections.str());
  92       if (!MBOrErr) {
  93         error("cannot open " + config->ltoBasicBlockSections + ":" +
  94               MBOrErr.getError().message());
  95       } else {
  96         c.Options.BBSectionsFuncListBuf = std::move(*MBOrErr);
  97       }
  98       c.Options.BBSections = BasicBlockSection::List;
  99     }
 100   }
 101
 102   c.Options.UniqueBasicBlockSectionNames =
 103       config->ltoUniqueBasicBlockSectionNames;
 104
 105   if (auto relocModel = getRelocModelFromCMModel())
 106     c.RelocModel = *relocModel;
 107   else if (config->relocatable)
 108     c.RelocModel = None;
 109   else if (config->isPic)
 110     c.RelocModel = Reloc::PIC_;
 111   else
 112     c.RelocModel = Reloc::Static;
 113
 114   c.CodeModel = getCodeModelFromCMModel();
 115   c.DisableVerify = config->disableVerify;
 116   c.DiagHandler = diagnosticHandler;
 117   c.OptLevel = config->ltoo;
 118   c.CPU = getCPUStr();
 119   c.MAttrs = getMAttrs();
 120   c.CGOptLevel = args::getCGOptLevel(config->ltoo);
 121
 122   c.PTO.LoopVectorization = c.OptLevel > 1;
 123   c.PTO.SLPVectorization = c.OptLevel > 1;
 124
 125   // Set up a custom pipeline if we've been asked to.
 126   c.OptPipeline = std::string(config->ltoNewPmPasses);
 127   c.AAPipeline = std::string(config->ltoAAPipeline);
 128
 129   // Set up optimization remarks if we've been asked to.
 130   c.RemarksFilename = std::string(config->optRemarksFilename);
 131   c.RemarksPasses = std::string(config->optRemarksPasses);
 132   c.RemarksWithHotness = config->optRemarksWithHotness;
 133   c.RemarksFormat = std::string(config->optRemarksFormat);
 134
 135   c.SampleProfile = std::string(config->ltoSampleProfile);
 136   c.UseNewPM = config->ltoNewPassManager;
 137   c.DebugPassManager = config->ltoDebugPassManager;
 138   c.DwoDir = std::string(config->dwoDir);
 139
 140   c.HasWholeProgramVisibility = config->ltoWholeProgramVisibility;
 141   c.AlwaysEmitRegularLTOObj = !config->ltoObjPath.empty();
 142
 143   for (const llvm::StringRef &name : config->thinLTOModulesToCompile)
 144     c.ThinLTOModulesToCompile.emplace_back(name);
 145
 146   c.TimeTraceEnabled = config->timeTraceEnabled;
 147   c.TimeTraceGranularity = config->timeTraceGranularity;
 148
 149   c.CSIRProfile = std::string(config->ltoCSProfileFile);
 150   c.RunCSIRInstr = config->ltoCSProfileGenerate;
 151
 152   if (config->emitLLVM) {
 153     c.PostInternalizeModuleHook = [](size_t task, const Module &m) {
 154       if (std::unique_ptr<raw_fd_ostream> os = openFile(config->outputFile))
 155         WriteBitcodeToFile(m, *os, false);
 156       return false;
 157     };
 158   }
 159
 160   if (config->ltoEmitAsm)
 161     c.CGFileType = CGFT_AssemblyFile;
 162
 163   if (config->saveTemps)
 164     checkError(c.addSaveTemps(config->outputFile.str() + ".",
 165                               /*UseInputModulePath*/ true));
 166   return c;
 167 }
 168
 169 BitcodeCompiler::BitcodeCompiler() {
 170   // Initialize indexFile.
 171   if (!config->thinLTOIndexOnlyArg.empty())
 172     indexFile = openFile(config->thinLTOIndexOnlyArg);
 173
 174   // Initialize ltoObj.
 175   lto::ThinBackend backend;
 176   if (config->thinLTOIndexOnly) {
 177     auto onIndexWrite = [&](StringRef s) { thinIndices.erase(s); };
 178     backend = lto::createWriteIndexesThinBackend(
 179         std::string(config->thinLTOPrefixReplace.first),
 180         std::string(config->thinLTOPrefixReplace.second),
 181         config->thinLTOEmitImportsFiles, indexFile.get(), onIndexWrite);
 182   } else {
 183     backend = lto::createInProcessThinBackend(
 184         llvm::heavyweight_hardware_concurrency(config->thinLTOJobs));
 185   }
 186
 187   ltoObj = std::make_unique<lto::LTO>(createConfig(), backend,
 188                                        config->ltoPartitions);
 189
 190   // Initialize usedStartStop.
 191   for (Symbol *sym : symtab->symbols()) {
 192     StringRef s = sym->getName();
 193     for (StringRef prefix : {"__start_", "__stop_"})
 194       if (s.startswith(prefix))
 195         usedStartStop.insert(s.substr(prefix.size()));
 196   }
 197 }
 198
 199 BitcodeCompiler::~BitcodeCompiler() = default;
 200
 201 void BitcodeCompiler::add(BitcodeFile &f) {
 202   lto::InputFile &obj = *f.obj;
 203   bool isExec = !config->shared && !config->relocatable;
 204
 205   if (config->thinLTOIndexOnly)
 206     thinIndices.insert(obj.getName());
 207
 208   ArrayRef<Symbol *> syms = f.getSymbols();
 209   ArrayRef<lto::InputFile::Symbol> objSyms = obj.symbols();
 210   std::vector<lto::SymbolResolution> resols(syms.size());
 211
 212   // Provide a resolution to the LTO API for each symbol.
 213   for (size_t i = 0, e = syms.size(); i != e; ++i) {
 214     Symbol *sym = syms[i];
 215     const lto::InputFile::Symbol &objSym = objSyms[i];
 216     lto::SymbolResolution &r = resols[i];
 217
 218     // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile
 219     // reports two symbols for module ASM defined. Without this check, lld
 220     // flags an undefined in IR with a definition in ASM as prevailing.
 221     // Once IRObjectFile is fixed to report only one symbol this hack can
 222     // be removed.
 223     r.Prevailing = !objSym.isUndefined() && sym->file == &f;
 224
 225     // We ask LTO to preserve following global symbols:
 226     // 1) All symbols when doing relocatable link, so that them can be used
 227     //    for doing final link.
 228     // 2) Symbols that are used in regular objects.
 229     // 3) C named sections if we have corresponding __start_/__stop_ symbol.
 230     // 4) Symbols that are defined in bitcode files and used for dynamic linking.
 231     r.VisibleToRegularObj = config->relocatable || sym->isUsedInRegularObj ||
 232                             (r.Prevailing && sym->includeInDynsym()) ||
 233                             usedStartStop.count(objSym.getSectionName());
 234     const auto *dr = dyn_cast<Defined>(sym);
 235     r.FinalDefinitionInLinkageUnit =
 236         (isExec || sym->visibility != STV_DEFAULT) && dr &&
 237         // Skip absolute symbols from ELF objects, otherwise PC-rel relocations
 238         // will be generated by for them, triggering linker errors.
 239         // Symbol section is always null for bitcode symbols, hence the check
 240         // for isElf(). Skip linker script defined symbols as well: they have
 241         // no File defined.
 242         !(dr->section == nullptr && (!sym->file || sym->file->isElf()));
 243
 244     if (r.Prevailing)
 245       sym->replace(Undefined{nullptr, sym->getName(), STB_GLOBAL, STV_DEFAULT,
 246                              sym->type});
 247
 248     // We tell LTO to not apply interprocedural optimization for wrapped
 249     // (with --wrap) symbols because otherwise LTO would inline them while
 250     // their values are still not final.
 251     r.LinkerRedefined = !sym->canInline;
 252   }
 253   checkError(ltoObj->add(std::move(f.obj), resols));
 254 }
 255
 256 // If LazyObjFile has not been added to link, emit empty index files.
 257 // This is needed because this is what GNU gold plugin does and we have a
 258 // distributed build system that depends on that behavior.
 259 static void thinLTOCreateEmptyIndexFiles() {
 260   for (LazyObjFile *f : lazyObjFiles) {
 261     if (f->fetched || !isBitcode(f->mb))
 262       continue;
 263     std::string path = replaceThinLTOSuffix(getThinLTOOutputFile(f->getName()));
 264     std::unique_ptr<raw_fd_ostream> os = openFile(path + ".thinlto.bc");
 265     if (!os)
 266       continue;
 267
 268     ModuleSummaryIndex m(/*HaveGVs*/ false);
 269     m.setSkipModuleByDistributedBackend();
 270     WriteIndexToFile(m, *os);
 271     if (config->thinLTOEmitImportsFiles)
 272       openFile(path + ".imports");
 273   }
 274 }
 275
 276 // Merge all the bitcode files we have seen, codegen the result
 277 // and return the resulting ObjectFile(s).
 278 std::vector<InputFile *> BitcodeCompiler::compile() {
 279   unsigned maxTasks = ltoObj->getMaxTasks();
 280   buf.resize(maxTasks);
 281   files.resize(maxTasks);
 282
 283   // The --thinlto-cache-dir option specifies the path to a directory in which
 284   // to cache native object files for ThinLTO incremental builds. If a path was
 285   // specified, configure LTO to use it as the cache directory.
 286   lto::NativeObjectCache cache;
 287   if (!config->thinLTOCacheDir.empty())
 288     cache = check(
 289         lto::localCache(config->thinLTOCacheDir,
 290                         [&](size_t task, std::unique_ptr<MemoryBuffer> mb) {
 291                           files[task] = std::move(mb);
 292                         }));
 293
 294   if (!bitcodeFiles.empty())
 295     checkError(ltoObj->run(
 296         [&](size_t task) {
 297           return std::make_unique<lto::NativeObjectStream>(
 298               std::make_unique<raw_svector_ostream>(buf[task]));
 299         },
 300         cache));
 301
 302   // Emit empty index files for non-indexed files but not in single-module mode.
 303   if (config->thinLTOModulesToCompile.empty()) {
 304     for (StringRef s : thinIndices) {
 305       std::string path = getThinLTOOutputFile(s);
 306       openFile(path + ".thinlto.bc");
 307       if (config->thinLTOEmitImportsFiles)
 308         openFile(path + ".imports");
 309     }
 310   }
 311
 312   if (config->thinLTOIndexOnly) {
 313     thinLTOCreateEmptyIndexFiles();
 314
 315     if (!config->ltoObjPath.empty())
 316       saveBuffer(buf[0], config->ltoObjPath);
 317
 318     // ThinLTO with index only option is required to generate only the index
 319     // files. After that, we exit from linker and ThinLTO backend runs in a
 320     // distributed environment.
 321     if (indexFile)
 322       indexFile->close();
 323     return {};
 324   }
 325
 326   if (!config->thinLTOCacheDir.empty())
 327     pruneCache(config->thinLTOCacheDir, config->thinLTOCachePolicy);
 328
 329   if (!config->ltoObjPath.empty()) {
 330     saveBuffer(buf[0], config->ltoObjPath);
 331     for (unsigned i = 1; i != maxTasks; ++i)
 332       saveBuffer(buf[i], config->ltoObjPath + Twine(i));
 333   }
 334
 335   if (config->saveTemps) {
 336     if (!buf[0].empty())
 337       saveBuffer(buf[0], config->outputFile + ".lto.o");
 338     for (unsigned i = 1; i != maxTasks; ++i)
 339       saveBuffer(buf[i], config->outputFile + Twine(i) + ".lto.o");
 340   }
 341
 342   if (config->ltoEmitAsm) {
 343     saveBuffer(buf[0], config->outputFile);
 344     for (unsigned i = 1; i != maxTasks; ++i)
 345       saveBuffer(buf[i], config->outputFile + Twine(i));
 346     return {};
 347   }
 348
 349   std::vector<InputFile *> ret;
 350   for (unsigned i = 0; i != maxTasks; ++i)
 351     if (!buf[i].empty())
 352       ret.push_back(createObjectFile(MemoryBufferRef(buf[i], "lto.tmp")));
 353
 354   for (std::unique_ptr<MemoryBuffer> &file : files)
 355     if (file)
 356       ret.push_back(createObjectFile(*file));
 357   return ret;
 358 }