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 34 using namespace llvm; 35 using namespace llvm::object; 36 using namespace llvm::ELF; 37 using namespace lld; 38 using namespace lld::elf; 39 40 static std::string getThinLTOOutputFile(Ctx &ctx, StringRef modulePath) { 41 return lto::getThinLTOOutputFile(modulePath, ctx.arg.thinLTOPrefixReplaceOld, 42 ctx.arg.thinLTOPrefixReplaceNew); 43 } 44 45 static 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(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(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(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(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(ctx.arg.outputFile)) 151 WriteBitcodeToFile(m, *os, 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(ctx.e, c.addSaveTemps(ctx.arg.outputFile.str() + ".", 163 /*UseInputModulePath*/ true, 164 ctx.arg.saveTempsArgs)); 165 return c; 166 } 167 168 BitcodeCompiler::BitcodeCompiler(Ctx &ctx) : ctx(ctx) { 169 // Initialize indexFile. 170 if (!ctx.arg.thinLTOIndexOnlyArg.empty()) 171 indexFile = openFile(ctx.arg.thinLTOIndexOnlyArg); 172 173 // Initialize ltoObj. 174 lto::ThinBackend backend; 175 auto onIndexWrite = [&](StringRef s) { thinIndices.erase(s); }; 176 if (ctx.arg.thinLTOIndexOnly) { 177 backend = lto::createWriteIndexesThinBackend( 178 llvm::hardware_concurrency(ctx.arg.thinLTOJobs), 179 std::string(ctx.arg.thinLTOPrefixReplaceOld), 180 std::string(ctx.arg.thinLTOPrefixReplaceNew), 181 std::string(ctx.arg.thinLTOPrefixReplaceNativeObject), 182 ctx.arg.thinLTOEmitImportsFiles, indexFile.get(), onIndexWrite); 183 } else if (!ctx.arg.dtltoDistributor.empty()) { 184 backend = lto::createOutOfProcessThinBackend( 185 llvm::hardware_concurrency(ctx.arg.thinLTOJobs), onIndexWrite, 186 ctx.arg.thinLTOEmitIndexFiles, ctx.arg.thinLTOEmitImportsFiles, 187 ctx.arg.outputFile, ctx.arg.dtltoDistributor, 188 ctx.arg.dtltoDistributorArgs, ctx.arg.dtltoCompiler, 189 ctx.arg.dtltoCompilerArgs, !ctx.arg.saveTempsArgs.empty()); 190 } else { 191 backend = lto::createInProcessThinBackend( 192 llvm::heavyweight_hardware_concurrency(ctx.arg.thinLTOJobs), 193 onIndexWrite, ctx.arg.thinLTOEmitIndexFiles, 194 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>(createConfig(ctx), backend, 202 ctx.arg.ltoPartitions, 203 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)) 214 usedStartStop.insert(s.substr(prefix.size())); 215 } 216 } 217 218 BitcodeCompiler::~BitcodeCompiler() = default; 219 220 void 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(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(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>(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); 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(ctx.e, ltoObj->add(std::move(f.obj), 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. 287 static void thinLTOCreateEmptyIndexFiles(Ctx &ctx) { 288 DenseSet<StringRef> linkedBitCodeFiles; 289 for (BitcodeFile *f : ctx.bitcodeFiles) 290 linkedBitCodeFiles.insert(f->getName()); 291 292 for (BitcodeFile *f : ctx.lazyBitcodeFiles) { 293 if (!f->lazy) 294 continue; 295 if (linkedBitCodeFiles.contains(f->getName())) 296 continue; 297 std::string path = 298 replaceThinLTOSuffix(ctx, getThinLTOOutputFile(ctx, f->obj->getName())); 299 std::unique_ptr<raw_fd_ostream> os = openFile(path + ".thinlto.bc"); 300 if (!os) 301 continue; 302 303 ModuleSummaryIndex m(/*HaveGVs*/ false); 304 m.setSkipModuleByDistributedBackend(); 305 writeIndexToFile(m, *os); 306 if (ctx.arg.thinLTOEmitImportsFiles) 307 openFile(path + ".imports"); 308 } 309 } 310 311 // Merge all the bitcode files we have seen, codegen the result 312 // and return the resulting ObjectFile(s). 313 SmallVector<std::unique_ptr<InputFile>, 0> BitcodeCompiler::compile() { 314 unsigned maxTasks = ltoObj->getMaxTasks(); 315 buf.resize(maxTasks); 316 files.resize(maxTasks); 317 filenames.resize(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(localCache("ThinLTO", "Thin", ctx.arg.thinLTOCacheDir, 325 [&](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(ctx.e, ltoObj->run( 333 [&](size_t task, const Twine &moduleName) { 334 buf[task].first = moduleName.str(); 335 return std::make_unique<CachedFileStream>( 336 std::make_unique<raw_svector_ostream>( 337 buf[task].second)); 338 }, 339 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, s); 345 openFile(path + ".thinlto.bc"); 346 if (ctx.arg.thinLTOEmitImportsFiles) 347 openFile(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(buf[0].second, 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(ctx.arg.thinLTOCacheDir, ctx.arg.thinLTOCachePolicy, files); 368 369 if (!ctx.arg.ltoObjPath.empty()) { 370 saveBuffer(buf[0].second, ctx.arg.ltoObjPath); 371 for (unsigned i = 1; i != maxTasks; ++i) 372 saveBuffer(buf[i].second, ctx.arg.ltoObjPath + Twine(i)); 373 } 374 375 bool savePrelink = ctx.arg.saveTempsArgs.contains("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(Twine(ctx.arg.outputFile) + ".lto" + 401 (i == 0 ? Twine("") : Twine('.') + Twine(i)) + ext); 402 } else { 403 StringRef directory = sys::path::parent_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(")") 408 ? sys::path::filename(bitcodeFilePath) 409 : sys::path::stem(bitcodeFilePath); 410 StringRef outputFileBaseName = sys::path::filename(ctx.arg.outputFile); 411 SmallString<256> path; 412 sys::path::append(path, directory, 413 outputFileBaseName + ".lto." + baseName + ext); 414 sys::path::remove_dots(path, true); 415 ltoObjName = ctx.saver.save(path.str()); 416 } 417 if (savePrelink || ctx.arg.ltoEmitAsm) 418 saveBuffer(buf[i].second, ltoObjName); 419 if (!ctx.arg.ltoEmitAsm) 420 ret.push_back(createObjFile(ctx, MemoryBufferRef(objBuf, ltoObjName))); 421 } 422 return ret; 423 } 424