lib/Transforms/IPO/FunctionImport.cpp

   1 //===- FunctionImport.cpp - ThinLTO Summary-based Function Import ---------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements Function import based on summaries.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/Transforms/IPO/FunctionImport.h"
  14 #include "llvm/ADT/ArrayRef.h"
  15 #include "llvm/ADT/STLExtras.h"
  16 #include "llvm/ADT/SetVector.h"
  17 #include "llvm/ADT/SmallVector.h"
  18 #include "llvm/ADT/Statistic.h"
  19 #include "llvm/ADT/StringMap.h"
  20 #include "llvm/ADT/StringRef.h"
  21 #include "llvm/ADT/StringSet.h"
  22 #include "llvm/Bitcode/BitcodeReader.h"
  23 #include "llvm/IR/AutoUpgrade.h"
  24 #include "llvm/IR/Constants.h"
  25 #include "llvm/IR/Function.h"
  26 #include "llvm/IR/GlobalAlias.h"
  27 #include "llvm/IR/GlobalObject.h"
  28 #include "llvm/IR/GlobalValue.h"
  29 #include "llvm/IR/GlobalVariable.h"
  30 #include "llvm/IR/Metadata.h"
  31 #include "llvm/IR/Module.h"
  32 #include "llvm/IR/ModuleSummaryIndex.h"
  33 #include "llvm/IRReader/IRReader.h"
  34 #include "llvm/Linker/IRMover.h"
  35 #include "llvm/Object/ModuleSymbolTable.h"
  36 #include "llvm/Object/SymbolicFile.h"
  37 #include "llvm/Pass.h"
  38 #include "llvm/Support/Casting.h"
  39 #include "llvm/Support/CommandLine.h"
  40 #include "llvm/Support/Debug.h"
  41 #include "llvm/Support/Error.h"
  42 #include "llvm/Support/ErrorHandling.h"
  43 #include "llvm/Support/FileSystem.h"
  44 #include "llvm/Support/SourceMgr.h"
  45 #include "llvm/Support/raw_ostream.h"
  46 #include "llvm/Transforms/IPO/Internalize.h"
  47 #include "llvm/Transforms/Utils/Cloning.h"
  48 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
  49 #include "llvm/Transforms/Utils/ValueMapper.h"
  50 #include <cassert>
  51 #include <memory>
  52 #include <set>
  53 #include <string>
  54 #include <system_error>
  55 #include <tuple>
  56 #include <utility>
  57
  58 using namespace llvm;
  59
  60 #define DEBUG_TYPE "function-import"
  61
  62 STATISTIC(NumImportedFunctionsThinLink,
  63           "Number of functions thin link decided to import");
  64 STATISTIC(NumImportedHotFunctionsThinLink,
  65           "Number of hot functions thin link decided to import");
  66 STATISTIC(NumImportedCriticalFunctionsThinLink,
  67           "Number of critical functions thin link decided to import");
  68 STATISTIC(NumImportedGlobalVarsThinLink,
  69           "Number of global variables thin link decided to import");
  70 STATISTIC(NumImportedFunctions, "Number of functions imported in backend");
  71 STATISTIC(NumImportedGlobalVars,
  72           "Number of global variables imported in backend");
  73 STATISTIC(NumImportedModules, "Number of modules imported from");
  74 STATISTIC(NumDeadSymbols, "Number of dead stripped symbols in index");
  75 STATISTIC(NumLiveSymbols, "Number of live symbols in index");
  76
  77 /// Limit on instruction count of imported functions.
  78 static cl::opt<unsigned> ImportInstrLimit(
  79     "import-instr-limit", cl::init(100), cl::Hidden, cl::value_desc("N"),
  80     cl::desc("Only import functions with less than N instructions"));
  81
  82 static cl::opt<int> ImportCutoff(
  83     "import-cutoff", cl::init(-1), cl::Hidden, cl::value_desc("N"),
  84     cl::desc("Only import first N functions if N>=0 (default -1)"));
  85
  86 static cl::opt<float>
  87     ImportInstrFactor("import-instr-evolution-factor", cl::init(0.7),
  88                       cl::Hidden, cl::value_desc("x"),
  89                       cl::desc("As we import functions, multiply the "
  90                                "`import-instr-limit` threshold by this factor "
  91                                "before processing newly imported functions"));
  92
  93 static cl::opt<float> ImportHotInstrFactor(
  94     "import-hot-evolution-factor", cl::init(1.0), cl::Hidden,
  95     cl::value_desc("x"),
  96     cl::desc("As we import functions called from hot callsite, multiply the "
  97              "`import-instr-limit` threshold by this factor "
  98              "before processing newly imported functions"));
  99
 100 static cl::opt<float> ImportHotMultiplier(
 101     "import-hot-multiplier", cl::init(10.0), cl::Hidden, cl::value_desc("x"),
 102     cl::desc("Multiply the `import-instr-limit` threshold for hot callsites"));
 103
 104 static cl::opt<float> ImportCriticalMultiplier(
 105     "import-critical-multiplier", cl::init(100.0), cl::Hidden,
 106     cl::value_desc("x"),
 107     cl::desc(
 108         "Multiply the `import-instr-limit` threshold for critical callsites"));
 109
 110 // FIXME: This multiplier was not really tuned up.
 111 static cl::opt<float> ImportColdMultiplier(
 112     "import-cold-multiplier", cl::init(0), cl::Hidden, cl::value_desc("N"),
 113     cl::desc("Multiply the `import-instr-limit` threshold for cold callsites"));
 114
 115 static cl::opt<bool> PrintImports("print-imports", cl::init(false), cl::Hidden,
 116                                   cl::desc("Print imported functions"));
 117
 118 static cl::opt<bool> PrintImportFailures(
 119     "print-import-failures", cl::init(false), cl::Hidden,
 120     cl::desc("Print information for functions rejected for importing"));
 121
 122 static cl::opt<bool> ComputeDead("compute-dead", cl::init(true), cl::Hidden,
 123                                  cl::desc("Compute dead symbols"));
 124
 125 static cl::opt<bool> EnableImportMetadata(
 126     "enable-import-metadata", cl::init(
 127 #if !defined(NDEBUG)
 128                                   true /*Enabled with asserts.*/
 129 #else
 130                                   false
 131 #endif
 132                                   ),
 133     cl::Hidden, cl::desc("Enable import metadata like 'thinlto_src_module'"));
 134
 135 /// Summary file to use for function importing when using -function-import from
 136 /// the command line.
 137 static cl::opt<std::string>
 138     SummaryFile("summary-file",
 139                 cl::desc("The summary file to use for function importing."));
 140
 141 /// Used when testing importing from distributed indexes via opt
 142 // -function-import.
 143 static cl::opt<bool>
 144     ImportAllIndex("import-all-index",
 145                    cl::desc("Import all external functions in index."));
 146
 147 // Load lazily a module from \p FileName in \p Context.
 148 static std::unique_ptr<Module> loadFile(const std::string &FileName,
 149                                         LLVMContext &Context) {
 150   SMDiagnostic Err;
 151   LLVM_DEBUG(dbgs() << "Loading '" << FileName << "'\n");
 152   // Metadata isn't loaded until functions are imported, to minimize
 153   // the memory overhead.
 154   std::unique_ptr<Module> Result =
 155       getLazyIRFileModule(FileName, Err, Context,
 156                           /* ShouldLazyLoadMetadata = */ true);
 157   if (!Result) {
 158     Err.print("function-import", errs());
 159     report_fatal_error("Abort");
 160   }
 161
 162   return Result;
 163 }
 164
 165 /// Given a list of possible callee implementation for a call site, select one
 166 /// that fits the \p Threshold.
 167 ///
 168 /// FIXME: select "best" instead of first that fits. But what is "best"?
 169 /// - The smallest: more likely to be inlined.
 170 /// - The one with the least outgoing edges (already well optimized).
 171 /// - One from a module already being imported from in order to reduce the
 172 ///   number of source modules parsed/linked.
 173 /// - One that has PGO data attached.
 174 /// - [insert you fancy metric here]
 175 static const GlobalValueSummary *
 176 selectCallee(const ModuleSummaryIndex &Index,
 177              ArrayRef<std::unique_ptr<GlobalValueSummary>> CalleeSummaryList,
 178              unsigned Threshold, StringRef CallerModulePath,
 179              FunctionImporter::ImportFailureReason &Reason,
 180              GlobalValue::GUID GUID) {
 181   Reason = FunctionImporter::ImportFailureReason::None;
 182   auto It = llvm::find_if(
 183       CalleeSummaryList,
 184       [&](const std::unique_ptr<GlobalValueSummary> &SummaryPtr) {
 185         auto *GVSummary = SummaryPtr.get();
 186         if (!Index.isGlobalValueLive(GVSummary)) {
 187           Reason = FunctionImporter::ImportFailureReason::NotLive;
 188           return false;
 189         }
 190
 191         // For SamplePGO, in computeImportForFunction the OriginalId
 192         // may have been used to locate the callee summary list (See
 193         // comment there).
 194         // The mapping from OriginalId to GUID may return a GUID
 195         // that corresponds to a static variable. Filter it out here.
 196         // This can happen when
 197         // 1) There is a call to a library function which is not defined
 198         // in the index.
 199         // 2) There is a static variable with the  OriginalGUID identical
 200         // to the GUID of the library function in 1);
 201         // When this happens, the logic for SamplePGO kicks in and
 202         // the static variable in 2) will be found, which needs to be
 203         // filtered out.
 204         if (GVSummary->getSummaryKind() == GlobalValueSummary::GlobalVarKind) {
 205           Reason = FunctionImporter::ImportFailureReason::GlobalVar;
 206           return false;
 207         }
 208         if (GlobalValue::isInterposableLinkage(GVSummary->linkage())) {
 209           Reason = FunctionImporter::ImportFailureReason::InterposableLinkage;
 210           // There is no point in importing these, we can't inline them
 211           return false;
 212         }
 213
 214         auto *Summary = cast<FunctionSummary>(GVSummary->getBaseObject());
 215
 216         // If this is a local function, make sure we import the copy
 217         // in the caller's module. The only time a local function can
 218         // share an entry in the index is if there is a local with the same name
 219         // in another module that had the same source file name (in a different
 220         // directory), where each was compiled in their own directory so there
 221         // was not distinguishing path.
 222         // However, do the import from another module if there is only one
 223         // entry in the list - in that case this must be a reference due
 224         // to indirect call profile data, since a function pointer can point to
 225         // a local in another module.
 226         if (GlobalValue::isLocalLinkage(Summary->linkage()) &&
 227             CalleeSummaryList.size() > 1 &&
 228             Summary->modulePath() != CallerModulePath) {
 229           Reason =
 230               FunctionImporter::ImportFailureReason::LocalLinkageNotInModule;
 231           return false;
 232         }
 233
 234         if (Summary->instCount() > Threshold) {
 235           Reason = FunctionImporter::ImportFailureReason::TooLarge;
 236           return false;
 237         }
 238
 239         // Skip if it isn't legal to import (e.g. may reference unpromotable
 240         // locals).
 241         if (Summary->notEligibleToImport()) {
 242           Reason = FunctionImporter::ImportFailureReason::NotEligible;
 243           return false;
 244         }
 245
 246         // Don't bother importing if we can't inline it anyway.
 247         if (Summary->fflags().NoInline) {
 248           Reason = FunctionImporter::ImportFailureReason::NoInline;
 249           return false;
 250         }
 251
 252         return true;
 253       });
 254   if (It == CalleeSummaryList.end())
 255     return nullptr;
 256
 257   return cast<GlobalValueSummary>(It->get());
 258 }
 259
 260 namespace {
 261
 262 using EdgeInfo = std::tuple<const FunctionSummary *, unsigned /* Threshold */,
 263                             GlobalValue::GUID>;
 264
 265 } // anonymous namespace
 266
 267 static ValueInfo
 268 updateValueInfoForIndirectCalls(const ModuleSummaryIndex &Index, ValueInfo VI) {
 269   if (!VI.getSummaryList().empty())
 270     return VI;
 271   // For SamplePGO, the indirect call targets for local functions will
 272   // have its original name annotated in profile. We try to find the
 273   // corresponding PGOFuncName as the GUID.
 274   // FIXME: Consider updating the edges in the graph after building
 275   // it, rather than needing to perform this mapping on each walk.
 276   auto GUID = Index.getGUIDFromOriginalID(VI.getGUID());
 277   if (GUID == 0)
 278     return ValueInfo();
 279   return Index.getValueInfo(GUID);
 280 }
 281
 282 static void computeImportForReferencedGlobals(
 283     const FunctionSummary &Summary, const GVSummaryMapTy &DefinedGVSummaries,
 284     FunctionImporter::ImportMapTy &ImportList,
 285     StringMap<FunctionImporter::ExportSetTy> *ExportLists) {
 286   for (auto &VI : Summary.refs()) {
 287     if (DefinedGVSummaries.count(VI.getGUID())) {
 288       LLVM_DEBUG(
 289           dbgs() << "Ref ignored! Target already in destination module.\n");
 290       continue;
 291     }
 292
 293     LLVM_DEBUG(dbgs() << " ref -> " << VI << "\n");
 294
 295     // If this is a local variable, make sure we import the copy
 296     // in the caller's module. The only time a local variable can
 297     // share an entry in the index is if there is a local with the same name
 298     // in another module that had the same source file name (in a different
 299     // directory), where each was compiled in their own directory so there
 300     // was not distinguishing path.
 301     auto LocalNotInModule = [&](const GlobalValueSummary *RefSummary) -> bool {
 302       return GlobalValue::isLocalLinkage(RefSummary->linkage()) &&
 303              RefSummary->modulePath() != Summary.modulePath();
 304     };
 305
 306     for (auto &RefSummary : VI.getSummaryList())
 307       if (isa<GlobalVarSummary>(RefSummary.get()) &&
 308           canImportGlobalVar(RefSummary.get()) &&
 309           !LocalNotInModule(RefSummary.get())) {
 310         auto ILI = ImportList[RefSummary->modulePath()].insert(VI.getGUID());
 311         // Only update stat if we haven't already imported this variable.
 312         if (ILI.second)
 313           NumImportedGlobalVarsThinLink++;
 314         if (ExportLists)
 315           (*ExportLists)[RefSummary->modulePath()].insert(VI.getGUID());
 316         break;
 317       }
 318   }
 319 }
 320
 321 static const char *
 322 getFailureName(FunctionImporter::ImportFailureReason Reason) {
 323   switch (Reason) {
 324   case FunctionImporter::ImportFailureReason::None:
 325     return "None";
 326   case FunctionImporter::ImportFailureReason::GlobalVar:
 327     return "GlobalVar";
 328   case FunctionImporter::ImportFailureReason::NotLive:
 329     return "NotLive";
 330   case FunctionImporter::ImportFailureReason::TooLarge:
 331     return "TooLarge";
 332   case FunctionImporter::ImportFailureReason::InterposableLinkage:
 333     return "InterposableLinkage";
 334   case FunctionImporter::ImportFailureReason::LocalLinkageNotInModule:
 335     return "LocalLinkageNotInModule";
 336   case FunctionImporter::ImportFailureReason::NotEligible:
 337     return "NotEligible";
 338   case FunctionImporter::ImportFailureReason::NoInline:
 339     return "NoInline";
 340   }
 341   llvm_unreachable("invalid reason");
 342 }
 343
 344 /// Compute the list of functions to import for a given caller. Mark these
 345 /// imported functions and the symbols they reference in their source module as
 346 /// exported from their source module.
 347 static void computeImportForFunction(
 348     const FunctionSummary &Summary, const ModuleSummaryIndex &Index,
 349     const unsigned Threshold, const GVSummaryMapTy &DefinedGVSummaries,
 350     SmallVectorImpl<EdgeInfo> &Worklist,
 351     FunctionImporter::ImportMapTy &ImportList,
 352     StringMap<FunctionImporter::ExportSetTy> *ExportLists,
 353     FunctionImporter::ImportThresholdsTy &ImportThresholds) {
 354   computeImportForReferencedGlobals(Summary, DefinedGVSummaries, ImportList,
 355                                     ExportLists);
 356   static int ImportCount = 0;
 357   for (auto &Edge : Summary.calls()) {
 358     ValueInfo VI = Edge.first;
 359     LLVM_DEBUG(dbgs() << " edge -> " << VI << " Threshold:" << Threshold
 360                       << "\n");
 361
 362     if (ImportCutoff >= 0 && ImportCount >= ImportCutoff) {
 363       LLVM_DEBUG(dbgs() << "ignored! import-cutoff value of " << ImportCutoff
 364                         << " reached.\n");
 365       continue;
 366     }
 367
 368     VI = updateValueInfoForIndirectCalls(Index, VI);
 369     if (!VI)
 370       continue;
 371
 372     if (DefinedGVSummaries.count(VI.getGUID())) {
 373       LLVM_DEBUG(dbgs() << "ignored! Target already in destination module.\n");
 374       continue;
 375     }
 376
 377     auto GetBonusMultiplier = [](CalleeInfo::HotnessType Hotness) -> float {
 378       if (Hotness == CalleeInfo::HotnessType::Hot)
 379         return ImportHotMultiplier;
 380       if (Hotness == CalleeInfo::HotnessType::Cold)
 381         return ImportColdMultiplier;
 382       if (Hotness == CalleeInfo::HotnessType::Critical)
 383         return ImportCriticalMultiplier;
 384       return 1.0;
 385     };
 386
 387     const auto NewThreshold =
 388         Threshold * GetBonusMultiplier(Edge.second.getHotness());
 389
 390     auto IT = ImportThresholds.insert(std::make_pair(
 391         VI.getGUID(), std::make_tuple(NewThreshold, nullptr, nullptr)));
 392     bool PreviouslyVisited = !IT.second;
 393     auto &ProcessedThreshold = std::get<0>(IT.first->second);
 394     auto &CalleeSummary = std::get<1>(IT.first->second);
 395     auto &FailureInfo = std::get<2>(IT.first->second);
 396
 397     bool IsHotCallsite =
 398         Edge.second.getHotness() == CalleeInfo::HotnessType::Hot;
 399     bool IsCriticalCallsite =
 400         Edge.second.getHotness() == CalleeInfo::HotnessType::Critical;
 401
 402     const FunctionSummary *ResolvedCalleeSummary = nullptr;
 403     if (CalleeSummary) {
 404       assert(PreviouslyVisited);
 405       // Since the traversal of the call graph is DFS, we can revisit a function
 406       // a second time with a higher threshold. In this case, it is added back
 407       // to the worklist with the new threshold (so that its own callee chains
 408       // can be considered with the higher threshold).
 409       if (NewThreshold <= ProcessedThreshold) {
 410         LLVM_DEBUG(
 411             dbgs() << "ignored! Target was already imported with Threshold "
 412                    << ProcessedThreshold << "\n");
 413         continue;
 414       }
 415       // Update with new larger threshold.
 416       ProcessedThreshold = NewThreshold;
 417       ResolvedCalleeSummary = cast<FunctionSummary>(CalleeSummary);
 418     } else {
 419       // If we already rejected importing a callee at the same or higher
 420       // threshold, don't waste time calling selectCallee.
 421       if (PreviouslyVisited && NewThreshold <= ProcessedThreshold) {
 422         LLVM_DEBUG(
 423             dbgs() << "ignored! Target was already rejected with Threshold "
 424             << ProcessedThreshold << "\n");
 425         if (PrintImportFailures) {
 426           assert(FailureInfo &&
 427                  "Expected FailureInfo for previously rejected candidate");
 428           FailureInfo->Attempts++;
 429         }
 430         continue;
 431       }
 432
 433       FunctionImporter::ImportFailureReason Reason;
 434       CalleeSummary = selectCallee(Index, VI.getSummaryList(), NewThreshold,
 435                                    Summary.modulePath(), Reason, VI.getGUID());
 436       if (!CalleeSummary) {
 437         // Update with new larger threshold if this was a retry (otherwise
 438         // we would have already inserted with NewThreshold above). Also
 439         // update failure info if requested.
 440         if (PreviouslyVisited) {
 441           ProcessedThreshold = NewThreshold;
 442           if (PrintImportFailures) {
 443             assert(FailureInfo &&
 444                    "Expected FailureInfo for previously rejected candidate");
 445             FailureInfo->Reason = Reason;
 446             FailureInfo->Attempts++;
 447             FailureInfo->MaxHotness =
 448                 std::max(FailureInfo->MaxHotness, Edge.second.getHotness());
 449           }
 450         } else if (PrintImportFailures) {
 451           assert(!FailureInfo &&
 452                  "Expected no FailureInfo for newly rejected candidate");
 453           FailureInfo = std::make_unique<FunctionImporter::ImportFailureInfo>(
 454               VI, Edge.second.getHotness(), Reason, 1);
 455         }
 456         LLVM_DEBUG(
 457             dbgs() << "ignored! No qualifying callee with summary found.\n");
 458         continue;
 459       }
 460
 461       // "Resolve" the summary
 462       CalleeSummary = CalleeSummary->getBaseObject();
 463       ResolvedCalleeSummary = cast<FunctionSummary>(CalleeSummary);
 464
 465       assert(ResolvedCalleeSummary->instCount() <= NewThreshold &&
 466              "selectCallee() didn't honor the threshold");
 467
 468       auto ExportModulePath = ResolvedCalleeSummary->modulePath();
 469       auto ILI = ImportList[ExportModulePath].insert(VI.getGUID());
 470       // We previously decided to import this GUID definition if it was already
 471       // inserted in the set of imports from the exporting module.
 472       bool PreviouslyImported = !ILI.second;
 473       if (!PreviouslyImported) {
 474         NumImportedFunctionsThinLink++;
 475         if (IsHotCallsite)
 476           NumImportedHotFunctionsThinLink++;
 477         if (IsCriticalCallsite)
 478           NumImportedCriticalFunctionsThinLink++;
 479       }
 480
 481       // Make exports in the source module.
 482       if (ExportLists) {
 483         auto &ExportList = (*ExportLists)[ExportModulePath];
 484         ExportList.insert(VI.getGUID());
 485         if (!PreviouslyImported) {
 486           // This is the first time this function was exported from its source
 487           // module, so mark all functions and globals it references as exported
 488           // to the outside if they are defined in the same source module.
 489           // For efficiency, we unconditionally add all the referenced GUIDs
 490           // to the ExportList for this module, and will prune out any not
 491           // defined in the module later in a single pass.
 492           for (auto &Edge : ResolvedCalleeSummary->calls()) {
 493             auto CalleeGUID = Edge.first.getGUID();
 494             ExportList.insert(CalleeGUID);
 495           }
 496           for (auto &Ref : ResolvedCalleeSummary->refs()) {
 497             auto GUID = Ref.getGUID();
 498             ExportList.insert(GUID);
 499           }
 500         }
 501       }
 502     }
 503
 504     auto GetAdjustedThreshold = [](unsigned Threshold, bool IsHotCallsite) {
 505       // Adjust the threshold for next level of imported functions.
 506       // The threshold is different for hot callsites because we can then
 507       // inline chains of hot calls.
 508       if (IsHotCallsite)
 509         return Threshold * ImportHotInstrFactor;
 510       return Threshold * ImportInstrFactor;
 511     };
 512
 513     const auto AdjThreshold = GetAdjustedThreshold(Threshold, IsHotCallsite);
 514
 515     ImportCount++;
 516
 517     // Insert the newly imported function to the worklist.
 518     Worklist.emplace_back(ResolvedCalleeSummary, AdjThreshold, VI.getGUID());
 519   }
 520 }
 521
 522 /// Given the list of globals defined in a module, compute the list of imports
 523 /// as well as the list of "exports", i.e. the list of symbols referenced from
 524 /// another module (that may require promotion).
 525 static void ComputeImportForModule(
 526     const GVSummaryMapTy &DefinedGVSummaries, const ModuleSummaryIndex &Index,
 527     StringRef ModName, FunctionImporter::ImportMapTy &ImportList,
 528     StringMap<FunctionImporter::ExportSetTy> *ExportLists = nullptr) {
 529   // Worklist contains the list of function imported in this module, for which
 530   // we will analyse the callees and may import further down the callgraph.
 531   SmallVector<EdgeInfo, 128> Worklist;
 532   FunctionImporter::ImportThresholdsTy ImportThresholds;
 533
 534   // Populate the worklist with the import for the functions in the current
 535   // module
 536   for (auto &GVSummary : DefinedGVSummaries) {
 537 #ifndef NDEBUG
 538     // FIXME: Change the GVSummaryMapTy to hold ValueInfo instead of GUID
 539     // so this map look up (and possibly others) can be avoided.
 540     auto VI = Index.getValueInfo(GVSummary.first);
 541 #endif
 542     if (!Index.isGlobalValueLive(GVSummary.second)) {
 543       LLVM_DEBUG(dbgs() << "Ignores Dead GUID: " << VI << "\n");
 544       continue;
 545     }
 546     auto *FuncSummary =
 547         dyn_cast<FunctionSummary>(GVSummary.second->getBaseObject());
 548     if (!FuncSummary)
 549       // Skip import for global variables
 550       continue;
 551     LLVM_DEBUG(dbgs() << "Initialize import for " << VI << "\n");
 552     computeImportForFunction(*FuncSummary, Index, ImportInstrLimit,
 553                              DefinedGVSummaries, Worklist, ImportList,
 554                              ExportLists, ImportThresholds);
 555   }
 556
 557   // Process the newly imported functions and add callees to the worklist.
 558   while (!Worklist.empty()) {
 559     auto FuncInfo = Worklist.pop_back_val();
 560     auto *Summary = std::get<0>(FuncInfo);
 561     auto Threshold = std::get<1>(FuncInfo);
 562
 563     computeImportForFunction(*Summary, Index, Threshold, DefinedGVSummaries,
 564                              Worklist, ImportList, ExportLists,
 565                              ImportThresholds);
 566   }
 567
 568   // Print stats about functions considered but rejected for importing
 569   // when requested.
 570   if (PrintImportFailures) {
 571     dbgs() << "Missed imports into module " << ModName << "\n";
 572     for (auto &I : ImportThresholds) {
 573       auto &ProcessedThreshold = std::get<0>(I.second);
 574       auto &CalleeSummary = std::get<1>(I.second);
 575       auto &FailureInfo = std::get<2>(I.second);
 576       if (CalleeSummary)
 577         continue; // We are going to import.
 578       assert(FailureInfo);
 579       FunctionSummary *FS = nullptr;
 580       if (!FailureInfo->VI.getSummaryList().empty())
 581         FS = dyn_cast<FunctionSummary>(
 582             FailureInfo->VI.getSummaryList()[0]->getBaseObject());
 583       dbgs() << FailureInfo->VI
 584              << ": Reason = " << getFailureName(FailureInfo->Reason)
 585              << ", Threshold = " << ProcessedThreshold
 586              << ", Size = " << (FS ? (int)FS->instCount() : -1)
 587              << ", MaxHotness = " << getHotnessName(FailureInfo->MaxHotness)
 588              << ", Attempts = " << FailureInfo->Attempts << "\n";
 589     }
 590   }
 591 }
 592
 593 #ifndef NDEBUG
 594 static bool isGlobalVarSummary(const ModuleSummaryIndex &Index,
 595                                GlobalValue::GUID G) {
 596   if (const auto &VI = Index.getValueInfo(G)) {
 597     auto SL = VI.getSummaryList();
 598     if (!SL.empty())
 599       return SL[0]->getSummaryKind() == GlobalValueSummary::GlobalVarKind;
 600   }
 601   return false;
 602 }
 603
 604 static GlobalValue::GUID getGUID(GlobalValue::GUID G) { return G; }
 605
 606 template <class T>
 607 static unsigned numGlobalVarSummaries(const ModuleSummaryIndex &Index,
 608                                       T &Cont) {
 609   unsigned NumGVS = 0;
 610   for (auto &V : Cont)
 611     if (isGlobalVarSummary(Index, getGUID(V)))
 612       ++NumGVS;
 613   return NumGVS;
 614 }
 615 #endif
 616
 617 /// Compute all the import and export for every module using the Index.
 618 void llvm::ComputeCrossModuleImport(
 619     const ModuleSummaryIndex &Index,
 620     const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
 621     StringMap<FunctionImporter::ImportMapTy> &ImportLists,
 622     StringMap<FunctionImporter::ExportSetTy> &ExportLists) {
 623   // For each module that has function defined, compute the import/export lists.
 624   for (auto &DefinedGVSummaries : ModuleToDefinedGVSummaries) {
 625     auto &ImportList = ImportLists[DefinedGVSummaries.first()];
 626     LLVM_DEBUG(dbgs() << "Computing import for Module '"
 627                       << DefinedGVSummaries.first() << "'\n");
 628     ComputeImportForModule(DefinedGVSummaries.second, Index,
 629                            DefinedGVSummaries.first(), ImportList,
 630                            &ExportLists);
 631   }
 632
 633   // When computing imports we added all GUIDs referenced by anything
 634   // imported from the module to its ExportList. Now we prune each ExportList
 635   // of any not defined in that module. This is more efficient than checking
 636   // while computing imports because some of the summary lists may be long
 637   // due to linkonce (comdat) copies.
 638   for (auto &ELI : ExportLists) {
 639     const auto &DefinedGVSummaries =
 640         ModuleToDefinedGVSummaries.lookup(ELI.first());
 641     for (auto EI = ELI.second.begin(); EI != ELI.second.end();) {
 642       if (!DefinedGVSummaries.count(*EI))
 643         EI = ELI.second.erase(EI);
 644       else
 645         ++EI;
 646     }
 647   }
 648
 649 #ifndef NDEBUG
 650   LLVM_DEBUG(dbgs() << "Import/Export lists for " << ImportLists.size()
 651                     << " modules:\n");
 652   for (auto &ModuleImports : ImportLists) {
 653     auto ModName = ModuleImports.first();
 654     auto &Exports = ExportLists[ModName];
 655     unsigned NumGVS = numGlobalVarSummaries(Index, Exports);
 656     LLVM_DEBUG(dbgs() << "* Module " << ModName << " exports "
 657                       << Exports.size() - NumGVS << " functions and " << NumGVS
 658                       << " vars. Imports from " << ModuleImports.second.size()
 659                       << " modules.\n");
 660     for (auto &Src : ModuleImports.second) {
 661       auto SrcModName = Src.first();
 662       unsigned NumGVSPerMod = numGlobalVarSummaries(Index, Src.second);
 663       LLVM_DEBUG(dbgs() << " - " << Src.second.size() - NumGVSPerMod
 664                         << " functions imported from " << SrcModName << "\n");
 665       LLVM_DEBUG(dbgs() << " - " << NumGVSPerMod
 666                         << " global vars imported from " << SrcModName << "\n");
 667     }
 668   }
 669 #endif
 670 }
 671
 672 #ifndef NDEBUG
 673 static void dumpImportListForModule(const ModuleSummaryIndex &Index,
 674                                     StringRef ModulePath,
 675                                     FunctionImporter::ImportMapTy &ImportList) {
 676   LLVM_DEBUG(dbgs() << "* Module " << ModulePath << " imports from "
 677                     << ImportList.size() << " modules.\n");
 678   for (auto &Src : ImportList) {
 679     auto SrcModName = Src.first();
 680     unsigned NumGVSPerMod = numGlobalVarSummaries(Index, Src.second);
 681     LLVM_DEBUG(dbgs() << " - " << Src.second.size() - NumGVSPerMod
 682                       << " functions imported from " << SrcModName << "\n");
 683     LLVM_DEBUG(dbgs() << " - " << NumGVSPerMod << " vars imported from "
 684                       << SrcModName << "\n");
 685   }
 686 }
 687 #endif
 688
 689 /// Compute all the imports for the given module in the Index.
 690 void llvm::ComputeCrossModuleImportForModule(
 691     StringRef ModulePath, const ModuleSummaryIndex &Index,
 692     FunctionImporter::ImportMapTy &ImportList) {
 693   // Collect the list of functions this module defines.
 694   // GUID -> Summary
 695   GVSummaryMapTy FunctionSummaryMap;
 696   Index.collectDefinedFunctionsForModule(ModulePath, FunctionSummaryMap);
 697
 698   // Compute the import list for this module.
 699   LLVM_DEBUG(dbgs() << "Computing import for Module '" << ModulePath << "'\n");
 700   ComputeImportForModule(FunctionSummaryMap, Index, ModulePath, ImportList);
 701
 702 #ifndef NDEBUG
 703   dumpImportListForModule(Index, ModulePath, ImportList);
 704 #endif
 705 }
 706
 707 // Mark all external summaries in Index for import into the given module.
 708 // Used for distributed builds using a distributed index.
 709 void llvm::ComputeCrossModuleImportForModuleFromIndex(
 710     StringRef ModulePath, const ModuleSummaryIndex &Index,
 711     FunctionImporter::ImportMapTy &ImportList) {
 712   for (auto &GlobalList : Index) {
 713     // Ignore entries for undefined references.
 714     if (GlobalList.second.SummaryList.empty())
 715       continue;
 716
 717     auto GUID = GlobalList.first;
 718     assert(GlobalList.second.SummaryList.size() == 1 &&
 719            "Expected individual combined index to have one summary per GUID");
 720     auto &Summary = GlobalList.second.SummaryList[0];
 721     // Skip the summaries for the importing module. These are included to
 722     // e.g. record required linkage changes.
 723     if (Summary->modulePath() == ModulePath)
 724       continue;
 725     // Add an entry to provoke importing by thinBackend.
 726     ImportList[Summary->modulePath()].insert(GUID);
 727   }
 728 #ifndef NDEBUG
 729   dumpImportListForModule(Index, ModulePath, ImportList);
 730 #endif
 731 }
 732
 733 void llvm::computeDeadSymbols(
 734     ModuleSummaryIndex &Index,
 735     const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols,
 736     function_ref<PrevailingType(GlobalValue::GUID)> isPrevailing) {
 737   assert(!Index.withGlobalValueDeadStripping());
 738   if (!ComputeDead)
 739     return;
 740   if (GUIDPreservedSymbols.empty())
 741     // Don't do anything when nothing is live, this is friendly with tests.
 742     return;
 743   unsigned LiveSymbols = 0;
 744   SmallVector<ValueInfo, 128> Worklist;
 745   Worklist.reserve(GUIDPreservedSymbols.size() * 2);
 746   for (auto GUID : GUIDPreservedSymbols) {
 747     ValueInfo VI = Index.getValueInfo(GUID);
 748     if (!VI)
 749       continue;
 750     for (auto &S : VI.getSummaryList())
 751       S->setLive(true);
 752   }
 753
 754   // Add values flagged in the index as live roots to the worklist.
 755   for (const auto &Entry : Index) {
 756     auto VI = Index.getValueInfo(Entry);
 757     for (auto &S : Entry.second.SummaryList)
 758       if (S->isLive()) {
 759         LLVM_DEBUG(dbgs() << "Live root: " << VI << "\n");
 760         Worklist.push_back(VI);
 761         ++LiveSymbols;
 762         break;
 763       }
 764   }
 765
 766   // Make value live and add it to the worklist if it was not live before.
 767   auto visit = [&](ValueInfo VI, bool IsAliasee) {
 768     // FIXME: If we knew which edges were created for indirect call profiles,
 769     // we could skip them here. Any that are live should be reached via
 770     // other edges, e.g. reference edges. Otherwise, using a profile collected
 771     // on a slightly different binary might provoke preserving, importing
 772     // and ultimately promoting calls to functions not linked into this
 773     // binary, which increases the binary size unnecessarily. Note that
 774     // if this code changes, the importer needs to change so that edges
 775     // to functions marked dead are skipped.
 776     VI = updateValueInfoForIndirectCalls(Index, VI);
 777     if (!VI)
 778       return;
 779
 780     if (llvm::any_of(VI.getSummaryList(),
 781                      [](const std::unique_ptr<llvm::GlobalValueSummary> &S) {
 782                        return S->isLive();
 783                      }))
 784       return;
 785
 786     // We only keep live symbols that are known to be non-prevailing if any are
 787     // available_externally, linkonceodr, weakodr. Those symbols are discarded
 788     // later in the EliminateAvailableExternally pass and setting them to
 789     // not-live could break downstreams users of liveness information (PR36483)
 790     // or limit optimization opportunities.
 791     if (isPrevailing(VI.getGUID()) == PrevailingType::No) {
 792       bool KeepAliveLinkage = false;
 793       bool Interposable = false;
 794       for (auto &S : VI.getSummaryList()) {
 795         if (S->linkage() == GlobalValue::AvailableExternallyLinkage ||
 796             S->linkage() == GlobalValue::WeakODRLinkage ||
 797             S->linkage() == GlobalValue::LinkOnceODRLinkage)
 798           KeepAliveLinkage = true;
 799         else if (GlobalValue::isInterposableLinkage(S->linkage()))
 800           Interposable = true;
 801       }
 802
 803       if (!IsAliasee) {
 804         if (!KeepAliveLinkage)
 805           return;
 806
 807         if (Interposable)
 808           report_fatal_error(
 809               "Interposable and available_externally/linkonce_odr/weak_odr "
 810               "symbol");
 811       }
 812     }
 813
 814     for (auto &S : VI.getSummaryList())
 815       S->setLive(true);
 816     ++LiveSymbols;
 817     Worklist.push_back(VI);
 818   };
 819
 820   while (!Worklist.empty()) {
 821     auto VI = Worklist.pop_back_val();
 822     for (auto &Summary : VI.getSummaryList()) {
 823       if (auto *AS = dyn_cast<AliasSummary>(Summary.get())) {
 824         // If this is an alias, visit the aliasee VI to ensure that all copies
 825         // are marked live and it is added to the worklist for further
 826         // processing of its references.
 827         visit(AS->getAliaseeVI(), true);
 828         continue;
 829       }
 830
 831       Summary->setLive(true);
 832       for (auto Ref : Summary->refs())
 833         visit(Ref, false);
 834       if (auto *FS = dyn_cast<FunctionSummary>(Summary.get()))
 835         for (auto Call : FS->calls())
 836           visit(Call.first, false);
 837     }
 838   }
 839   Index.setWithGlobalValueDeadStripping();
 840
 841   unsigned DeadSymbols = Index.size() - LiveSymbols;
 842   LLVM_DEBUG(dbgs() << LiveSymbols << " symbols Live, and " << DeadSymbols
 843                     << " symbols Dead \n");
 844   NumDeadSymbols += DeadSymbols;
 845   NumLiveSymbols += LiveSymbols;
 846 }
 847
 848 // Compute dead symbols and propagate constants in combined index.
 849 void llvm::computeDeadSymbolsWithConstProp(
 850     ModuleSummaryIndex &Index,
 851     const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols,
 852     function_ref<PrevailingType(GlobalValue::GUID)> isPrevailing,
 853     bool ImportEnabled) {
 854   computeDeadSymbols(Index, GUIDPreservedSymbols, isPrevailing);
 855   if (ImportEnabled) {
 856     Index.propagateAttributes(GUIDPreservedSymbols);
 857   } else {
 858     // If import is disabled we should drop read/write-only attribute
 859     // from all summaries to prevent internalization.
 860     for (auto &P : Index)
 861       for (auto &S : P.second.SummaryList)
 862         if (auto *GVS = dyn_cast<GlobalVarSummary>(S.get())) {
 863           GVS->setReadOnly(false);
 864           GVS->setWriteOnly(false);
 865         }
 866   }
 867 }
 868
 869 /// Compute the set of summaries needed for a ThinLTO backend compilation of
 870 /// \p ModulePath.
 871 void llvm::gatherImportedSummariesForModule(
 872     StringRef ModulePath,
 873     const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
 874     const FunctionImporter::ImportMapTy &ImportList,
 875     std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex) {
 876   // Include all summaries from the importing module.
 877   ModuleToSummariesForIndex[ModulePath] =
 878       ModuleToDefinedGVSummaries.lookup(ModulePath);
 879   // Include summaries for imports.
 880   for (auto &ILI : ImportList) {
 881     auto &SummariesForIndex = ModuleToSummariesForIndex[ILI.first()];
 882     const auto &DefinedGVSummaries =
 883         ModuleToDefinedGVSummaries.lookup(ILI.first());
 884     for (auto &GI : ILI.second) {
 885       const auto &DS = DefinedGVSummaries.find(GI);
 886       assert(DS != DefinedGVSummaries.end() &&
 887              "Expected a defined summary for imported global value");
 888       SummariesForIndex[GI] = DS->second;
 889     }
 890   }
 891 }
 892
 893 /// Emit the files \p ModulePath will import from into \p OutputFilename.
 894 std::error_code llvm::EmitImportsFiles(
 895     StringRef ModulePath, StringRef OutputFilename,
 896     const std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex) {
 897   std::error_code EC;
 898   raw_fd_ostream ImportsOS(OutputFilename, EC, sys::fs::OpenFlags::OF_None);
 899   if (EC)
 900     return EC;
 901   for (auto &ILI : ModuleToSummariesForIndex)
 902     // The ModuleToSummariesForIndex map includes an entry for the current
 903     // Module (needed for writing out the index files). We don't want to
 904     // include it in the imports file, however, so filter it out.
 905     if (ILI.first != ModulePath)
 906       ImportsOS << ILI.first << "\n";
 907   return std::error_code();
 908 }
 909
 910 bool llvm::convertToDeclaration(GlobalValue &GV) {
 911   LLVM_DEBUG(dbgs() << "Converting to a declaration: `" << GV.getName()
 912                     << "\n");
 913   if (Function *F = dyn_cast<Function>(&GV)) {
 914     F->deleteBody();
 915     F->clearMetadata();
 916     F->setComdat(nullptr);
 917   } else if (GlobalVariable *V = dyn_cast<GlobalVariable>(&GV)) {
 918     V->setInitializer(nullptr);
 919     V->setLinkage(GlobalValue::ExternalLinkage);
 920     V->clearMetadata();
 921     V->setComdat(nullptr);
 922   } else {
 923     GlobalValue *NewGV;
 924     if (GV.getValueType()->isFunctionTy())
 925       NewGV =
 926           Function::Create(cast<FunctionType>(GV.getValueType()),
 927                            GlobalValue::ExternalLinkage, GV.getAddressSpace(),
 928                            "", GV.getParent());
 929     else
 930       NewGV =
 931           new GlobalVariable(*GV.getParent(), GV.getValueType(),
 932                              /*isConstant*/ false, GlobalValue::ExternalLinkage,
 933                              /*init*/ nullptr, "",
 934                              /*insertbefore*/ nullptr, GV.getThreadLocalMode(),
 935                              GV.getType()->getAddressSpace());
 936     NewGV->takeName(&GV);
 937     GV.replaceAllUsesWith(NewGV);
 938     return false;
 939   }
 940   return true;
 941 }
 942
 943 /// Fixup prevailing symbol linkages in \p TheModule based on summary analysis.
 944 void llvm::thinLTOResolvePrevailingInModule(
 945     Module &TheModule, const GVSummaryMapTy &DefinedGlobals) {
 946   auto updateLinkage = [&](GlobalValue &GV) {
 947     // See if the global summary analysis computed a new resolved linkage.
 948     const auto &GS = DefinedGlobals.find(GV.getGUID());
 949     if (GS == DefinedGlobals.end())
 950       return;
 951     auto NewLinkage = GS->second->linkage();
 952     if (NewLinkage == GV.getLinkage())
 953       return;
 954     if (GlobalValue::isLocalLinkage(GV.getLinkage()) ||
 955         // Don't internalize anything here, because the code below
 956         // lacks necessary correctness checks. Leave this job to
 957         // LLVM 'internalize' pass.
 958         GlobalValue::isLocalLinkage(NewLinkage) ||
 959         // In case it was dead and already converted to declaration.
 960         GV.isDeclaration())
 961       return;
 962
 963     // Check for a non-prevailing def that has interposable linkage
 964     // (e.g. non-odr weak or linkonce). In that case we can't simply
 965     // convert to available_externally, since it would lose the
 966     // interposable property and possibly get inlined. Simply drop
 967     // the definition in that case.
 968     if (GlobalValue::isAvailableExternallyLinkage(NewLinkage) &&
 969         GlobalValue::isInterposableLinkage(GV.getLinkage())) {
 970       if (!convertToDeclaration(GV))
 971         // FIXME: Change this to collect replaced GVs and later erase
 972         // them from the parent module once thinLTOResolvePrevailingGUID is
 973         // changed to enable this for aliases.
 974         llvm_unreachable("Expected GV to be converted");
 975     } else {
 976       // If all copies of the original symbol had global unnamed addr and
 977       // linkonce_odr linkage, it should be an auto hide symbol. In that case
 978       // the thin link would have marked it as CanAutoHide. Add hidden visibility
 979       // to the symbol to preserve the property.
 980       if (NewLinkage == GlobalValue::WeakODRLinkage &&
 981           GS->second->canAutoHide()) {
 982         assert(GV.hasLinkOnceODRLinkage() && GV.hasGlobalUnnamedAddr());
 983         GV.setVisibility(GlobalValue::HiddenVisibility);
 984       }
 985
 986       LLVM_DEBUG(dbgs() << "ODR fixing up linkage for `" << GV.getName()
 987                         << "` from " << GV.getLinkage() << " to " << NewLinkage
 988                         << "\n");
 989       GV.setLinkage(NewLinkage);
 990     }
 991     // Remove declarations from comdats, including available_externally
 992     // as this is a declaration for the linker, and will be dropped eventually.
 993     // It is illegal for comdats to contain declarations.
 994     auto *GO = dyn_cast_or_null<GlobalObject>(&GV);
 995     if (GO && GO->isDeclarationForLinker() && GO->hasComdat())
 996       GO->setComdat(nullptr);
 997   };
 998
 999   // Process functions and global now
1000   for (auto &GV : TheModule)
1001     updateLinkage(GV);
1002   for (auto &GV : TheModule.globals())
1003     updateLinkage(GV);
1004   for (auto &GV : TheModule.aliases())
1005     updateLinkage(GV);
1006 }
1007
1008 /// Run internalization on \p TheModule based on symmary analysis.
1009 void llvm::thinLTOInternalizeModule(Module &TheModule,
1010                                     const GVSummaryMapTy &DefinedGlobals) {
1011   // Declare a callback for the internalize pass that will ask for every
1012   // candidate GlobalValue if it can be internalized or not.
1013   auto MustPreserveGV = [&](const GlobalValue &GV) -> bool {
1014     // Lookup the linkage recorded in the summaries during global analysis.
1015     auto GS = DefinedGlobals.find(GV.getGUID());
1016     if (GS == DefinedGlobals.end()) {
1017       // Must have been promoted (possibly conservatively). Find original
1018       // name so that we can access the correct summary and see if it can
1019       // be internalized again.
1020       // FIXME: Eventually we should control promotion instead of promoting
1021       // and internalizing again.
1022       StringRef OrigName =
1023           ModuleSummaryIndex::getOriginalNameBeforePromote(GV.getName());
1024       std::string OrigId = GlobalValue::getGlobalIdentifier(
1025           OrigName, GlobalValue::InternalLinkage,
1026           TheModule.getSourceFileName());
1027       GS = DefinedGlobals.find(GlobalValue::getGUID(OrigId));
1028       if (GS == DefinedGlobals.end()) {
1029         // Also check the original non-promoted non-globalized name. In some
1030         // cases a preempted weak value is linked in as a local copy because
1031         // it is referenced by an alias (IRLinker::linkGlobalValueProto).
1032         // In that case, since it was originally not a local value, it was
1033         // recorded in the index using the original name.
1034         // FIXME: This may not be needed once PR27866 is fixed.
1035         GS = DefinedGlobals.find(GlobalValue::getGUID(OrigName));
1036         assert(GS != DefinedGlobals.end());
1037       }
1038     }
1039     return !GlobalValue::isLocalLinkage(GS->second->linkage());
1040   };
1041
1042   // FIXME: See if we can just internalize directly here via linkage changes
1043   // based on the index, rather than invoking internalizeModule.
1044   internalizeModule(TheModule, MustPreserveGV);
1045 }
1046
1047 /// Make alias a clone of its aliasee.
1048 static Function *replaceAliasWithAliasee(Module *SrcModule, GlobalAlias *GA) {
1049   Function *Fn = cast<Function>(GA->getBaseObject());
1050
1051   ValueToValueMapTy VMap;
1052   Function *NewFn = CloneFunction(Fn, VMap);
1053   // Clone should use the original alias's linkage, visibility and name, and we
1054   // ensure all uses of alias instead use the new clone (casted if necessary).
1055   NewFn->setLinkage(GA->getLinkage());
1056   NewFn->setVisibility(GA->getVisibility());
1057   GA->replaceAllUsesWith(ConstantExpr::getBitCast(NewFn, GA->getType()));
1058   NewFn->takeName(GA);
1059   return NewFn;
1060 }
1061
1062 // Internalize values that we marked with specific attribute
1063 // in processGlobalForThinLTO.
1064 static void internalizeGVsAfterImport(Module &M) {
1065   for (auto &GV : M.globals())
1066     // Skip GVs which have been converted to declarations
1067     // by dropDeadSymbols.
1068     if (!GV.isDeclaration() && GV.hasAttribute("thinlto-internalize")) {
1069       GV.setLinkage(GlobalValue::InternalLinkage);
1070       GV.setVisibility(GlobalValue::DefaultVisibility);
1071     }
1072 }
1073
1074 // Automatically import functions in Module \p DestModule based on the summaries
1075 // index.
1076 Expected<bool> FunctionImporter::importFunctions(
1077     Module &DestModule, const FunctionImporter::ImportMapTy &ImportList) {
1078   LLVM_DEBUG(dbgs() << "Starting import for Module "
1079                     << DestModule.getModuleIdentifier() << "\n");
1080   unsigned ImportedCount = 0, ImportedGVCount = 0;
1081
1082   IRMover Mover(DestModule);
1083   // Do the actual import of functions now, one Module at a time
1084   std::set<StringRef> ModuleNameOrderedList;
1085   for (auto &FunctionsToImportPerModule : ImportList) {
1086     ModuleNameOrderedList.insert(FunctionsToImportPerModule.first());
1087   }
1088   for (auto &Name : ModuleNameOrderedList) {
1089     // Get the module for the import
1090     const auto &FunctionsToImportPerModule = ImportList.find(Name);
1091     assert(FunctionsToImportPerModule != ImportList.end());
1092     Expected<std::unique_ptr<Module>> SrcModuleOrErr = ModuleLoader(Name);
1093     if (!SrcModuleOrErr)
1094       return SrcModuleOrErr.takeError();
1095     std::unique_ptr<Module> SrcModule = std::move(*SrcModuleOrErr);
1096     assert(&DestModule.getContext() == &SrcModule->getContext() &&
1097            "Context mismatch");
1098
1099     // If modules were created with lazy metadata loading, materialize it
1100     // now, before linking it (otherwise this will be a noop).
1101     if (Error Err = SrcModule->materializeMetadata())
1102       return std::move(Err);
1103
1104     auto &ImportGUIDs = FunctionsToImportPerModule->second;
1105     // Find the globals to import
1106     SetVector<GlobalValue *> GlobalsToImport;
1107     for (Function &F : *SrcModule) {
1108       if (!F.hasName())
1109         continue;
1110       auto GUID = F.getGUID();
1111       auto Import = ImportGUIDs.count(GUID);
1112       LLVM_DEBUG(dbgs() << (Import ? "Is" : "Not") << " importing function "
1113                         << GUID << " " << F.getName() << " from "
1114                         << SrcModule->getSourceFileName() << "\n");
1115       if (Import) {
1116         if (Error Err = F.materialize())
1117           return std::move(Err);
1118         if (EnableImportMetadata) {
1119           // Add 'thinlto_src_module' metadata for statistics and debugging.
1120           F.setMetadata(
1121               "thinlto_src_module",
1122               MDNode::get(DestModule.getContext(),
1123                           {MDString::get(DestModule.getContext(),
1124                                          SrcModule->getSourceFileName())}));
1125         }
1126         GlobalsToImport.insert(&F);
1127       }
1128     }
1129     for (GlobalVariable &GV : SrcModule->globals()) {
1130       if (!GV.hasName())
1131         continue;
1132       auto GUID = GV.getGUID();
1133       auto Import = ImportGUIDs.count(GUID);
1134       LLVM_DEBUG(dbgs() << (Import ? "Is" : "Not") << " importing global "
1135                         << GUID << " " << GV.getName() << " from "
1136                         << SrcModule->getSourceFileName() << "\n");
1137       if (Import) {
1138         if (Error Err = GV.materialize())
1139           return std::move(Err);
1140         ImportedGVCount += GlobalsToImport.insert(&GV);
1141       }
1142     }
1143     for (GlobalAlias &GA : SrcModule->aliases()) {
1144       if (!GA.hasName())
1145         continue;
1146       auto GUID = GA.getGUID();
1147       auto Import = ImportGUIDs.count(GUID);
1148       LLVM_DEBUG(dbgs() << (Import ? "Is" : "Not") << " importing alias "
1149                         << GUID << " " << GA.getName() << " from "
1150                         << SrcModule->getSourceFileName() << "\n");
1151       if (Import) {
1152         if (Error Err = GA.materialize())
1153           return std::move(Err);
1154         // Import alias as a copy of its aliasee.
1155         GlobalObject *Base = GA.getBaseObject();
1156         if (Error Err = Base->materialize())
1157           return std::move(Err);
1158         auto *Fn = replaceAliasWithAliasee(SrcModule.get(), &GA);
1159         LLVM_DEBUG(dbgs() << "Is importing aliasee fn " << Base->getGUID()
1160                           << " " << Base->getName() << " from "
1161                           << SrcModule->getSourceFileName() << "\n");
1162         if (EnableImportMetadata) {
1163           // Add 'thinlto_src_module' metadata for statistics and debugging.
1164           Fn->setMetadata(
1165               "thinlto_src_module",
1166               MDNode::get(DestModule.getContext(),
1167                           {MDString::get(DestModule.getContext(),
1168                                          SrcModule->getSourceFileName())}));
1169         }
1170         GlobalsToImport.insert(Fn);
1171       }
1172     }
1173
1174     // Upgrade debug info after we're done materializing all the globals and we
1175     // have loaded all the required metadata!
1176     UpgradeDebugInfo(*SrcModule);
1177
1178     // Link in the specified functions.
1179     if (renameModuleForThinLTO(*SrcModule, Index, &GlobalsToImport))
1180       return true;
1181
1182     if (PrintImports) {
1183       for (const auto *GV : GlobalsToImport)
1184         dbgs() << DestModule.getSourceFileName() << ": Import " << GV->getName()
1185                << " from " << SrcModule->getSourceFileName() << "\n";
1186     }
1187
1188     if (Mover.move(std::move(SrcModule), GlobalsToImport.getArrayRef(),
1189                    [](GlobalValue &, IRMover::ValueAdder) {},
1190                    /*IsPerformingImport=*/true))
1191       report_fatal_error("Function Import: link error");
1192
1193     ImportedCount += GlobalsToImport.size();
1194     NumImportedModules++;
1195   }
1196
1197   internalizeGVsAfterImport(DestModule);
1198
1199   NumImportedFunctions += (ImportedCount - ImportedGVCount);
1200   NumImportedGlobalVars += ImportedGVCount;
1201
1202   LLVM_DEBUG(dbgs() << "Imported " << ImportedCount - ImportedGVCount
1203                     << " functions for Module "
1204                     << DestModule.getModuleIdentifier() << "\n");
1205   LLVM_DEBUG(dbgs() << "Imported " << ImportedGVCount
1206                     << " global variables for Module "
1207                     << DestModule.getModuleIdentifier() << "\n");
1208   return ImportedCount;
1209 }
1210
1211 static bool doImportingForModule(Module &M) {
1212   if (SummaryFile.empty())
1213     report_fatal_error("error: -function-import requires -summary-file\n");
1214   Expected<std::unique_ptr<ModuleSummaryIndex>> IndexPtrOrErr =
1215       getModuleSummaryIndexForFile(SummaryFile);
1216   if (!IndexPtrOrErr) {
1217     logAllUnhandledErrors(IndexPtrOrErr.takeError(), errs(),
1218                           "Error loading file '" + SummaryFile + "': ");
1219     return false;
1220   }
1221   std::unique_ptr<ModuleSummaryIndex> Index = std::move(*IndexPtrOrErr);
1222
1223   // First step is collecting the import list.
1224   FunctionImporter::ImportMapTy ImportList;
1225   // If requested, simply import all functions in the index. This is used
1226   // when testing distributed backend handling via the opt tool, when
1227   // we have distributed indexes containing exactly the summaries to import.
1228   if (ImportAllIndex)
1229     ComputeCrossModuleImportForModuleFromIndex(M.getModuleIdentifier(), *Index,
1230                                                ImportList);
1231   else
1232     ComputeCrossModuleImportForModule(M.getModuleIdentifier(), *Index,
1233                                       ImportList);
1234
1235   // Conservatively mark all internal values as promoted. This interface is
1236   // only used when doing importing via the function importing pass. The pass
1237   // is only enabled when testing importing via the 'opt' tool, which does
1238   // not do the ThinLink that would normally determine what values to promote.
1239   for (auto &I : *Index) {
1240     for (auto &S : I.second.SummaryList) {
1241       if (GlobalValue::isLocalLinkage(S->linkage()))
1242         S->setLinkage(GlobalValue::ExternalLinkage);
1243     }
1244   }
1245
1246   // Next we need to promote to global scope and rename any local values that
1247   // are potentially exported to other modules.
1248   if (renameModuleForThinLTO(M, *Index, nullptr)) {
1249     errs() << "Error renaming module\n";
1250     return false;
1251   }
1252
1253   // Perform the import now.
1254   auto ModuleLoader = [&M](StringRef Identifier) {
1255     return loadFile(Identifier, M.getContext());
1256   };
1257   FunctionImporter Importer(*Index, ModuleLoader);
1258   Expected<bool> Result = Importer.importFunctions(M, ImportList);
1259
1260   // FIXME: Probably need to propagate Errors through the pass manager.
1261   if (!Result) {
1262     logAllUnhandledErrors(Result.takeError(), errs(),
1263                           "Error importing module: ");
1264     return false;
1265   }
1266
1267   return *Result;
1268 }
1269
1270 namespace {
1271
1272 /// Pass that performs cross-module function import provided a summary file.
1273 class FunctionImportLegacyPass : public ModulePass {
1274 public:
1275   /// Pass identification, replacement for typeid
1276   static char ID;
1277
1278   explicit FunctionImportLegacyPass() : ModulePass(ID) {}
1279
1280   /// Specify pass name for debug output
1281   StringRef getPassName() const override { return "Function Importing"; }
1282
1283   bool runOnModule(Module &M) override {
1284     if (skipModule(M))
1285       return false;
1286
1287     return doImportingForModule(M);
1288   }
1289 };
1290
1291 } // end anonymous namespace
1292
1293 PreservedAnalyses FunctionImportPass::run(Module &M,
1294                                           ModuleAnalysisManager &AM) {
1295   if (!doImportingForModule(M))
1296     return PreservedAnalyses::all();
1297
1298   return PreservedAnalyses::none();
1299 }
1300
1301 char FunctionImportLegacyPass::ID = 0;
1302 INITIALIZE_PASS(FunctionImportLegacyPass, "function-import",
1303                 "Summary Based Function Import", false, false)
1304
1305 namespace llvm {
1306
1307 Pass *createFunctionImportPass() {
1308   return new FunctionImportLegacyPass();
1309 }
1310
1311 } // end namespace llvm