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