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