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