lib/LTO/LTO.cpp

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