1 //===-LTO.cpp - LLVM Link Time Optimizer ----------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements functions and classes used to support LTO. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/LTO/LTO.h" 15 #include "llvm/ADT/Statistic.h" 16 #include "llvm/Analysis/TargetLibraryInfo.h" 17 #include "llvm/Analysis/TargetTransformInfo.h" 18 #include "llvm/Bitcode/BitcodeReader.h" 19 #include "llvm/Bitcode/BitcodeWriter.h" 20 #include "llvm/CodeGen/Analysis.h" 21 #include "llvm/Config/llvm-config.h" 22 #include "llvm/IR/AutoUpgrade.h" 23 #include "llvm/IR/DiagnosticPrinter.h" 24 #include "llvm/IR/LegacyPassManager.h" 25 #include "llvm/IR/Mangler.h" 26 #include "llvm/IR/Metadata.h" 27 #include "llvm/LTO/LTOBackend.h" 28 #include "llvm/Linker/IRMover.h" 29 #include "llvm/Object/IRObjectFile.h" 30 #include "llvm/Support/Error.h" 31 #include "llvm/Support/ManagedStatic.h" 32 #include "llvm/Support/MemoryBuffer.h" 33 #include "llvm/Support/Path.h" 34 #include "llvm/Support/SHA1.h" 35 #include "llvm/Support/SourceMgr.h" 36 #include "llvm/Support/TargetRegistry.h" 37 #include "llvm/Support/ThreadPool.h" 38 #include "llvm/Support/Threading.h" 39 #include "llvm/Support/VCSRevision.h" 40 #include "llvm/Support/raw_ostream.h" 41 #include "llvm/Target/TargetMachine.h" 42 #include "llvm/Target/TargetOptions.h" 43 #include "llvm/Transforms/IPO.h" 44 #include "llvm/Transforms/IPO/PassManagerBuilder.h" 45 #include "llvm/Transforms/Utils/SplitModule.h" 46 47 #include <set> 48 49 using namespace llvm; 50 using namespace lto; 51 using namespace object; 52 53 #define DEBUG_TYPE "lto" 54 55 static cl::opt<bool> 56 DumpThinCGSCCs("dump-thin-cg-sccs", cl::init(false), cl::Hidden, 57 cl::desc("Dump the SCCs in the ThinLTO index's callgraph")); 58 59 // The values are (type identifier, summary) pairs. 60 typedef DenseMap< 61 GlobalValue::GUID, 62 TinyPtrVector<const std::pair<const std::string, TypeIdSummary> *>> 63 TypeIdSummariesByGuidTy; 64 65 // Returns a unique hash for the Module considering the current list of 66 // export/import and other global analysis results. 67 // The hash is produced in \p Key. 68 static void computeCacheKey( 69 SmallString<40> &Key, const Config &Conf, const ModuleSummaryIndex &Index, 70 StringRef ModuleID, const FunctionImporter::ImportMapTy &ImportList, 71 const FunctionImporter::ExportSetTy &ExportList, 72 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR, 73 const GVSummaryMapTy &DefinedGlobals, 74 const TypeIdSummariesByGuidTy &TypeIdSummariesByGuid, 75 const std::set<GlobalValue::GUID> &CfiFunctionDefs, 76 const std::set<GlobalValue::GUID> &CfiFunctionDecls) { 77 // Compute the unique hash for this entry. 78 // This is based on the current compiler version, the module itself, the 79 // export list, the hash for every single module in the import list, the 80 // list of ResolvedODR for the module, and the list of preserved symbols. 81 SHA1 Hasher; 82 83 // Start with the compiler revision 84 Hasher.update(LLVM_VERSION_STRING); 85 #ifdef LLVM_REVISION 86 Hasher.update(LLVM_REVISION); 87 #endif 88 89 // Include the parts of the LTO configuration that affect code generation. 90 auto AddString = [&](StringRef Str) { 91 Hasher.update(Str); 92 Hasher.update(ArrayRef<uint8_t>{0}); 93 }; 94 auto AddUnsigned = [&](unsigned I) { 95 uint8_t Data[4]; 96 Data[0] = I; 97 Data[1] = I >> 8; 98 Data[2] = I >> 16; 99 Data[3] = I >> 24; 100 Hasher.update(ArrayRef<uint8_t>{Data, 4}); 101 }; 102 auto AddUint64 = [&](uint64_t I) { 103 uint8_t Data[8]; 104 Data[0] = I; 105 Data[1] = I >> 8; 106 Data[2] = I >> 16; 107 Data[3] = I >> 24; 108 Data[4] = I >> 32; 109 Data[5] = I >> 40; 110 Data[6] = I >> 48; 111 Data[7] = I >> 56; 112 Hasher.update(ArrayRef<uint8_t>{Data, 8}); 113 }; 114 AddString(Conf.CPU); 115 // FIXME: Hash more of Options. For now all clients initialize Options from 116 // command-line flags (which is unsupported in production), but may set 117 // RelaxELFRelocations. The clang driver can also pass FunctionSections, 118 // DataSections and DebuggerTuning via command line flags. 119 AddUnsigned(Conf.Options.RelaxELFRelocations); 120 AddUnsigned(Conf.Options.FunctionSections); 121 AddUnsigned(Conf.Options.DataSections); 122 AddUnsigned((unsigned)Conf.Options.DebuggerTuning); 123 for (auto &A : Conf.MAttrs) 124 AddString(A); 125 if (Conf.RelocModel) 126 AddUnsigned(*Conf.RelocModel); 127 else 128 AddUnsigned(-1); 129 if (Conf.CodeModel) 130 AddUnsigned(*Conf.CodeModel); 131 else 132 AddUnsigned(-1); 133 AddUnsigned(Conf.CGOptLevel); 134 AddUnsigned(Conf.CGFileType); 135 AddUnsigned(Conf.OptLevel); 136 AddUnsigned(Conf.UseNewPM); 137 AddString(Conf.OptPipeline); 138 AddString(Conf.AAPipeline); 139 AddString(Conf.OverrideTriple); 140 AddString(Conf.DefaultTriple); 141 AddString(Conf.DwoDir); 142 143 // Include the hash for the current module 144 auto ModHash = Index.getModuleHash(ModuleID); 145 Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash))); 146 for (auto F : ExportList) 147 // The export list can impact the internalization, be conservative here 148 Hasher.update(ArrayRef<uint8_t>((uint8_t *)&F, sizeof(F))); 149 150 // Include the hash for every module we import functions from. The set of 151 // imported symbols for each module may affect code generation and is 152 // sensitive to link order, so include that as well. 153 for (auto &Entry : ImportList) { 154 auto ModHash = Index.getModuleHash(Entry.first()); 155 Hasher.update(ArrayRef<uint8_t>((uint8_t *)&ModHash[0], sizeof(ModHash))); 156 157 AddUint64(Entry.second.size()); 158 for (auto &Fn : Entry.second) 159 AddUint64(Fn); 160 } 161 162 // Include the hash for the resolved ODR. 163 for (auto &Entry : ResolvedODR) { 164 Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.first, 165 sizeof(GlobalValue::GUID))); 166 Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&Entry.second, 167 sizeof(GlobalValue::LinkageTypes))); 168 } 169 170 // Members of CfiFunctionDefs and CfiFunctionDecls that are referenced or 171 // defined in this module. 172 std::set<GlobalValue::GUID> UsedCfiDefs; 173 std::set<GlobalValue::GUID> UsedCfiDecls; 174 175 // Typeids used in this module. 176 std::set<GlobalValue::GUID> UsedTypeIds; 177 178 auto AddUsedCfiGlobal = [&](GlobalValue::GUID ValueGUID) { 179 if (CfiFunctionDefs.count(ValueGUID)) 180 UsedCfiDefs.insert(ValueGUID); 181 if (CfiFunctionDecls.count(ValueGUID)) 182 UsedCfiDecls.insert(ValueGUID); 183 }; 184 185 auto AddUsedThings = [&](GlobalValueSummary *GS) { 186 if (!GS) return; 187 AddUnsigned(GS->isLive()); 188 for (const ValueInfo &VI : GS->refs()) { 189 AddUnsigned(VI.isDSOLocal()); 190 AddUsedCfiGlobal(VI.getGUID()); 191 } 192 if (auto *FS = dyn_cast<FunctionSummary>(GS)) { 193 for (auto &TT : FS->type_tests()) 194 UsedTypeIds.insert(TT); 195 for (auto &TT : FS->type_test_assume_vcalls()) 196 UsedTypeIds.insert(TT.GUID); 197 for (auto &TT : FS->type_checked_load_vcalls()) 198 UsedTypeIds.insert(TT.GUID); 199 for (auto &TT : FS->type_test_assume_const_vcalls()) 200 UsedTypeIds.insert(TT.VFunc.GUID); 201 for (auto &TT : FS->type_checked_load_const_vcalls()) 202 UsedTypeIds.insert(TT.VFunc.GUID); 203 for (auto &ET : FS->calls()) { 204 AddUnsigned(ET.first.isDSOLocal()); 205 AddUsedCfiGlobal(ET.first.getGUID()); 206 } 207 } 208 }; 209 210 // Include the hash for the linkage type to reflect internalization and weak 211 // resolution, and collect any used type identifier resolutions. 212 for (auto &GS : DefinedGlobals) { 213 GlobalValue::LinkageTypes Linkage = GS.second->linkage(); 214 Hasher.update( 215 ArrayRef<uint8_t>((const uint8_t *)&Linkage, sizeof(Linkage))); 216 AddUsedCfiGlobal(GS.first); 217 AddUsedThings(GS.second); 218 } 219 220 // Imported functions may introduce new uses of type identifier resolutions, 221 // so we need to collect their used resolutions as well. 222 for (auto &ImpM : ImportList) 223 for (auto &ImpF : ImpM.second) 224 AddUsedThings(Index.findSummaryInModule(ImpF, ImpM.first())); 225 226 auto AddTypeIdSummary = [&](StringRef TId, const TypeIdSummary &S) { 227 AddString(TId); 228 229 AddUnsigned(S.TTRes.TheKind); 230 AddUnsigned(S.TTRes.SizeM1BitWidth); 231 232 AddUint64(S.TTRes.AlignLog2); 233 AddUint64(S.TTRes.SizeM1); 234 AddUint64(S.TTRes.BitMask); 235 AddUint64(S.TTRes.InlineBits); 236 237 AddUint64(S.WPDRes.size()); 238 for (auto &WPD : S.WPDRes) { 239 AddUnsigned(WPD.first); 240 AddUnsigned(WPD.second.TheKind); 241 AddString(WPD.second.SingleImplName); 242 243 AddUint64(WPD.second.ResByArg.size()); 244 for (auto &ByArg : WPD.second.ResByArg) { 245 AddUint64(ByArg.first.size()); 246 for (uint64_t Arg : ByArg.first) 247 AddUint64(Arg); 248 AddUnsigned(ByArg.second.TheKind); 249 AddUint64(ByArg.second.Info); 250 AddUnsigned(ByArg.second.Byte); 251 AddUnsigned(ByArg.second.Bit); 252 } 253 } 254 }; 255 256 // Include the hash for all type identifiers used by this module. 257 for (GlobalValue::GUID TId : UsedTypeIds) { 258 auto SummariesI = TypeIdSummariesByGuid.find(TId); 259 if (SummariesI != TypeIdSummariesByGuid.end()) 260 for (auto *Summary : SummariesI->second) 261 AddTypeIdSummary(Summary->first, Summary->second); 262 } 263 264 AddUnsigned(UsedCfiDefs.size()); 265 for (auto &V : UsedCfiDefs) 266 AddUint64(V); 267 268 AddUnsigned(UsedCfiDecls.size()); 269 for (auto &V : UsedCfiDecls) 270 AddUint64(V); 271 272 if (!Conf.SampleProfile.empty()) { 273 auto FileOrErr = MemoryBuffer::getFile(Conf.SampleProfile); 274 if (FileOrErr) 275 Hasher.update(FileOrErr.get()->getBuffer()); 276 } 277 278 Key = toHex(Hasher.result()); 279 } 280 281 static void thinLTOResolveWeakForLinkerGUID( 282 GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID, 283 DenseSet<GlobalValueSummary *> &GlobalInvolvedWithAlias, 284 function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)> 285 isPrevailing, 286 function_ref<void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)> 287 recordNewLinkage) { 288 for (auto &S : GVSummaryList) { 289 GlobalValue::LinkageTypes OriginalLinkage = S->linkage(); 290 if (!GlobalValue::isWeakForLinker(OriginalLinkage)) 291 continue; 292 // We need to emit only one of these. The prevailing module will keep it, 293 // but turned into a weak, while the others will drop it when possible. 294 // This is both a compile-time optimization and a correctness 295 // transformation. This is necessary for correctness when we have exported 296 // a reference - we need to convert the linkonce to weak to 297 // ensure a copy is kept to satisfy the exported reference. 298 // FIXME: We may want to split the compile time and correctness 299 // aspects into separate routines. 300 if (isPrevailing(GUID, S.get())) { 301 if (GlobalValue::isLinkOnceLinkage(OriginalLinkage)) 302 S->setLinkage(GlobalValue::getWeakLinkage( 303 GlobalValue::isLinkOnceODRLinkage(OriginalLinkage))); 304 } 305 // Alias and aliasee can't be turned into available_externally. 306 else if (!isa<AliasSummary>(S.get()) && 307 !GlobalInvolvedWithAlias.count(S.get())) 308 S->setLinkage(GlobalValue::AvailableExternallyLinkage); 309 if (S->linkage() != OriginalLinkage) 310 recordNewLinkage(S->modulePath(), GUID, S->linkage()); 311 } 312 } 313 314 // Resolve Weak and LinkOnce values in the \p Index. 315 // 316 // We'd like to drop these functions if they are no longer referenced in the 317 // current module. However there is a chance that another module is still 318 // referencing them because of the import. We make sure we always emit at least 319 // one copy. 320 void llvm::thinLTOResolveWeakForLinkerInIndex( 321 ModuleSummaryIndex &Index, 322 function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)> 323 isPrevailing, 324 function_ref<void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)> 325 recordNewLinkage) { 326 // We won't optimize the globals that are referenced by an alias for now 327 // Ideally we should turn the alias into a global and duplicate the definition 328 // when needed. 329 DenseSet<GlobalValueSummary *> GlobalInvolvedWithAlias; 330 for (auto &I : Index) 331 for (auto &S : I.second.SummaryList) 332 if (auto AS = dyn_cast<AliasSummary>(S.get())) 333 GlobalInvolvedWithAlias.insert(&AS->getAliasee()); 334 335 for (auto &I : Index) 336 thinLTOResolveWeakForLinkerGUID(I.second.SummaryList, I.first, 337 GlobalInvolvedWithAlias, isPrevailing, 338 recordNewLinkage); 339 } 340 341 static void thinLTOInternalizeAndPromoteGUID( 342 GlobalValueSummaryList &GVSummaryList, GlobalValue::GUID GUID, 343 function_ref<bool(StringRef, GlobalValue::GUID)> isExported) { 344 for (auto &S : GVSummaryList) { 345 if (isExported(S->modulePath(), GUID)) { 346 if (GlobalValue::isLocalLinkage(S->linkage())) 347 S->setLinkage(GlobalValue::ExternalLinkage); 348 } else if (!GlobalValue::isLocalLinkage(S->linkage())) 349 S->setLinkage(GlobalValue::InternalLinkage); 350 } 351 } 352 353 // Update the linkages in the given \p Index to mark exported values 354 // as external and non-exported values as internal. 355 void llvm::thinLTOInternalizeAndPromoteInIndex( 356 ModuleSummaryIndex &Index, 357 function_ref<bool(StringRef, GlobalValue::GUID)> isExported) { 358 for (auto &I : Index) 359 thinLTOInternalizeAndPromoteGUID(I.second.SummaryList, I.first, isExported); 360 } 361 362 // Requires a destructor for std::vector<InputModule>. 363 InputFile::~InputFile() = default; 364 365 Expected<std::unique_ptr<InputFile>> InputFile::create(MemoryBufferRef Object) { 366 std::unique_ptr<InputFile> File(new InputFile); 367 368 Expected<IRSymtabFile> FOrErr = readIRSymtab(Object); 369 if (!FOrErr) 370 return FOrErr.takeError(); 371 372 File->TargetTriple = FOrErr->TheReader.getTargetTriple(); 373 File->SourceFileName = FOrErr->TheReader.getSourceFileName(); 374 File->COFFLinkerOpts = FOrErr->TheReader.getCOFFLinkerOpts(); 375 File->ComdatTable = FOrErr->TheReader.getComdatTable(); 376 377 for (unsigned I = 0; I != FOrErr->Mods.size(); ++I) { 378 size_t Begin = File->Symbols.size(); 379 for (const irsymtab::Reader::SymbolRef &Sym : 380 FOrErr->TheReader.module_symbols(I)) 381 // Skip symbols that are irrelevant to LTO. Note that this condition needs 382 // to match the one in Skip() in LTO::addRegularLTO(). 383 if (Sym.isGlobal() && !Sym.isFormatSpecific()) 384 File->Symbols.push_back(Sym); 385 File->ModuleSymIndices.push_back({Begin, File->Symbols.size()}); 386 } 387 388 File->Mods = FOrErr->Mods; 389 File->Strtab = std::move(FOrErr->Strtab); 390 return std::move(File); 391 } 392 393 StringRef InputFile::getName() const { 394 return Mods[0].getModuleIdentifier(); 395 } 396 397 LTO::RegularLTOState::RegularLTOState(unsigned ParallelCodeGenParallelismLevel, 398 Config &Conf) 399 : ParallelCodeGenParallelismLevel(ParallelCodeGenParallelismLevel), 400 Ctx(Conf), CombinedModule(llvm::make_unique<Module>("ld-temp.o", Ctx)), 401 Mover(llvm::make_unique<IRMover>(*CombinedModule)) {} 402 403 LTO::ThinLTOState::ThinLTOState(ThinBackend Backend) 404 : Backend(Backend), CombinedIndex(/*HaveGVs*/ false) { 405 if (!Backend) 406 this->Backend = 407 createInProcessThinBackend(llvm::heavyweight_hardware_concurrency()); 408 } 409 410 LTO::LTO(Config Conf, ThinBackend Backend, 411 unsigned ParallelCodeGenParallelismLevel) 412 : Conf(std::move(Conf)), 413 RegularLTO(ParallelCodeGenParallelismLevel, this->Conf), 414 ThinLTO(std::move(Backend)) {} 415 416 // Requires a destructor for MapVector<BitcodeModule>. 417 LTO::~LTO() = default; 418 419 // Add the symbols in the given module to the GlobalResolutions map, and resolve 420 // their partitions. 421 void LTO::addModuleToGlobalRes(ArrayRef<InputFile::Symbol> Syms, 422 ArrayRef<SymbolResolution> Res, 423 unsigned Partition, bool InSummary) { 424 auto *ResI = Res.begin(); 425 auto *ResE = Res.end(); 426 (void)ResE; 427 for (const InputFile::Symbol &Sym : Syms) { 428 assert(ResI != ResE); 429 SymbolResolution Res = *ResI++; 430 431 StringRef Name = Sym.getName(); 432 Triple TT(RegularLTO.CombinedModule->getTargetTriple()); 433 // Strip the __imp_ prefix from COFF dllimport symbols (similar to the 434 // way they are handled by lld), otherwise we can end up with two 435 // global resolutions (one with and one for a copy of the symbol without). 436 if (TT.isOSBinFormatCOFF() && Name.startswith("__imp_")) 437 Name = Name.substr(strlen("__imp_")); 438 auto &GlobalRes = GlobalResolutions[Name]; 439 GlobalRes.UnnamedAddr &= Sym.isUnnamedAddr(); 440 if (Res.Prevailing) { 441 assert(!GlobalRes.Prevailing && 442 "Multiple prevailing defs are not allowed"); 443 GlobalRes.Prevailing = true; 444 GlobalRes.IRName = Sym.getIRName(); 445 } else if (!GlobalRes.Prevailing && GlobalRes.IRName.empty()) { 446 // Sometimes it can be two copies of symbol in a module and prevailing 447 // symbol can have no IR name. That might happen if symbol is defined in 448 // module level inline asm block. In case we have multiple modules with 449 // the same symbol we want to use IR name of the prevailing symbol. 450 // Otherwise, if we haven't seen a prevailing symbol, set the name so that 451 // we can later use it to check if there is any prevailing copy in IR. 452 GlobalRes.IRName = Sym.getIRName(); 453 } 454 455 // Set the partition to external if we know it is re-defined by the linker 456 // with -defsym or -wrap options, used elsewhere, e.g. it is visible to a 457 // regular object, is referenced from llvm.compiler_used, or was already 458 // recorded as being referenced from a different partition. 459 if (Res.LinkerRedefined || Res.VisibleToRegularObj || Sym.isUsed() || 460 (GlobalRes.Partition != GlobalResolution::Unknown && 461 GlobalRes.Partition != Partition)) { 462 GlobalRes.Partition = GlobalResolution::External; 463 } else 464 // First recorded reference, save the current partition. 465 GlobalRes.Partition = Partition; 466 467 // Flag as visible outside of summary if visible from a regular object or 468 // from a module that does not have a summary. 469 GlobalRes.VisibleOutsideSummary |= 470 (Res.VisibleToRegularObj || Sym.isUsed() || !InSummary); 471 } 472 } 473 474 static void writeToResolutionFile(raw_ostream &OS, InputFile *Input, 475 ArrayRef<SymbolResolution> Res) { 476 StringRef Path = Input->getName(); 477 OS << Path << '\n'; 478 auto ResI = Res.begin(); 479 for (const InputFile::Symbol &Sym : Input->symbols()) { 480 assert(ResI != Res.end()); 481 SymbolResolution Res = *ResI++; 482 483 OS << "-r=" << Path << ',' << Sym.getName() << ','; 484 if (Res.Prevailing) 485 OS << 'p'; 486 if (Res.FinalDefinitionInLinkageUnit) 487 OS << 'l'; 488 if (Res.VisibleToRegularObj) 489 OS << 'x'; 490 if (Res.LinkerRedefined) 491 OS << 'r'; 492 OS << '\n'; 493 } 494 OS.flush(); 495 assert(ResI == Res.end()); 496 } 497 498 Error LTO::add(std::unique_ptr<InputFile> Input, 499 ArrayRef<SymbolResolution> Res) { 500 assert(!CalledGetMaxTasks); 501 502 if (Conf.ResolutionFile) 503 writeToResolutionFile(*Conf.ResolutionFile, Input.get(), Res); 504 505 if (RegularLTO.CombinedModule->getTargetTriple().empty()) 506 RegularLTO.CombinedModule->setTargetTriple(Input->getTargetTriple()); 507 508 const SymbolResolution *ResI = Res.begin(); 509 for (unsigned I = 0; I != Input->Mods.size(); ++I) 510 if (Error Err = addModule(*Input, I, ResI, Res.end())) 511 return Err; 512 513 assert(ResI == Res.end()); 514 return Error::success(); 515 } 516 517 Error LTO::addModule(InputFile &Input, unsigned ModI, 518 const SymbolResolution *&ResI, 519 const SymbolResolution *ResE) { 520 Expected<BitcodeLTOInfo> LTOInfo = Input.Mods[ModI].getLTOInfo(); 521 if (!LTOInfo) 522 return LTOInfo.takeError(); 523 524 BitcodeModule BM = Input.Mods[ModI]; 525 auto ModSyms = Input.module_symbols(ModI); 526 addModuleToGlobalRes(ModSyms, {ResI, ResE}, 527 LTOInfo->IsThinLTO ? ThinLTO.ModuleMap.size() + 1 : 0, 528 LTOInfo->HasSummary); 529 530 if (LTOInfo->IsThinLTO) 531 return addThinLTO(BM, ModSyms, ResI, ResE); 532 533 Expected<RegularLTOState::AddedModule> ModOrErr = 534 addRegularLTO(BM, ModSyms, ResI, ResE); 535 if (!ModOrErr) 536 return ModOrErr.takeError(); 537 538 if (!LTOInfo->HasSummary) 539 return linkRegularLTO(std::move(*ModOrErr), /*LivenessFromIndex=*/false); 540 541 // Regular LTO module summaries are added to a dummy module that represents 542 // the combined regular LTO module. 543 if (Error Err = BM.readSummary(ThinLTO.CombinedIndex, "", -1ull)) 544 return Err; 545 RegularLTO.ModsWithSummaries.push_back(std::move(*ModOrErr)); 546 return Error::success(); 547 } 548 549 // Checks whether the given global value is in a non-prevailing comdat 550 // (comdat containing values the linker indicated were not prevailing, 551 // which we then dropped to available_externally), and if so, removes 552 // it from the comdat. This is called for all global values to ensure the 553 // comdat is empty rather than leaving an incomplete comdat. It is needed for 554 // regular LTO modules, in case we are in a mixed-LTO mode (both regular 555 // and thin LTO modules) compilation. Since the regular LTO module will be 556 // linked first in the final native link, we want to make sure the linker 557 // doesn't select any of these incomplete comdats that would be left 558 // in the regular LTO module without this cleanup. 559 static void 560 handleNonPrevailingComdat(GlobalValue &GV, 561 std::set<const Comdat *> &NonPrevailingComdats) { 562 Comdat *C = GV.getComdat(); 563 if (!C) 564 return; 565 566 if (!NonPrevailingComdats.count(C)) 567 return; 568 569 // Additionally need to drop externally visible global values from the comdat 570 // to available_externally, so that there aren't multiply defined linker 571 // errors. 572 if (!GV.hasLocalLinkage()) 573 GV.setLinkage(GlobalValue::AvailableExternallyLinkage); 574 575 if (auto GO = dyn_cast<GlobalObject>(&GV)) 576 GO->setComdat(nullptr); 577 } 578 579 // Add a regular LTO object to the link. 580 // The resulting module needs to be linked into the combined LTO module with 581 // linkRegularLTO. 582 Expected<LTO::RegularLTOState::AddedModule> 583 LTO::addRegularLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms, 584 const SymbolResolution *&ResI, 585 const SymbolResolution *ResE) { 586 RegularLTOState::AddedModule Mod; 587 Expected<std::unique_ptr<Module>> MOrErr = 588 BM.getLazyModule(RegularLTO.Ctx, /*ShouldLazyLoadMetadata*/ true, 589 /*IsImporting*/ false); 590 if (!MOrErr) 591 return MOrErr.takeError(); 592 Module &M = **MOrErr; 593 Mod.M = std::move(*MOrErr); 594 595 if (Error Err = M.materializeMetadata()) 596 return std::move(Err); 597 UpgradeDebugInfo(M); 598 599 ModuleSymbolTable SymTab; 600 SymTab.addModule(&M); 601 602 for (GlobalVariable &GV : M.globals()) 603 if (GV.hasAppendingLinkage()) 604 Mod.Keep.push_back(&GV); 605 606 DenseSet<GlobalObject *> AliasedGlobals; 607 for (auto &GA : M.aliases()) 608 if (GlobalObject *GO = GA.getBaseObject()) 609 AliasedGlobals.insert(GO); 610 611 // In this function we need IR GlobalValues matching the symbols in Syms 612 // (which is not backed by a module), so we need to enumerate them in the same 613 // order. The symbol enumeration order of a ModuleSymbolTable intentionally 614 // matches the order of an irsymtab, but when we read the irsymtab in 615 // InputFile::create we omit some symbols that are irrelevant to LTO. The 616 // Skip() function skips the same symbols from the module as InputFile does 617 // from the symbol table. 618 auto MsymI = SymTab.symbols().begin(), MsymE = SymTab.symbols().end(); 619 auto Skip = [&]() { 620 while (MsymI != MsymE) { 621 auto Flags = SymTab.getSymbolFlags(*MsymI); 622 if ((Flags & object::BasicSymbolRef::SF_Global) && 623 !(Flags & object::BasicSymbolRef::SF_FormatSpecific)) 624 return; 625 ++MsymI; 626 } 627 }; 628 Skip(); 629 630 std::set<const Comdat *> NonPrevailingComdats; 631 for (const InputFile::Symbol &Sym : Syms) { 632 assert(ResI != ResE); 633 SymbolResolution Res = *ResI++; 634 635 assert(MsymI != MsymE); 636 ModuleSymbolTable::Symbol Msym = *MsymI++; 637 Skip(); 638 639 if (GlobalValue *GV = Msym.dyn_cast<GlobalValue *>()) { 640 if (Res.Prevailing) { 641 if (Sym.isUndefined()) 642 continue; 643 Mod.Keep.push_back(GV); 644 // For symbols re-defined with linker -wrap and -defsym options, 645 // set the linkage to weak to inhibit IPO. The linkage will be 646 // restored by the linker. 647 if (Res.LinkerRedefined) 648 GV->setLinkage(GlobalValue::WeakAnyLinkage); 649 650 GlobalValue::LinkageTypes OriginalLinkage = GV->getLinkage(); 651 if (GlobalValue::isLinkOnceLinkage(OriginalLinkage)) 652 GV->setLinkage(GlobalValue::getWeakLinkage( 653 GlobalValue::isLinkOnceODRLinkage(OriginalLinkage))); 654 } else if (isa<GlobalObject>(GV) && 655 (GV->hasLinkOnceODRLinkage() || GV->hasWeakODRLinkage() || 656 GV->hasAvailableExternallyLinkage()) && 657 !AliasedGlobals.count(cast<GlobalObject>(GV))) { 658 // Any of the above three types of linkage indicates that the 659 // chosen prevailing symbol will have the same semantics as this copy of 660 // the symbol, so we may be able to link it with available_externally 661 // linkage. We will decide later whether to do that when we link this 662 // module (in linkRegularLTO), based on whether it is undefined. 663 Mod.Keep.push_back(GV); 664 GV->setLinkage(GlobalValue::AvailableExternallyLinkage); 665 if (GV->hasComdat()) 666 NonPrevailingComdats.insert(GV->getComdat()); 667 cast<GlobalObject>(GV)->setComdat(nullptr); 668 } 669 670 // Set the 'local' flag based on the linker resolution for this symbol. 671 if (Res.FinalDefinitionInLinkageUnit) 672 GV->setDSOLocal(true); 673 } 674 // Common resolution: collect the maximum size/alignment over all commons. 675 // We also record if we see an instance of a common as prevailing, so that 676 // if none is prevailing we can ignore it later. 677 if (Sym.isCommon()) { 678 // FIXME: We should figure out what to do about commons defined by asm. 679 // For now they aren't reported correctly by ModuleSymbolTable. 680 auto &CommonRes = RegularLTO.Commons[Sym.getIRName()]; 681 CommonRes.Size = std::max(CommonRes.Size, Sym.getCommonSize()); 682 CommonRes.Align = std::max(CommonRes.Align, Sym.getCommonAlignment()); 683 CommonRes.Prevailing |= Res.Prevailing; 684 } 685 686 } 687 if (!M.getComdatSymbolTable().empty()) 688 for (GlobalValue &GV : M.global_values()) 689 handleNonPrevailingComdat(GV, NonPrevailingComdats); 690 assert(MsymI == MsymE); 691 return std::move(Mod); 692 } 693 694 Error LTO::linkRegularLTO(RegularLTOState::AddedModule Mod, 695 bool LivenessFromIndex) { 696 std::vector<GlobalValue *> Keep; 697 for (GlobalValue *GV : Mod.Keep) { 698 if (LivenessFromIndex && !ThinLTO.CombinedIndex.isGUIDLive(GV->getGUID())) 699 continue; 700 701 if (!GV->hasAvailableExternallyLinkage()) { 702 Keep.push_back(GV); 703 continue; 704 } 705 706 // Only link available_externally definitions if we don't already have a 707 // definition. 708 GlobalValue *CombinedGV = 709 RegularLTO.CombinedModule->getNamedValue(GV->getName()); 710 if (CombinedGV && !CombinedGV->isDeclaration()) 711 continue; 712 713 Keep.push_back(GV); 714 } 715 716 return RegularLTO.Mover->move(std::move(Mod.M), Keep, 717 [](GlobalValue &, IRMover::ValueAdder) {}, 718 /* IsPerformingImport */ false); 719 } 720 721 // Add a ThinLTO module to the link. 722 Error LTO::addThinLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms, 723 const SymbolResolution *&ResI, 724 const SymbolResolution *ResE) { 725 if (Error Err = 726 BM.readSummary(ThinLTO.CombinedIndex, BM.getModuleIdentifier(), 727 ThinLTO.ModuleMap.size())) 728 return Err; 729 730 for (const InputFile::Symbol &Sym : Syms) { 731 assert(ResI != ResE); 732 SymbolResolution Res = *ResI++; 733 734 if (!Sym.getIRName().empty()) { 735 auto GUID = GlobalValue::getGUID(GlobalValue::getGlobalIdentifier( 736 Sym.getIRName(), GlobalValue::ExternalLinkage, "")); 737 if (Res.Prevailing) { 738 ThinLTO.PrevailingModuleForGUID[GUID] = BM.getModuleIdentifier(); 739 740 // For linker redefined symbols (via --wrap or --defsym) we want to 741 // switch the linkage to `weak` to prevent IPOs from happening. 742 // Find the summary in the module for this very GV and record the new 743 // linkage so that we can switch it when we import the GV. 744 if (Res.LinkerRedefined) 745 if (auto S = ThinLTO.CombinedIndex.findSummaryInModule( 746 GUID, BM.getModuleIdentifier())) 747 S->setLinkage(GlobalValue::WeakAnyLinkage); 748 } 749 750 // If the linker resolved the symbol to a local definition then mark it 751 // as local in the summary for the module we are adding. 752 if (Res.FinalDefinitionInLinkageUnit) { 753 if (auto S = ThinLTO.CombinedIndex.findSummaryInModule( 754 GUID, BM.getModuleIdentifier())) { 755 S->setDSOLocal(true); 756 } 757 } 758 } 759 } 760 761 if (!ThinLTO.ModuleMap.insert({BM.getModuleIdentifier(), BM}).second) 762 return make_error<StringError>( 763 "Expected at most one ThinLTO module per bitcode file", 764 inconvertibleErrorCode()); 765 766 return Error::success(); 767 } 768 769 unsigned LTO::getMaxTasks() const { 770 CalledGetMaxTasks = true; 771 return RegularLTO.ParallelCodeGenParallelismLevel + ThinLTO.ModuleMap.size(); 772 } 773 774 Error LTO::run(AddStreamFn AddStream, NativeObjectCache Cache) { 775 // Compute "dead" symbols, we don't want to import/export these! 776 DenseSet<GlobalValue::GUID> GUIDPreservedSymbols; 777 DenseMap<GlobalValue::GUID, PrevailingType> GUIDPrevailingResolutions; 778 for (auto &Res : GlobalResolutions) { 779 // Normally resolution have IR name of symbol. We can do nothing here 780 // otherwise. See comments in GlobalResolution struct for more details. 781 if (Res.second.IRName.empty()) 782 continue; 783 784 GlobalValue::GUID GUID = GlobalValue::getGUID( 785 GlobalValue::dropLLVMManglingEscape(Res.second.IRName)); 786 787 if (Res.second.VisibleOutsideSummary && Res.second.Prevailing) 788 GUIDPreservedSymbols.insert(GlobalValue::getGUID( 789 GlobalValue::dropLLVMManglingEscape(Res.second.IRName))); 790 791 GUIDPrevailingResolutions[GUID] = 792 Res.second.Prevailing ? PrevailingType::Yes : PrevailingType::No; 793 } 794 795 auto isPrevailing = [&](GlobalValue::GUID G) { 796 auto It = GUIDPrevailingResolutions.find(G); 797 if (It == GUIDPrevailingResolutions.end()) 798 return PrevailingType::Unknown; 799 return It->second; 800 }; 801 computeDeadSymbols(ThinLTO.CombinedIndex, GUIDPreservedSymbols, isPrevailing); 802 803 // Setup output file to emit statistics. 804 std::unique_ptr<ToolOutputFile> StatsFile = nullptr; 805 if (!Conf.StatsFile.empty()) { 806 EnableStatistics(false); 807 std::error_code EC; 808 StatsFile = 809 llvm::make_unique<ToolOutputFile>(Conf.StatsFile, EC, sys::fs::F_None); 810 if (EC) 811 return errorCodeToError(EC); 812 StatsFile->keep(); 813 } 814 815 Error Result = runRegularLTO(AddStream); 816 if (!Result) 817 Result = runThinLTO(AddStream, Cache); 818 819 if (StatsFile) 820 PrintStatisticsJSON(StatsFile->os()); 821 822 return Result; 823 } 824 825 Error LTO::runRegularLTO(AddStreamFn AddStream) { 826 for (auto &M : RegularLTO.ModsWithSummaries) 827 if (Error Err = linkRegularLTO(std::move(M), 828 /*LivenessFromIndex=*/true)) 829 return Err; 830 831 // Make sure commons have the right size/alignment: we kept the largest from 832 // all the prevailing when adding the inputs, and we apply it here. 833 const DataLayout &DL = RegularLTO.CombinedModule->getDataLayout(); 834 for (auto &I : RegularLTO.Commons) { 835 if (!I.second.Prevailing) 836 // Don't do anything if no instance of this common was prevailing. 837 continue; 838 GlobalVariable *OldGV = RegularLTO.CombinedModule->getNamedGlobal(I.first); 839 if (OldGV && DL.getTypeAllocSize(OldGV->getValueType()) == I.second.Size) { 840 // Don't create a new global if the type is already correct, just make 841 // sure the alignment is correct. 842 OldGV->setAlignment(I.second.Align); 843 continue; 844 } 845 ArrayType *Ty = 846 ArrayType::get(Type::getInt8Ty(RegularLTO.Ctx), I.second.Size); 847 auto *GV = new GlobalVariable(*RegularLTO.CombinedModule, Ty, false, 848 GlobalValue::CommonLinkage, 849 ConstantAggregateZero::get(Ty), ""); 850 GV->setAlignment(I.second.Align); 851 if (OldGV) { 852 OldGV->replaceAllUsesWith(ConstantExpr::getBitCast(GV, OldGV->getType())); 853 GV->takeName(OldGV); 854 OldGV->eraseFromParent(); 855 } else { 856 GV->setName(I.first); 857 } 858 } 859 860 if (Conf.PreOptModuleHook && 861 !Conf.PreOptModuleHook(0, *RegularLTO.CombinedModule)) 862 return Error::success(); 863 864 if (!Conf.CodeGenOnly) { 865 for (const auto &R : GlobalResolutions) { 866 if (!R.second.isPrevailingIRSymbol()) 867 continue; 868 if (R.second.Partition != 0 && 869 R.second.Partition != GlobalResolution::External) 870 continue; 871 872 GlobalValue *GV = 873 RegularLTO.CombinedModule->getNamedValue(R.second.IRName); 874 // Ignore symbols defined in other partitions. 875 // Also skip declarations, which are not allowed to have internal linkage. 876 if (!GV || GV->hasLocalLinkage() || GV->isDeclaration()) 877 continue; 878 GV->setUnnamedAddr(R.second.UnnamedAddr ? GlobalValue::UnnamedAddr::Global 879 : GlobalValue::UnnamedAddr::None); 880 if (R.second.Partition == 0) 881 GV->setLinkage(GlobalValue::InternalLinkage); 882 } 883 884 if (Conf.PostInternalizeModuleHook && 885 !Conf.PostInternalizeModuleHook(0, *RegularLTO.CombinedModule)) 886 return Error::success(); 887 } 888 return backend(Conf, AddStream, RegularLTO.ParallelCodeGenParallelismLevel, 889 std::move(RegularLTO.CombinedModule), ThinLTO.CombinedIndex); 890 } 891 892 /// This class defines the interface to the ThinLTO backend. 893 class lto::ThinBackendProc { 894 protected: 895 Config &Conf; 896 ModuleSummaryIndex &CombinedIndex; 897 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries; 898 899 public: 900 ThinBackendProc(Config &Conf, ModuleSummaryIndex &CombinedIndex, 901 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries) 902 : Conf(Conf), CombinedIndex(CombinedIndex), 903 ModuleToDefinedGVSummaries(ModuleToDefinedGVSummaries) {} 904 905 virtual ~ThinBackendProc() {} 906 virtual Error start( 907 unsigned Task, BitcodeModule BM, 908 const FunctionImporter::ImportMapTy &ImportList, 909 const FunctionImporter::ExportSetTy &ExportList, 910 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR, 911 MapVector<StringRef, BitcodeModule> &ModuleMap) = 0; 912 virtual Error wait() = 0; 913 }; 914 915 namespace { 916 class InProcessThinBackend : public ThinBackendProc { 917 ThreadPool BackendThreadPool; 918 AddStreamFn AddStream; 919 NativeObjectCache Cache; 920 TypeIdSummariesByGuidTy TypeIdSummariesByGuid; 921 std::set<GlobalValue::GUID> CfiFunctionDefs; 922 std::set<GlobalValue::GUID> CfiFunctionDecls; 923 924 Optional<Error> Err; 925 std::mutex ErrMu; 926 927 public: 928 InProcessThinBackend( 929 Config &Conf, ModuleSummaryIndex &CombinedIndex, 930 unsigned ThinLTOParallelismLevel, 931 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries, 932 AddStreamFn AddStream, NativeObjectCache Cache) 933 : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries), 934 BackendThreadPool(ThinLTOParallelismLevel), 935 AddStream(std::move(AddStream)), Cache(std::move(Cache)) { 936 // Create a mapping from type identifier GUIDs to type identifier summaries. 937 // This allows backends to use the type identifier GUIDs stored in the 938 // function summaries to determine which type identifier summaries affect 939 // each function without needing to compute GUIDs in each backend. 940 for (auto &TId : CombinedIndex.typeIds()) 941 TypeIdSummariesByGuid[GlobalValue::getGUID(TId.first)].push_back(&TId); 942 for (auto &Name : CombinedIndex.cfiFunctionDefs()) 943 CfiFunctionDefs.insert( 944 GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(Name))); 945 for (auto &Name : CombinedIndex.cfiFunctionDecls()) 946 CfiFunctionDecls.insert( 947 GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(Name))); 948 } 949 950 Error runThinLTOBackendThread( 951 AddStreamFn AddStream, NativeObjectCache Cache, unsigned Task, 952 BitcodeModule BM, ModuleSummaryIndex &CombinedIndex, 953 const FunctionImporter::ImportMapTy &ImportList, 954 const FunctionImporter::ExportSetTy &ExportList, 955 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR, 956 const GVSummaryMapTy &DefinedGlobals, 957 MapVector<StringRef, BitcodeModule> &ModuleMap, 958 const TypeIdSummariesByGuidTy &TypeIdSummariesByGuid) { 959 auto RunThinBackend = [&](AddStreamFn AddStream) { 960 LTOLLVMContext BackendContext(Conf); 961 Expected<std::unique_ptr<Module>> MOrErr = BM.parseModule(BackendContext); 962 if (!MOrErr) 963 return MOrErr.takeError(); 964 965 return thinBackend(Conf, Task, AddStream, **MOrErr, CombinedIndex, 966 ImportList, DefinedGlobals, ModuleMap); 967 }; 968 969 auto ModuleID = BM.getModuleIdentifier(); 970 971 if (!Cache || !CombinedIndex.modulePaths().count(ModuleID) || 972 all_of(CombinedIndex.getModuleHash(ModuleID), 973 [](uint32_t V) { return V == 0; })) 974 // Cache disabled or no entry for this module in the combined index or 975 // no module hash. 976 return RunThinBackend(AddStream); 977 978 SmallString<40> Key; 979 // The module may be cached, this helps handling it. 980 computeCacheKey(Key, Conf, CombinedIndex, ModuleID, ImportList, ExportList, 981 ResolvedODR, DefinedGlobals, TypeIdSummariesByGuid, 982 CfiFunctionDefs, CfiFunctionDecls); 983 if (AddStreamFn CacheAddStream = Cache(Task, Key)) 984 return RunThinBackend(CacheAddStream); 985 986 return Error::success(); 987 } 988 989 Error start( 990 unsigned Task, BitcodeModule BM, 991 const FunctionImporter::ImportMapTy &ImportList, 992 const FunctionImporter::ExportSetTy &ExportList, 993 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR, 994 MapVector<StringRef, BitcodeModule> &ModuleMap) override { 995 StringRef ModulePath = BM.getModuleIdentifier(); 996 assert(ModuleToDefinedGVSummaries.count(ModulePath)); 997 const GVSummaryMapTy &DefinedGlobals = 998 ModuleToDefinedGVSummaries.find(ModulePath)->second; 999 BackendThreadPool.async( 1000 [=](BitcodeModule BM, ModuleSummaryIndex &CombinedIndex, 1001 const FunctionImporter::ImportMapTy &ImportList, 1002 const FunctionImporter::ExportSetTy &ExportList, 1003 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> 1004 &ResolvedODR, 1005 const GVSummaryMapTy &DefinedGlobals, 1006 MapVector<StringRef, BitcodeModule> &ModuleMap, 1007 const TypeIdSummariesByGuidTy &TypeIdSummariesByGuid) { 1008 Error E = runThinLTOBackendThread( 1009 AddStream, Cache, Task, BM, CombinedIndex, ImportList, ExportList, 1010 ResolvedODR, DefinedGlobals, ModuleMap, TypeIdSummariesByGuid); 1011 if (E) { 1012 std::unique_lock<std::mutex> L(ErrMu); 1013 if (Err) 1014 Err = joinErrors(std::move(*Err), std::move(E)); 1015 else 1016 Err = std::move(E); 1017 } 1018 }, 1019 BM, std::ref(CombinedIndex), std::ref(ImportList), std::ref(ExportList), 1020 std::ref(ResolvedODR), std::ref(DefinedGlobals), std::ref(ModuleMap), 1021 std::ref(TypeIdSummariesByGuid)); 1022 return Error::success(); 1023 } 1024 1025 Error wait() override { 1026 BackendThreadPool.wait(); 1027 if (Err) 1028 return std::move(*Err); 1029 else 1030 return Error::success(); 1031 } 1032 }; 1033 } // end anonymous namespace 1034 1035 ThinBackend lto::createInProcessThinBackend(unsigned ParallelismLevel) { 1036 return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex, 1037 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries, 1038 AddStreamFn AddStream, NativeObjectCache Cache) { 1039 return llvm::make_unique<InProcessThinBackend>( 1040 Conf, CombinedIndex, ParallelismLevel, ModuleToDefinedGVSummaries, 1041 AddStream, Cache); 1042 }; 1043 } 1044 1045 // Given the original \p Path to an output file, replace any path 1046 // prefix matching \p OldPrefix with \p NewPrefix. Also, create the 1047 // resulting directory if it does not yet exist. 1048 std::string lto::getThinLTOOutputFile(const std::string &Path, 1049 const std::string &OldPrefix, 1050 const std::string &NewPrefix) { 1051 if (OldPrefix.empty() && NewPrefix.empty()) 1052 return Path; 1053 SmallString<128> NewPath(Path); 1054 llvm::sys::path::replace_path_prefix(NewPath, OldPrefix, NewPrefix); 1055 StringRef ParentPath = llvm::sys::path::parent_path(NewPath.str()); 1056 if (!ParentPath.empty()) { 1057 // Make sure the new directory exists, creating it if necessary. 1058 if (std::error_code EC = llvm::sys::fs::create_directories(ParentPath)) 1059 llvm::errs() << "warning: could not create directory '" << ParentPath 1060 << "': " << EC.message() << '\n'; 1061 } 1062 return NewPath.str(); 1063 } 1064 1065 namespace { 1066 class WriteIndexesThinBackend : public ThinBackendProc { 1067 std::string OldPrefix, NewPrefix; 1068 bool ShouldEmitImportsFiles; 1069 raw_fd_ostream *LinkedObjectsFile; 1070 lto::IndexWriteCallback OnWrite; 1071 1072 public: 1073 WriteIndexesThinBackend( 1074 Config &Conf, ModuleSummaryIndex &CombinedIndex, 1075 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries, 1076 std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles, 1077 raw_fd_ostream *LinkedObjectsFile, lto::IndexWriteCallback OnWrite) 1078 : ThinBackendProc(Conf, CombinedIndex, ModuleToDefinedGVSummaries), 1079 OldPrefix(OldPrefix), NewPrefix(NewPrefix), 1080 ShouldEmitImportsFiles(ShouldEmitImportsFiles), 1081 LinkedObjectsFile(LinkedObjectsFile), OnWrite(OnWrite) {} 1082 1083 Error start( 1084 unsigned Task, BitcodeModule BM, 1085 const FunctionImporter::ImportMapTy &ImportList, 1086 const FunctionImporter::ExportSetTy &ExportList, 1087 const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR, 1088 MapVector<StringRef, BitcodeModule> &ModuleMap) override { 1089 StringRef ModulePath = BM.getModuleIdentifier(); 1090 std::string NewModulePath = 1091 getThinLTOOutputFile(ModulePath, OldPrefix, NewPrefix); 1092 1093 if (LinkedObjectsFile) 1094 *LinkedObjectsFile << NewModulePath << '\n'; 1095 1096 std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex; 1097 gatherImportedSummariesForModule(ModulePath, ModuleToDefinedGVSummaries, 1098 ImportList, ModuleToSummariesForIndex); 1099 1100 std::error_code EC; 1101 raw_fd_ostream OS(NewModulePath + ".thinlto.bc", EC, 1102 sys::fs::OpenFlags::F_None); 1103 if (EC) 1104 return errorCodeToError(EC); 1105 WriteIndexToFile(CombinedIndex, OS, &ModuleToSummariesForIndex); 1106 1107 if (ShouldEmitImportsFiles) { 1108 EC = EmitImportsFiles(ModulePath, NewModulePath + ".imports", 1109 ModuleToSummariesForIndex); 1110 if (EC) 1111 return errorCodeToError(EC); 1112 } 1113 1114 if (OnWrite) 1115 OnWrite(ModulePath); 1116 return Error::success(); 1117 } 1118 1119 Error wait() override { return Error::success(); } 1120 }; 1121 } // end anonymous namespace 1122 1123 ThinBackend lto::createWriteIndexesThinBackend( 1124 std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles, 1125 raw_fd_ostream *LinkedObjectsFile, IndexWriteCallback OnWrite) { 1126 return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex, 1127 const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries, 1128 AddStreamFn AddStream, NativeObjectCache Cache) { 1129 return llvm::make_unique<WriteIndexesThinBackend>( 1130 Conf, CombinedIndex, ModuleToDefinedGVSummaries, OldPrefix, NewPrefix, 1131 ShouldEmitImportsFiles, LinkedObjectsFile, OnWrite); 1132 }; 1133 } 1134 1135 Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache) { 1136 if (ThinLTO.ModuleMap.empty()) 1137 return Error::success(); 1138 1139 if (Conf.CombinedIndexHook && !Conf.CombinedIndexHook(ThinLTO.CombinedIndex)) 1140 return Error::success(); 1141 1142 // Collect for each module the list of function it defines (GUID -> 1143 // Summary). 1144 StringMap<GVSummaryMapTy> 1145 ModuleToDefinedGVSummaries(ThinLTO.ModuleMap.size()); 1146 ThinLTO.CombinedIndex.collectDefinedGVSummariesPerModule( 1147 ModuleToDefinedGVSummaries); 1148 // Create entries for any modules that didn't have any GV summaries 1149 // (either they didn't have any GVs to start with, or we suppressed 1150 // generation of the summaries because they e.g. had inline assembly 1151 // uses that couldn't be promoted/renamed on export). This is so 1152 // InProcessThinBackend::start can still launch a backend thread, which 1153 // is passed the map of summaries for the module, without any special 1154 // handling for this case. 1155 for (auto &Mod : ThinLTO.ModuleMap) 1156 if (!ModuleToDefinedGVSummaries.count(Mod.first)) 1157 ModuleToDefinedGVSummaries.try_emplace(Mod.first); 1158 1159 StringMap<FunctionImporter::ImportMapTy> ImportLists( 1160 ThinLTO.ModuleMap.size()); 1161 StringMap<FunctionImporter::ExportSetTy> ExportLists( 1162 ThinLTO.ModuleMap.size()); 1163 StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>> ResolvedODR; 1164 1165 if (DumpThinCGSCCs) 1166 ThinLTO.CombinedIndex.dumpSCCs(outs()); 1167 1168 if (Conf.OptLevel > 0) 1169 ComputeCrossModuleImport(ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries, 1170 ImportLists, ExportLists); 1171 1172 // Figure out which symbols need to be internalized. This also needs to happen 1173 // at -O0 because summary-based DCE is implemented using internalization, and 1174 // we must apply DCE consistently with the full LTO module in order to avoid 1175 // undefined references during the final link. 1176 std::set<GlobalValue::GUID> ExportedGUIDs; 1177 for (auto &Res : GlobalResolutions) { 1178 // If the symbol does not have external references or it is not prevailing, 1179 // then not need to mark it as exported from a ThinLTO partition. 1180 if (Res.second.Partition != GlobalResolution::External || 1181 !Res.second.isPrevailingIRSymbol()) 1182 continue; 1183 auto GUID = GlobalValue::getGUID( 1184 GlobalValue::dropLLVMManglingEscape(Res.second.IRName)); 1185 // Mark exported unless index-based analysis determined it to be dead. 1186 if (ThinLTO.CombinedIndex.isGUIDLive(GUID)) 1187 ExportedGUIDs.insert(GUID); 1188 } 1189 1190 // Any functions referenced by the jump table in the regular LTO object must 1191 // be exported. 1192 for (auto &Def : ThinLTO.CombinedIndex.cfiFunctionDefs()) 1193 ExportedGUIDs.insert( 1194 GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(Def))); 1195 1196 auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) { 1197 const auto &ExportList = ExportLists.find(ModuleIdentifier); 1198 return (ExportList != ExportLists.end() && 1199 ExportList->second.count(GUID)) || 1200 ExportedGUIDs.count(GUID); 1201 }; 1202 thinLTOInternalizeAndPromoteInIndex(ThinLTO.CombinedIndex, isExported); 1203 1204 auto isPrevailing = [&](GlobalValue::GUID GUID, 1205 const GlobalValueSummary *S) { 1206 return ThinLTO.PrevailingModuleForGUID[GUID] == S->modulePath(); 1207 }; 1208 auto recordNewLinkage = [&](StringRef ModuleIdentifier, 1209 GlobalValue::GUID GUID, 1210 GlobalValue::LinkageTypes NewLinkage) { 1211 ResolvedODR[ModuleIdentifier][GUID] = NewLinkage; 1212 }; 1213 thinLTOResolveWeakForLinkerInIndex(ThinLTO.CombinedIndex, isPrevailing, 1214 recordNewLinkage); 1215 1216 std::unique_ptr<ThinBackendProc> BackendProc = 1217 ThinLTO.Backend(Conf, ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries, 1218 AddStream, Cache); 1219 1220 // Tasks 0 through ParallelCodeGenParallelismLevel-1 are reserved for combined 1221 // module and parallel code generation partitions. 1222 unsigned Task = RegularLTO.ParallelCodeGenParallelismLevel; 1223 for (auto &Mod : ThinLTO.ModuleMap) { 1224 if (Error E = BackendProc->start(Task, Mod.second, ImportLists[Mod.first], 1225 ExportLists[Mod.first], 1226 ResolvedODR[Mod.first], ThinLTO.ModuleMap)) 1227 return E; 1228 ++Task; 1229 } 1230 1231 return BackendProc->wait(); 1232 } 1233 1234 Expected<std::unique_ptr<ToolOutputFile>> 1235 lto::setupOptimizationRemarks(LLVMContext &Context, 1236 StringRef LTORemarksFilename, 1237 bool LTOPassRemarksWithHotness, int Count) { 1238 if (LTOPassRemarksWithHotness) 1239 Context.setDiagnosticsHotnessRequested(true); 1240 if (LTORemarksFilename.empty()) 1241 return nullptr; 1242 1243 std::string Filename = LTORemarksFilename; 1244 if (Count != -1) 1245 Filename += ".thin." + llvm::utostr(Count) + ".yaml"; 1246 1247 std::error_code EC; 1248 auto DiagnosticFile = 1249 llvm::make_unique<ToolOutputFile>(Filename, EC, sys::fs::F_None); 1250 if (EC) 1251 return errorCodeToError(EC); 1252 Context.setDiagnosticsOutputFile( 1253 llvm::make_unique<yaml::Output>(DiagnosticFile->os())); 1254 DiagnosticFile->keep(); 1255 return std::move(DiagnosticFile); 1256 } 1257