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 "LinkerScript.h" 13 #include "SymbolTable.h" 14 #include "Symbols.h" 15 #include "lld/Common/Args.h" 16 #include "lld/Common/ErrorHandler.h" 17 #include "lld/Common/TargetOptionsCommandFlags.h" 18 #include "llvm/ADT/STLExtras.h" 19 #include "llvm/ADT/SmallString.h" 20 #include "llvm/ADT/StringRef.h" 21 #include "llvm/ADT/Twine.h" 22 #include "llvm/BinaryFormat/ELF.h" 23 #include "llvm/Bitcode/BitcodeReader.h" 24 #include "llvm/Bitcode/BitcodeWriter.h" 25 #include "llvm/IR/DiagnosticPrinter.h" 26 #include "llvm/LTO/Caching.h" 27 #include "llvm/LTO/Config.h" 28 #include "llvm/LTO/LTO.h" 29 #include "llvm/Object/SymbolicFile.h" 30 #include "llvm/Support/CodeGen.h" 31 #include "llvm/Support/Error.h" 32 #include "llvm/Support/FileSystem.h" 33 #include "llvm/Support/MemoryBuffer.h" 34 #include <algorithm> 35 #include <cstddef> 36 #include <memory> 37 #include <string> 38 #include <system_error> 39 #include <vector> 40 41 using namespace llvm; 42 using namespace llvm::object; 43 using namespace llvm::ELF; 44 using namespace lld; 45 using namespace lld::elf; 46 47 // Creates an empty file to store a list of object files for final 48 // linking of distributed ThinLTO. 49 static std::unique_ptr<raw_fd_ostream> openFile(StringRef file) { 50 std::error_code ec; 51 auto ret = 52 std::make_unique<raw_fd_ostream>(file, ec, sys::fs::OpenFlags::OF_None); 53 if (ec) { 54 error("cannot open " + file + ": " + ec.message()); 55 return nullptr; 56 } 57 return ret; 58 } 59 60 // The merged bitcode after LTO is large. Try opening a file stream that 61 // supports reading, seeking and writing. Such a file allows BitcodeWriter to 62 // flush buffered data to reduce memory consumption. If this fails, open a file 63 // stream that supports only write. 64 static std::unique_ptr<raw_fd_ostream> openLTOOutputFile(StringRef file) { 65 std::error_code ec; 66 std::unique_ptr<raw_fd_ostream> fs = 67 std::make_unique<raw_fd_stream>(file, ec); 68 if (!ec) 69 return fs; 70 return openFile(file); 71 } 72 73 static std::string getThinLTOOutputFile(StringRef modulePath) { 74 return lto::getThinLTOOutputFile( 75 std::string(modulePath), std::string(config->thinLTOPrefixReplace.first), 76 std::string(config->thinLTOPrefixReplace.second)); 77 } 78 79 static lto::Config createConfig() { 80 lto::Config c; 81 82 // LLD supports the new relocations and address-significance tables. 83 c.Options = initTargetOptionsFromCodeGenFlags(); 84 c.Options.RelaxELFRelocations = true; 85 c.Options.EmitAddrsig = true; 86 87 // Always emit a section per function/datum with LTO. 88 c.Options.FunctionSections = true; 89 c.Options.DataSections = true; 90 91 // Check if basic block sections must be used. 92 // Allowed values for --lto-basic-block-sections are "all", "labels", 93 // "<file name specifying basic block ids>", or none. This is the equivalent 94 // of -fbasic-block-sections= flag in clang. 95 if (!config->ltoBasicBlockSections.empty()) { 96 if (config->ltoBasicBlockSections == "all") { 97 c.Options.BBSections = BasicBlockSection::All; 98 } else if (config->ltoBasicBlockSections == "labels") { 99 c.Options.BBSections = BasicBlockSection::Labels; 100 } else if (config->ltoBasicBlockSections == "none") { 101 c.Options.BBSections = BasicBlockSection::None; 102 } else { 103 ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = 104 MemoryBuffer::getFile(config->ltoBasicBlockSections.str()); 105 if (!MBOrErr) { 106 error("cannot open " + config->ltoBasicBlockSections + ":" + 107 MBOrErr.getError().message()); 108 } else { 109 c.Options.BBSectionsFuncListBuf = std::move(*MBOrErr); 110 } 111 c.Options.BBSections = BasicBlockSection::List; 112 } 113 } 114 115 c.Options.PseudoProbeForProfiling = config->ltoPseudoProbeForProfiling; 116 c.Options.UniqueBasicBlockSectionNames = 117 config->ltoUniqueBasicBlockSectionNames; 118 119 if (auto relocModel = getRelocModelFromCMModel()) 120 c.RelocModel = *relocModel; 121 else if (config->relocatable) 122 c.RelocModel = None; 123 else if (config->isPic) 124 c.RelocModel = Reloc::PIC_; 125 else 126 c.RelocModel = Reloc::Static; 127 128 c.CodeModel = getCodeModelFromCMModel(); 129 c.DisableVerify = config->disableVerify; 130 c.DiagHandler = diagnosticHandler; 131 c.OptLevel = config->ltoo; 132 c.CPU = getCPUStr(); 133 c.MAttrs = getMAttrs(); 134 c.CGOptLevel = args::getCGOptLevel(config->ltoo); 135 136 c.PTO.LoopVectorization = c.OptLevel > 1; 137 c.PTO.SLPVectorization = c.OptLevel > 1; 138 139 // Set up a custom pipeline if we've been asked to. 140 c.OptPipeline = std::string(config->ltoNewPmPasses); 141 c.AAPipeline = std::string(config->ltoAAPipeline); 142 143 // Set up optimization remarks if we've been asked to. 144 c.RemarksFilename = std::string(config->optRemarksFilename); 145 c.RemarksPasses = std::string(config->optRemarksPasses); 146 c.RemarksWithHotness = config->optRemarksWithHotness; 147 c.RemarksHotnessThreshold = config->optRemarksHotnessThreshold; 148 c.RemarksFormat = std::string(config->optRemarksFormat); 149 150 c.SampleProfile = std::string(config->ltoSampleProfile); 151 c.UseNewPM = config->ltoNewPassManager; 152 c.DebugPassManager = config->ltoDebugPassManager; 153 c.DwoDir = std::string(config->dwoDir); 154 155 c.HasWholeProgramVisibility = config->ltoWholeProgramVisibility; 156 c.AlwaysEmitRegularLTOObj = !config->ltoObjPath.empty(); 157 158 for (const llvm::StringRef &name : config->thinLTOModulesToCompile) 159 c.ThinLTOModulesToCompile.emplace_back(name); 160 161 c.TimeTraceEnabled = config->timeTraceEnabled; 162 c.TimeTraceGranularity = config->timeTraceGranularity; 163 164 c.CSIRProfile = std::string(config->ltoCSProfileFile); 165 c.RunCSIRInstr = config->ltoCSProfileGenerate; 166 167 if (config->emitLLVM) { 168 c.PostInternalizeModuleHook = [](size_t task, const Module &m) { 169 if (std::unique_ptr<raw_fd_ostream> os = 170 openLTOOutputFile(config->outputFile)) 171 WriteBitcodeToFile(m, *os, false); 172 return false; 173 }; 174 } 175 176 if (config->ltoEmitAsm) 177 c.CGFileType = CGFT_AssemblyFile; 178 179 if (config->saveTemps) 180 checkError(c.addSaveTemps(config->outputFile.str() + ".", 181 /*UseInputModulePath*/ true)); 182 return c; 183 } 184 185 BitcodeCompiler::BitcodeCompiler() { 186 // Initialize indexFile. 187 if (!config->thinLTOIndexOnlyArg.empty()) 188 indexFile = openFile(config->thinLTOIndexOnlyArg); 189 190 // Initialize ltoObj. 191 lto::ThinBackend backend; 192 if (config->thinLTOIndexOnly) { 193 auto onIndexWrite = [&](StringRef s) { thinIndices.erase(s); }; 194 backend = lto::createWriteIndexesThinBackend( 195 std::string(config->thinLTOPrefixReplace.first), 196 std::string(config->thinLTOPrefixReplace.second), 197 config->thinLTOEmitImportsFiles, indexFile.get(), onIndexWrite); 198 } else { 199 backend = lto::createInProcessThinBackend( 200 llvm::heavyweight_hardware_concurrency(config->thinLTOJobs)); 201 } 202 203 ltoObj = std::make_unique<lto::LTO>(createConfig(), backend, 204 config->ltoPartitions); 205 206 // Initialize usedStartStop. 207 for (Symbol *sym : symtab->symbols()) { 208 StringRef s = sym->getName(); 209 for (StringRef prefix : {"__start_", "__stop_"}) 210 if (s.startswith(prefix)) 211 usedStartStop.insert(s.substr(prefix.size())); 212 } 213 } 214 215 BitcodeCompiler::~BitcodeCompiler() = default; 216 217 void BitcodeCompiler::add(BitcodeFile &f) { 218 lto::InputFile &obj = *f.obj; 219 bool isExec = !config->shared && !config->relocatable; 220 221 if (config->thinLTOIndexOnly) 222 thinIndices.insert(obj.getName()); 223 224 ArrayRef<Symbol *> syms = f.getSymbols(); 225 ArrayRef<lto::InputFile::Symbol> objSyms = obj.symbols(); 226 std::vector<lto::SymbolResolution> resols(syms.size()); 227 228 // Provide a resolution to the LTO API for each symbol. 229 for (size_t i = 0, e = syms.size(); i != e; ++i) { 230 Symbol *sym = syms[i]; 231 const lto::InputFile::Symbol &objSym = objSyms[i]; 232 lto::SymbolResolution &r = resols[i]; 233 234 // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile 235 // reports two symbols for module ASM defined. Without this check, lld 236 // flags an undefined in IR with a definition in ASM as prevailing. 237 // Once IRObjectFile is fixed to report only one symbol this hack can 238 // be removed. 239 r.Prevailing = !objSym.isUndefined() && sym->file == &f; 240 241 // We ask LTO to preserve following global symbols: 242 // 1) All symbols when doing relocatable link, so that them can be used 243 // for doing final link. 244 // 2) Symbols that are used in regular objects. 245 // 3) C named sections if we have corresponding __start_/__stop_ symbol. 246 // 4) Symbols that are defined in bitcode files and used for dynamic linking. 247 r.VisibleToRegularObj = config->relocatable || sym->isUsedInRegularObj || 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 = sym->computeBinding() != STB_LOCAL && 253 (sym->isExportDynamic(sym->kind(), sym->visibility) || 254 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 && (!sym->file || sym->file->isElf())); 264 265 if (r.Prevailing) 266 sym->replace(Undefined{nullptr, sym->getName(), STB_GLOBAL, STV_DEFAULT, 267 sym->type}); 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->canInline; 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. 280 static void thinLTOCreateEmptyIndexFiles() { 281 for (LazyObjFile *f : lazyObjFiles) { 282 if (f->fetched || !isBitcode(f->mb)) 283 continue; 284 std::string path = replaceThinLTOSuffix(getThinLTOOutputFile(f->getName())); 285 std::unique_ptr<raw_fd_ostream> os = openFile(path + ".thinlto.bc"); 286 if (!os) 287 continue; 288 289 ModuleSummaryIndex m(/*HaveGVs*/ false); 290 m.setSkipModuleByDistributedBackend(); 291 WriteIndexToFile(m, *os); 292 if (config->thinLTOEmitImportsFiles) 293 openFile(path + ".imports"); 294 } 295 } 296 297 // Merge all the bitcode files we have seen, codegen the result 298 // and return the resulting ObjectFile(s). 299 std::vector<InputFile *> BitcodeCompiler::compile() { 300 unsigned maxTasks = ltoObj->getMaxTasks(); 301 buf.resize(maxTasks); 302 files.resize(maxTasks); 303 304 // The --thinlto-cache-dir option specifies the path to a directory in which 305 // to cache native object files for ThinLTO incremental builds. If a path was 306 // specified, configure LTO to use it as the cache directory. 307 lto::NativeObjectCache cache; 308 if (!config->thinLTOCacheDir.empty()) 309 cache = check( 310 lto::localCache(config->thinLTOCacheDir, 311 [&](size_t task, std::unique_ptr<MemoryBuffer> mb) { 312 files[task] = std::move(mb); 313 })); 314 315 if (!bitcodeFiles.empty()) 316 checkError(ltoObj->run( 317 [&](size_t task) { 318 return std::make_unique<lto::NativeObjectStream>( 319 std::make_unique<raw_svector_ostream>(buf[task])); 320 }, 321 cache)); 322 323 // Emit empty index files for non-indexed files but not in single-module mode. 324 if (config->thinLTOModulesToCompile.empty()) { 325 for (StringRef s : thinIndices) { 326 std::string path = getThinLTOOutputFile(s); 327 openFile(path + ".thinlto.bc"); 328 if (config->thinLTOEmitImportsFiles) 329 openFile(path + ".imports"); 330 } 331 } 332 333 if (config->thinLTOIndexOnly) { 334 thinLTOCreateEmptyIndexFiles(); 335 336 if (!config->ltoObjPath.empty()) 337 saveBuffer(buf[0], config->ltoObjPath); 338 339 // ThinLTO with index only option is required to generate only the index 340 // files. After that, we exit from linker and ThinLTO backend runs in a 341 // distributed environment. 342 if (indexFile) 343 indexFile->close(); 344 return {}; 345 } 346 347 if (!config->thinLTOCacheDir.empty()) 348 pruneCache(config->thinLTOCacheDir, config->thinLTOCachePolicy); 349 350 if (!config->ltoObjPath.empty()) { 351 saveBuffer(buf[0], config->ltoObjPath); 352 for (unsigned i = 1; i != maxTasks; ++i) 353 saveBuffer(buf[i], config->ltoObjPath + Twine(i)); 354 } 355 356 if (config->saveTemps) { 357 if (!buf[0].empty()) 358 saveBuffer(buf[0], config->outputFile + ".lto.o"); 359 for (unsigned i = 1; i != maxTasks; ++i) 360 saveBuffer(buf[i], config->outputFile + Twine(i) + ".lto.o"); 361 } 362 363 if (config->ltoEmitAsm) { 364 saveBuffer(buf[0], config->outputFile); 365 for (unsigned i = 1; i != maxTasks; ++i) 366 saveBuffer(buf[i], config->outputFile + Twine(i)); 367 return {}; 368 } 369 370 std::vector<InputFile *> ret; 371 for (unsigned i = 0; i != maxTasks; ++i) 372 if (!buf[i].empty()) 373 ret.push_back(createObjectFile(MemoryBufferRef(buf[i], "lto.tmp"))); 374 375 for (std::unique_ptr<MemoryBuffer> &file : files) 376 if (file) 377 ret.push_back(createObjectFile(*file)); 378 return ret; 379 } 380