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 static std::string getThinLTOOutputFile(StringRef modulePath) { 61 return lto::getThinLTOOutputFile( 62 std::string(modulePath), std::string(config->thinLTOPrefixReplace.first), 63 std::string(config->thinLTOPrefixReplace.second)); 64 } 65 66 static lto::Config createConfig() { 67 lto::Config c; 68 69 // LLD supports the new relocations and address-significance tables. 70 c.Options = initTargetOptionsFromCodeGenFlags(); 71 c.Options.RelaxELFRelocations = true; 72 c.Options.EmitAddrsig = true; 73 74 // Always emit a section per function/datum with LTO. 75 c.Options.FunctionSections = true; 76 c.Options.DataSections = true; 77 78 // Check if basic block sections must be used. 79 // Allowed values for --lto-basicblock-sections are "all", "labels", 80 // "<file name specifying basic block ids>", or none. This is the equivalent 81 // of -fbasic-block-sections= flag in clang. 82 if (!config->ltoBasicBlockSections.empty()) { 83 if (config->ltoBasicBlockSections == "all") { 84 c.Options.BBSections = BasicBlockSection::All; 85 } else if (config->ltoBasicBlockSections == "labels") { 86 c.Options.BBSections = BasicBlockSection::Labels; 87 } else if (config->ltoBasicBlockSections == "none") { 88 c.Options.BBSections = BasicBlockSection::None; 89 } else { 90 ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = 91 MemoryBuffer::getFile(config->ltoBasicBlockSections.str()); 92 if (!MBOrErr) { 93 error("cannot open " + config->ltoBasicBlockSections + ":" + 94 MBOrErr.getError().message()); 95 } else { 96 c.Options.BBSectionsFuncListBuf = std::move(*MBOrErr); 97 } 98 c.Options.BBSections = BasicBlockSection::List; 99 } 100 } 101 102 c.Options.UniqueBasicBlockSectionNames = 103 config->ltoUniqueBasicBlockSectionNames; 104 105 if (auto relocModel = getRelocModelFromCMModel()) 106 c.RelocModel = *relocModel; 107 else if (config->relocatable) 108 c.RelocModel = None; 109 else if (config->isPic) 110 c.RelocModel = Reloc::PIC_; 111 else 112 c.RelocModel = Reloc::Static; 113 114 c.CodeModel = getCodeModelFromCMModel(); 115 c.DisableVerify = config->disableVerify; 116 c.DiagHandler = diagnosticHandler; 117 c.OptLevel = config->ltoo; 118 c.CPU = getCPUStr(); 119 c.MAttrs = getMAttrs(); 120 c.CGOptLevel = args::getCGOptLevel(config->ltoo); 121 122 c.PTO.LoopVectorization = c.OptLevel > 1; 123 c.PTO.SLPVectorization = c.OptLevel > 1; 124 125 // Set up a custom pipeline if we've been asked to. 126 c.OptPipeline = std::string(config->ltoNewPmPasses); 127 c.AAPipeline = std::string(config->ltoAAPipeline); 128 129 // Set up optimization remarks if we've been asked to. 130 c.RemarksFilename = std::string(config->optRemarksFilename); 131 c.RemarksPasses = std::string(config->optRemarksPasses); 132 c.RemarksWithHotness = config->optRemarksWithHotness; 133 c.RemarksFormat = std::string(config->optRemarksFormat); 134 135 c.SampleProfile = std::string(config->ltoSampleProfile); 136 c.UseNewPM = config->ltoNewPassManager; 137 c.DebugPassManager = config->ltoDebugPassManager; 138 c.DwoDir = std::string(config->dwoDir); 139 140 c.HasWholeProgramVisibility = config->ltoWholeProgramVisibility; 141 c.AlwaysEmitRegularLTOObj = !config->ltoObjPath.empty(); 142 143 for (const llvm::StringRef &name : config->thinLTOModulesToCompile) 144 c.ThinLTOModulesToCompile.emplace_back(name); 145 146 c.TimeTraceEnabled = config->timeTraceEnabled; 147 c.TimeTraceGranularity = config->timeTraceGranularity; 148 149 c.CSIRProfile = std::string(config->ltoCSProfileFile); 150 c.RunCSIRInstr = config->ltoCSProfileGenerate; 151 152 if (config->emitLLVM) { 153 c.PostInternalizeModuleHook = [](size_t task, const Module &m) { 154 if (std::unique_ptr<raw_fd_ostream> os = openFile(config->outputFile)) 155 WriteBitcodeToFile(m, *os, false); 156 return false; 157 }; 158 } 159 160 if (config->ltoEmitAsm) 161 c.CGFileType = CGFT_AssemblyFile; 162 163 if (config->saveTemps) 164 checkError(c.addSaveTemps(config->outputFile.str() + ".", 165 /*UseInputModulePath*/ true)); 166 return c; 167 } 168 169 BitcodeCompiler::BitcodeCompiler() { 170 // Initialize indexFile. 171 if (!config->thinLTOIndexOnlyArg.empty()) 172 indexFile = openFile(config->thinLTOIndexOnlyArg); 173 174 // Initialize ltoObj. 175 lto::ThinBackend backend; 176 if (config->thinLTOIndexOnly) { 177 auto onIndexWrite = [&](StringRef s) { thinIndices.erase(s); }; 178 backend = lto::createWriteIndexesThinBackend( 179 std::string(config->thinLTOPrefixReplace.first), 180 std::string(config->thinLTOPrefixReplace.second), 181 config->thinLTOEmitImportsFiles, indexFile.get(), onIndexWrite); 182 } else { 183 backend = lto::createInProcessThinBackend( 184 llvm::heavyweight_hardware_concurrency(config->thinLTOJobs)); 185 } 186 187 ltoObj = std::make_unique<lto::LTO>(createConfig(), backend, 188 config->ltoPartitions); 189 190 // Initialize usedStartStop. 191 for (Symbol *sym : symtab->symbols()) { 192 StringRef s = sym->getName(); 193 for (StringRef prefix : {"__start_", "__stop_"}) 194 if (s.startswith(prefix)) 195 usedStartStop.insert(s.substr(prefix.size())); 196 } 197 } 198 199 BitcodeCompiler::~BitcodeCompiler() = default; 200 201 void BitcodeCompiler::add(BitcodeFile &f) { 202 lto::InputFile &obj = *f.obj; 203 bool isExec = !config->shared && !config->relocatable; 204 205 if (config->thinLTOIndexOnly) 206 thinIndices.insert(obj.getName()); 207 208 ArrayRef<Symbol *> syms = f.getSymbols(); 209 ArrayRef<lto::InputFile::Symbol> objSyms = obj.symbols(); 210 std::vector<lto::SymbolResolution> resols(syms.size()); 211 212 // Provide a resolution to the LTO API for each symbol. 213 for (size_t i = 0, e = syms.size(); i != e; ++i) { 214 Symbol *sym = syms[i]; 215 const lto::InputFile::Symbol &objSym = objSyms[i]; 216 lto::SymbolResolution &r = resols[i]; 217 218 // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile 219 // reports two symbols for module ASM defined. Without this check, lld 220 // flags an undefined in IR with a definition in ASM as prevailing. 221 // Once IRObjectFile is fixed to report only one symbol this hack can 222 // be removed. 223 r.Prevailing = !objSym.isUndefined() && sym->file == &f; 224 225 // We ask LTO to preserve following global symbols: 226 // 1) All symbols when doing relocatable link, so that them can be used 227 // for doing final link. 228 // 2) Symbols that are used in regular objects. 229 // 3) C named sections if we have corresponding __start_/__stop_ symbol. 230 // 4) Symbols that are defined in bitcode files and used for dynamic linking. 231 r.VisibleToRegularObj = config->relocatable || sym->isUsedInRegularObj || 232 (r.Prevailing && sym->includeInDynsym()) || 233 usedStartStop.count(objSym.getSectionName()); 234 const auto *dr = dyn_cast<Defined>(sym); 235 r.FinalDefinitionInLinkageUnit = 236 (isExec || sym->visibility != STV_DEFAULT) && dr && 237 // Skip absolute symbols from ELF objects, otherwise PC-rel relocations 238 // will be generated by for them, triggering linker errors. 239 // Symbol section is always null for bitcode symbols, hence the check 240 // for isElf(). Skip linker script defined symbols as well: they have 241 // no File defined. 242 !(dr->section == nullptr && (!sym->file || sym->file->isElf())); 243 244 if (r.Prevailing) 245 sym->replace(Undefined{nullptr, sym->getName(), STB_GLOBAL, STV_DEFAULT, 246 sym->type}); 247 248 // We tell LTO to not apply interprocedural optimization for wrapped 249 // (with --wrap) symbols because otherwise LTO would inline them while 250 // their values are still not final. 251 r.LinkerRedefined = !sym->canInline; 252 } 253 checkError(ltoObj->add(std::move(f.obj), resols)); 254 } 255 256 // If LazyObjFile has not been added to link, emit empty index files. 257 // This is needed because this is what GNU gold plugin does and we have a 258 // distributed build system that depends on that behavior. 259 static void thinLTOCreateEmptyIndexFiles() { 260 for (LazyObjFile *f : lazyObjFiles) { 261 if (f->fetched || !isBitcode(f->mb)) 262 continue; 263 std::string path = replaceThinLTOSuffix(getThinLTOOutputFile(f->getName())); 264 std::unique_ptr<raw_fd_ostream> os = openFile(path + ".thinlto.bc"); 265 if (!os) 266 continue; 267 268 ModuleSummaryIndex m(/*HaveGVs*/ false); 269 m.setSkipModuleByDistributedBackend(); 270 WriteIndexToFile(m, *os); 271 if (config->thinLTOEmitImportsFiles) 272 openFile(path + ".imports"); 273 } 274 } 275 276 // Merge all the bitcode files we have seen, codegen the result 277 // and return the resulting ObjectFile(s). 278 std::vector<InputFile *> BitcodeCompiler::compile() { 279 unsigned maxTasks = ltoObj->getMaxTasks(); 280 buf.resize(maxTasks); 281 files.resize(maxTasks); 282 283 // The --thinlto-cache-dir option specifies the path to a directory in which 284 // to cache native object files for ThinLTO incremental builds. If a path was 285 // specified, configure LTO to use it as the cache directory. 286 lto::NativeObjectCache cache; 287 if (!config->thinLTOCacheDir.empty()) 288 cache = check( 289 lto::localCache(config->thinLTOCacheDir, 290 [&](size_t task, std::unique_ptr<MemoryBuffer> mb) { 291 files[task] = std::move(mb); 292 })); 293 294 if (!bitcodeFiles.empty()) 295 checkError(ltoObj->run( 296 [&](size_t task) { 297 return std::make_unique<lto::NativeObjectStream>( 298 std::make_unique<raw_svector_ostream>(buf[task])); 299 }, 300 cache)); 301 302 // Emit empty index files for non-indexed files but not in single-module mode. 303 if (config->thinLTOModulesToCompile.empty()) { 304 for (StringRef s : thinIndices) { 305 std::string path = getThinLTOOutputFile(s); 306 openFile(path + ".thinlto.bc"); 307 if (config->thinLTOEmitImportsFiles) 308 openFile(path + ".imports"); 309 } 310 } 311 312 if (config->thinLTOIndexOnly) { 313 thinLTOCreateEmptyIndexFiles(); 314 315 if (!config->ltoObjPath.empty()) 316 saveBuffer(buf[0], config->ltoObjPath); 317 318 // ThinLTO with index only option is required to generate only the index 319 // files. After that, we exit from linker and ThinLTO backend runs in a 320 // distributed environment. 321 if (indexFile) 322 indexFile->close(); 323 return {}; 324 } 325 326 if (!config->thinLTOCacheDir.empty()) 327 pruneCache(config->thinLTOCacheDir, config->thinLTOCachePolicy); 328 329 if (!config->ltoObjPath.empty()) { 330 saveBuffer(buf[0], config->ltoObjPath); 331 for (unsigned i = 1; i != maxTasks; ++i) 332 saveBuffer(buf[i], config->ltoObjPath + Twine(i)); 333 } 334 335 if (config->saveTemps) { 336 if (!buf[0].empty()) 337 saveBuffer(buf[0], config->outputFile + ".lto.o"); 338 for (unsigned i = 1; i != maxTasks; ++i) 339 saveBuffer(buf[i], config->outputFile + Twine(i) + ".lto.o"); 340 } 341 342 if (config->ltoEmitAsm) { 343 saveBuffer(buf[0], config->outputFile); 344 for (unsigned i = 1; i != maxTasks; ++i) 345 saveBuffer(buf[i], config->outputFile + Twine(i)); 346 return {}; 347 } 348 349 std::vector<InputFile *> ret; 350 for (unsigned i = 0; i != maxTasks; ++i) 351 if (!buf[i].empty()) 352 ret.push_back(createObjectFile(MemoryBufferRef(buf[i], "lto.tmp"))); 353 354 for (std::unique_ptr<MemoryBuffer> &file : files) 355 if (file) 356 ret.push_back(createObjectFile(*file)); 357 return ret; 358 } 359