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