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
getThinLTOOutputFile(StringRef modulePath)46 static std::string getThinLTOOutputFile(StringRef modulePath) {
47 return lto::getThinLTOOutputFile(modulePath, config->thinLTOPrefixReplaceOld,
48 config->thinLTOPrefixReplaceNew);
49 }
50
createConfig()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
BitcodeCompiler()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
add(BitcodeFile & f)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.
thinLTOCreateEmptyIndexFiles()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).
compile()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 }
418