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