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