contrib/llvm/lib/Transforms/IPO/FunctionImport.cpp

   1 //===- FunctionImport.cpp - ThinLTO Summary-based Function Import ---------===//
   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 Function import based on summaries.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Transforms/IPO/FunctionImport.h"
  15
  16 #include "llvm/ADT/SmallVector.h"
  17 #include "llvm/ADT/Statistic.h"
  18 #include "llvm/ADT/StringSet.h"
  19 #include "llvm/ADT/Triple.h"
  20 #include "llvm/Bitcode/BitcodeReader.h"
  21 #include "llvm/IR/AutoUpgrade.h"
  22 #include "llvm/IR/DiagnosticPrinter.h"
  23 #include "llvm/IR/IntrinsicInst.h"
  24 #include "llvm/IR/Module.h"
  25 #include "llvm/IR/Verifier.h"
  26 #include "llvm/IRReader/IRReader.h"
  27 #include "llvm/Linker/Linker.h"
  28 #include "llvm/Object/IRObjectFile.h"
  29 #include "llvm/Support/CommandLine.h"
  30 #include "llvm/Support/Debug.h"
  31 #include "llvm/Support/SourceMgr.h"
  32 #include "llvm/Transforms/IPO/Internalize.h"
  33 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
  34
  35 #define DEBUG_TYPE "function-import"
  36
  37 using namespace llvm;
  38
  39 STATISTIC(NumImportedFunctions, "Number of functions imported");
  40 STATISTIC(NumImportedModules, "Number of modules imported from");
  41 STATISTIC(NumDeadSymbols, "Number of dead stripped symbols in index");
  42 STATISTIC(NumLiveSymbols, "Number of live symbols in index");
  43
  44 /// Limit on instruction count of imported functions.
  45 static cl::opt<unsigned> ImportInstrLimit(
  46     "import-instr-limit", cl::init(100), cl::Hidden, cl::value_desc("N"),
  47     cl::desc("Only import functions with less than N instructions"));
  48
  49 static cl::opt<float>
  50     ImportInstrFactor("import-instr-evolution-factor", cl::init(0.7),
  51                       cl::Hidden, cl::value_desc("x"),
  52                       cl::desc("As we import functions, multiply the "
  53                                "`import-instr-limit` threshold by this factor "
  54                                "before processing newly imported functions"));
  55
  56 static cl::opt<float> ImportHotInstrFactor(
  57     "import-hot-evolution-factor", cl::init(1.0), cl::Hidden,
  58     cl::value_desc("x"),
  59     cl::desc("As we import functions called from hot callsite, multiply the "
  60              "`import-instr-limit` threshold by this factor "
  61              "before processing newly imported functions"));
  62
  63 static cl::opt<float> ImportHotMultiplier(
  64     "import-hot-multiplier", cl::init(3.0), cl::Hidden, cl::value_desc("x"),
  65     cl::desc("Multiply the `import-instr-limit` threshold for hot callsites"));
  66
  67 // FIXME: This multiplier was not really tuned up.
  68 static cl::opt<float> ImportColdMultiplier(
  69     "import-cold-multiplier", cl::init(0), cl::Hidden, cl::value_desc("N"),
  70     cl::desc("Multiply the `import-instr-limit` threshold for cold callsites"));
  71
  72 static cl::opt<bool> PrintImports("print-imports", cl::init(false), cl::Hidden,
  73                                   cl::desc("Print imported functions"));
  74
  75 static cl::opt<bool> ComputeDead("compute-dead", cl::init(true), cl::Hidden,
  76                                  cl::desc("Compute dead symbols"));
  77
  78 static cl::opt<bool> EnableImportMetadata(
  79     "enable-import-metadata", cl::init(
  80 #if !defined(NDEBUG)
  81                                   true /*Enabled with asserts.*/
  82 #else
  83                                   false
  84 #endif
  85                                   ),
  86     cl::Hidden, cl::desc("Enable import metadata like 'thinlto_src_module'"));
  87
  88 // Load lazily a module from \p FileName in \p Context.
  89 static std::unique_ptr<Module> loadFile(const std::string &FileName,
  90                                         LLVMContext &Context) {
  91   SMDiagnostic Err;
  92   DEBUG(dbgs() << "Loading '" << FileName << "'\n");
  93   // Metadata isn't loaded until functions are imported, to minimize
  94   // the memory overhead.
  95   std::unique_ptr<Module> Result =
  96       getLazyIRFileModule(FileName, Err, Context,
  97                           /* ShouldLazyLoadMetadata = */ true);
  98   if (!Result) {
  99     Err.print("function-import", errs());
 100     report_fatal_error("Abort");
 101   }
 102
 103   return Result;
 104 }
 105
 106 namespace {
 107
 108 /// Given a list of possible callee implementation for a call site, select one
 109 /// that fits the \p Threshold.
 110 ///
 111 /// FIXME: select "best" instead of first that fits. But what is "best"?
 112 /// - The smallest: more likely to be inlined.
 113 /// - The one with the least outgoing edges (already well optimized).
 114 /// - One from a module already being imported from in order to reduce the
 115 ///   number of source modules parsed/linked.
 116 /// - One that has PGO data attached.
 117 /// - [insert you fancy metric here]
 118 static const GlobalValueSummary *
 119 selectCallee(const ModuleSummaryIndex &Index,
 120              const GlobalValueSummaryList &CalleeSummaryList,
 121              unsigned Threshold, StringRef CallerModulePath) {
 122   auto It = llvm::find_if(
 123       CalleeSummaryList,
 124       [&](const std::unique_ptr<GlobalValueSummary> &SummaryPtr) {
 125         auto *GVSummary = SummaryPtr.get();
 126         if (GlobalValue::isInterposableLinkage(GVSummary->linkage()))
 127           // There is no point in importing these, we can't inline them
 128           return false;
 129         if (auto *AS = dyn_cast<AliasSummary>(GVSummary)) {
 130           GVSummary = &AS->getAliasee();
 131           // Alias can't point to "available_externally". However when we import
 132           // linkOnceODR the linkage does not change. So we import the alias
 133           // and aliasee only in this case.
 134           // FIXME: we should import alias as available_externally *function*,
 135           // the destination module does need to know it is an alias.
 136           if (!GlobalValue::isLinkOnceODRLinkage(GVSummary->linkage()))
 137             return false;
 138         }
 139
 140         auto *Summary = cast<FunctionSummary>(GVSummary);
 141
 142         // If this is a local function, make sure we import the copy
 143         // in the caller's module. The only time a local function can
 144         // share an entry in the index is if there is a local with the same name
 145         // in another module that had the same source file name (in a different
 146         // directory), where each was compiled in their own directory so there
 147         // was not distinguishing path.
 148         // However, do the import from another module if there is only one
 149         // entry in the list - in that case this must be a reference due
 150         // to indirect call profile data, since a function pointer can point to
 151         // a local in another module.
 152         if (GlobalValue::isLocalLinkage(Summary->linkage()) &&
 153             CalleeSummaryList.size() > 1 &&
 154             Summary->modulePath() != CallerModulePath)
 155           return false;
 156
 157         if (Summary->instCount() > Threshold)
 158           return false;
 159
 160         if (Summary->notEligibleToImport())
 161           return false;
 162
 163         return true;
 164       });
 165   if (It == CalleeSummaryList.end())
 166     return nullptr;
 167
 168   return cast<GlobalValueSummary>(It->get());
 169 }
 170
 171 /// Return the summary for the function \p GUID that fits the \p Threshold, or
 172 /// null if there's no match.
 173 static const GlobalValueSummary *selectCallee(GlobalValue::GUID GUID,
 174                                               unsigned Threshold,
 175                                               const ModuleSummaryIndex &Index,
 176                                               StringRef CallerModulePath) {
 177   auto CalleeSummaryList = Index.findGlobalValueSummaryList(GUID);
 178   if (CalleeSummaryList == Index.end())
 179     return nullptr; // This function does not have a summary
 180   return selectCallee(Index, CalleeSummaryList->second, Threshold,
 181                       CallerModulePath);
 182 }
 183
 184 using EdgeInfo = std::tuple<const FunctionSummary *, unsigned /* Threshold */,
 185                             GlobalValue::GUID>;
 186
 187 /// Compute the list of functions to import for a given caller. Mark these
 188 /// imported functions and the symbols they reference in their source module as
 189 /// exported from their source module.
 190 static void computeImportForFunction(
 191     const FunctionSummary &Summary, const ModuleSummaryIndex &Index,
 192     const unsigned Threshold, const GVSummaryMapTy &DefinedGVSummaries,
 193     SmallVectorImpl<EdgeInfo> &Worklist,
 194     FunctionImporter::ImportMapTy &ImportList,
 195     StringMap<FunctionImporter::ExportSetTy> *ExportLists = nullptr) {
 196   for (auto &Edge : Summary.calls()) {
 197     auto GUID = Edge.first.getGUID();
 198     DEBUG(dbgs() << " edge -> " << GUID << " Threshold:" << Threshold << "\n");
 199
 200     if (Index.findGlobalValueSummaryList(GUID) == Index.end()) {
 201       // For SamplePGO, the indirect call targets for local functions will
 202       // have its original name annotated in profile. We try to find the
 203       // corresponding PGOFuncName as the GUID.
 204       GUID = Index.getGUIDFromOriginalID(GUID);
 205       if (GUID == 0)
 206         continue;
 207     }
 208
 209     if (DefinedGVSummaries.count(GUID)) {
 210       DEBUG(dbgs() << "ignored! Target already in destination module.\n");
 211       continue;
 212     }
 213
 214     auto GetBonusMultiplier = [](CalleeInfo::HotnessType Hotness) -> float {
 215       if (Hotness == CalleeInfo::HotnessType::Hot)
 216         return ImportHotMultiplier;
 217       if (Hotness == CalleeInfo::HotnessType::Cold)
 218         return ImportColdMultiplier;
 219       return 1.0;
 220     };
 221
 222     const auto NewThreshold =
 223         Threshold * GetBonusMultiplier(Edge.second.Hotness);
 224
 225     auto *CalleeSummary =
 226         selectCallee(GUID, NewThreshold, Index, Summary.modulePath());
 227     if (!CalleeSummary) {
 228       DEBUG(dbgs() << "ignored! No qualifying callee with summary found.\n");
 229       continue;
 230     }
 231     // "Resolve" the summary, traversing alias,
 232     const FunctionSummary *ResolvedCalleeSummary;
 233     if (isa<AliasSummary>(CalleeSummary)) {
 234       ResolvedCalleeSummary = cast<FunctionSummary>(
 235           &cast<AliasSummary>(CalleeSummary)->getAliasee());
 236       assert(
 237           GlobalValue::isLinkOnceODRLinkage(ResolvedCalleeSummary->linkage()) &&
 238           "Unexpected alias to a non-linkonceODR in import list");
 239     } else
 240       ResolvedCalleeSummary = cast<FunctionSummary>(CalleeSummary);
 241
 242     assert(ResolvedCalleeSummary->instCount() <= NewThreshold &&
 243            "selectCallee() didn't honor the threshold");
 244
 245     auto GetAdjustedThreshold = [](unsigned Threshold, bool IsHotCallsite) {
 246       // Adjust the threshold for next level of imported functions.
 247       // The threshold is different for hot callsites because we can then
 248       // inline chains of hot calls.
 249       if (IsHotCallsite)
 250         return Threshold * ImportHotInstrFactor;
 251       return Threshold * ImportInstrFactor;
 252     };
 253
 254     bool IsHotCallsite = Edge.second.Hotness == CalleeInfo::HotnessType::Hot;
 255     const auto AdjThreshold = GetAdjustedThreshold(Threshold, IsHotCallsite);
 256
 257     auto ExportModulePath = ResolvedCalleeSummary->modulePath();
 258     auto &ProcessedThreshold = ImportList[ExportModulePath][GUID];
 259     /// Since the traversal of the call graph is DFS, we can revisit a function
 260     /// a second time with a higher threshold. In this case, it is added back to
 261     /// the worklist with the new threshold.
 262     if (ProcessedThreshold && ProcessedThreshold >= AdjThreshold) {
 263       DEBUG(dbgs() << "ignored! Target was already seen with Threshold "
 264                    << ProcessedThreshold << "\n");
 265       continue;
 266     }
 267     bool PreviouslyImported = ProcessedThreshold != 0;
 268     // Mark this function as imported in this module, with the current Threshold
 269     ProcessedThreshold = AdjThreshold;
 270
 271     // Make exports in the source module.
 272     if (ExportLists) {
 273       auto &ExportList = (*ExportLists)[ExportModulePath];
 274       ExportList.insert(GUID);
 275       if (!PreviouslyImported) {
 276         // This is the first time this function was exported from its source
 277         // module, so mark all functions and globals it references as exported
 278         // to the outside if they are defined in the same source module.
 279         // For efficiency, we unconditionally add all the referenced GUIDs
 280         // to the ExportList for this module, and will prune out any not
 281         // defined in the module later in a single pass.
 282         for (auto &Edge : ResolvedCalleeSummary->calls()) {
 283           auto CalleeGUID = Edge.first.getGUID();
 284           ExportList.insert(CalleeGUID);
 285         }
 286         for (auto &Ref : ResolvedCalleeSummary->refs()) {
 287           auto GUID = Ref.getGUID();
 288           ExportList.insert(GUID);
 289         }
 290       }
 291     }
 292
 293     // Insert the newly imported function to the worklist.
 294     Worklist.emplace_back(ResolvedCalleeSummary, AdjThreshold, GUID);
 295   }
 296 }
 297
 298 /// Given the list of globals defined in a module, compute the list of imports
 299 /// as well as the list of "exports", i.e. the list of symbols referenced from
 300 /// another module (that may require promotion).
 301 static void ComputeImportForModule(
 302     const GVSummaryMapTy &DefinedGVSummaries, const ModuleSummaryIndex &Index,
 303     FunctionImporter::ImportMapTy &ImportList,
 304     StringMap<FunctionImporter::ExportSetTy> *ExportLists = nullptr,
 305     const DenseSet<GlobalValue::GUID> *DeadSymbols = nullptr) {
 306   // Worklist contains the list of function imported in this module, for which
 307   // we will analyse the callees and may import further down the callgraph.
 308   SmallVector<EdgeInfo, 128> Worklist;
 309
 310   // Populate the worklist with the import for the functions in the current
 311   // module
 312   for (auto &GVSummary : DefinedGVSummaries) {
 313     if (DeadSymbols && DeadSymbols->count(GVSummary.first)) {
 314       DEBUG(dbgs() << "Ignores Dead GUID: " << GVSummary.first << "\n");
 315       continue;
 316     }
 317     auto *Summary = GVSummary.second;
 318     if (auto *AS = dyn_cast<AliasSummary>(Summary))
 319       Summary = &AS->getAliasee();
 320     auto *FuncSummary = dyn_cast<FunctionSummary>(Summary);
 321     if (!FuncSummary)
 322       // Skip import for global variables
 323       continue;
 324     DEBUG(dbgs() << "Initalize import for " << GVSummary.first << "\n");
 325     computeImportForFunction(*FuncSummary, Index, ImportInstrLimit,
 326                              DefinedGVSummaries, Worklist, ImportList,
 327                              ExportLists);
 328   }
 329
 330   // Process the newly imported functions and add callees to the worklist.
 331   while (!Worklist.empty()) {
 332     auto FuncInfo = Worklist.pop_back_val();
 333     auto *Summary = std::get<0>(FuncInfo);
 334     auto Threshold = std::get<1>(FuncInfo);
 335     auto GUID = std::get<2>(FuncInfo);
 336
 337     // Check if we later added this summary with a higher threshold.
 338     // If so, skip this entry.
 339     auto ExportModulePath = Summary->modulePath();
 340     auto &LatestProcessedThreshold = ImportList[ExportModulePath][GUID];
 341     if (LatestProcessedThreshold > Threshold)
 342       continue;
 343
 344     computeImportForFunction(*Summary, Index, Threshold, DefinedGVSummaries,
 345                              Worklist, ImportList, ExportLists);
 346   }
 347 }
 348
 349 } // anonymous namespace
 350
 351 /// Compute all the import and export for every module using the Index.
 352 void llvm::ComputeCrossModuleImport(
 353     const ModuleSummaryIndex &Index,
 354     const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
 355     StringMap<FunctionImporter::ImportMapTy> &ImportLists,
 356     StringMap<FunctionImporter::ExportSetTy> &ExportLists,
 357     const DenseSet<GlobalValue::GUID> *DeadSymbols) {
 358   // For each module that has function defined, compute the import/export lists.
 359   for (auto &DefinedGVSummaries : ModuleToDefinedGVSummaries) {
 360     auto &ImportList = ImportLists[DefinedGVSummaries.first()];
 361     DEBUG(dbgs() << "Computing import for Module '"
 362                  << DefinedGVSummaries.first() << "'\n");
 363     ComputeImportForModule(DefinedGVSummaries.second, Index, ImportList,
 364                            &ExportLists, DeadSymbols);
 365   }
 366
 367   // When computing imports we added all GUIDs referenced by anything
 368   // imported from the module to its ExportList. Now we prune each ExportList
 369   // of any not defined in that module. This is more efficient than checking
 370   // while computing imports because some of the summary lists may be long
 371   // due to linkonce (comdat) copies.
 372   for (auto &ELI : ExportLists) {
 373     const auto &DefinedGVSummaries =
 374         ModuleToDefinedGVSummaries.lookup(ELI.first());
 375     for (auto EI = ELI.second.begin(); EI != ELI.second.end();) {
 376       if (!DefinedGVSummaries.count(*EI))
 377         EI = ELI.second.erase(EI);
 378       else
 379         ++EI;
 380     }
 381   }
 382
 383 #ifndef NDEBUG
 384   DEBUG(dbgs() << "Import/Export lists for " << ImportLists.size()
 385                << " modules:\n");
 386   for (auto &ModuleImports : ImportLists) {
 387     auto ModName = ModuleImports.first();
 388     auto &Exports = ExportLists[ModName];
 389     DEBUG(dbgs() << "* Module " << ModName << " exports " << Exports.size()
 390                  << " functions. Imports from " << ModuleImports.second.size()
 391                  << " modules.\n");
 392     for (auto &Src : ModuleImports.second) {
 393       auto SrcModName = Src.first();
 394       DEBUG(dbgs() << " - " << Src.second.size() << " functions imported from "
 395                    << SrcModName << "\n");
 396     }
 397   }
 398 #endif
 399 }
 400
 401 /// Compute all the imports for the given module in the Index.
 402 void llvm::ComputeCrossModuleImportForModule(
 403     StringRef ModulePath, const ModuleSummaryIndex &Index,
 404     FunctionImporter::ImportMapTy &ImportList) {
 405
 406   // Collect the list of functions this module defines.
 407   // GUID -> Summary
 408   GVSummaryMapTy FunctionSummaryMap;
 409   Index.collectDefinedFunctionsForModule(ModulePath, FunctionSummaryMap);
 410
 411   // Compute the import list for this module.
 412   DEBUG(dbgs() << "Computing import for Module '" << ModulePath << "'\n");
 413   ComputeImportForModule(FunctionSummaryMap, Index, ImportList);
 414
 415 #ifndef NDEBUG
 416   DEBUG(dbgs() << "* Module " << ModulePath << " imports from "
 417                << ImportList.size() << " modules.\n");
 418   for (auto &Src : ImportList) {
 419     auto SrcModName = Src.first();
 420     DEBUG(dbgs() << " - " << Src.second.size() << " functions imported from "
 421                  << SrcModName << "\n");
 422   }
 423 #endif
 424 }
 425
 426 DenseSet<GlobalValue::GUID> llvm::computeDeadSymbols(
 427     const ModuleSummaryIndex &Index,
 428     const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) {
 429   if (!ComputeDead)
 430     return DenseSet<GlobalValue::GUID>();
 431   if (GUIDPreservedSymbols.empty())
 432     // Don't do anything when nothing is live, this is friendly with tests.
 433     return DenseSet<GlobalValue::GUID>();
 434   DenseSet<GlobalValue::GUID> LiveSymbols = GUIDPreservedSymbols;
 435   SmallVector<GlobalValue::GUID, 128> Worklist;
 436   Worklist.reserve(LiveSymbols.size() * 2);
 437   for (auto GUID : LiveSymbols) {
 438     DEBUG(dbgs() << "Live root: " << GUID << "\n");
 439     Worklist.push_back(GUID);
 440   }
 441   // Add values flagged in the index as live roots to the worklist.
 442   for (const auto &Entry : Index) {
 443     bool IsLiveRoot = llvm::any_of(
 444         Entry.second,
 445         [&](const std::unique_ptr<llvm::GlobalValueSummary> &Summary) {
 446           return Summary->liveRoot();
 447         });
 448     if (!IsLiveRoot)
 449       continue;
 450     DEBUG(dbgs() << "Live root (summary): " << Entry.first << "\n");
 451     Worklist.push_back(Entry.first);
 452   }
 453
 454   while (!Worklist.empty()) {
 455     auto GUID = Worklist.pop_back_val();
 456     auto It = Index.findGlobalValueSummaryList(GUID);
 457     if (It == Index.end()) {
 458       DEBUG(dbgs() << "Not in index: " << GUID << "\n");
 459       continue;
 460     }
 461
 462     // FIXME: we should only make the prevailing copy live here
 463     for (auto &Summary : It->second) {
 464       for (auto Ref : Summary->refs()) {
 465         auto RefGUID = Ref.getGUID();
 466         if (LiveSymbols.insert(RefGUID).second) {
 467           DEBUG(dbgs() << "Marking live (ref): " << RefGUID << "\n");
 468           Worklist.push_back(RefGUID);
 469         }
 470       }
 471       if (auto *FS = dyn_cast<FunctionSummary>(Summary.get())) {
 472         for (auto Call : FS->calls()) {
 473           auto CallGUID = Call.first.getGUID();
 474           if (LiveSymbols.insert(CallGUID).second) {
 475             DEBUG(dbgs() << "Marking live (call): " << CallGUID << "\n");
 476             Worklist.push_back(CallGUID);
 477           }
 478         }
 479       }
 480       if (auto *AS = dyn_cast<AliasSummary>(Summary.get())) {
 481         auto AliaseeGUID = AS->getAliasee().getOriginalName();
 482         if (LiveSymbols.insert(AliaseeGUID).second) {
 483           DEBUG(dbgs() << "Marking live (alias): " << AliaseeGUID << "\n");
 484           Worklist.push_back(AliaseeGUID);
 485         }
 486       }
 487     }
 488   }
 489   DenseSet<GlobalValue::GUID> DeadSymbols;
 490   DeadSymbols.reserve(
 491       std::min(Index.size(), Index.size() - LiveSymbols.size()));
 492   for (auto &Entry : Index) {
 493     auto GUID = Entry.first;
 494     if (!LiveSymbols.count(GUID)) {
 495       DEBUG(dbgs() << "Marking dead: " << GUID << "\n");
 496       DeadSymbols.insert(GUID);
 497     }
 498   }
 499   DEBUG(dbgs() << LiveSymbols.size() << " symbols Live, and "
 500                << DeadSymbols.size() << " symbols Dead \n");
 501   NumDeadSymbols += DeadSymbols.size();
 502   NumLiveSymbols += LiveSymbols.size();
 503   return DeadSymbols;
 504 }
 505
 506 /// Compute the set of summaries needed for a ThinLTO backend compilation of
 507 /// \p ModulePath.
 508 void llvm::gatherImportedSummariesForModule(
 509     StringRef ModulePath,
 510     const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
 511     const FunctionImporter::ImportMapTy &ImportList,
 512     std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex) {
 513   // Include all summaries from the importing module.
 514   ModuleToSummariesForIndex[ModulePath] =
 515       ModuleToDefinedGVSummaries.lookup(ModulePath);
 516   // Include summaries for imports.
 517   for (auto &ILI : ImportList) {
 518     auto &SummariesForIndex = ModuleToSummariesForIndex[ILI.first()];
 519     const auto &DefinedGVSummaries =
 520         ModuleToDefinedGVSummaries.lookup(ILI.first());
 521     for (auto &GI : ILI.second) {
 522       const auto &DS = DefinedGVSummaries.find(GI.first);
 523       assert(DS != DefinedGVSummaries.end() &&
 524              "Expected a defined summary for imported global value");
 525       SummariesForIndex[GI.first] = DS->second;
 526     }
 527   }
 528 }
 529
 530 /// Emit the files \p ModulePath will import from into \p OutputFilename.
 531 std::error_code
 532 llvm::EmitImportsFiles(StringRef ModulePath, StringRef OutputFilename,
 533                        const FunctionImporter::ImportMapTy &ModuleImports) {
 534   std::error_code EC;
 535   raw_fd_ostream ImportsOS(OutputFilename, EC, sys::fs::OpenFlags::F_None);
 536   if (EC)
 537     return EC;
 538   for (auto &ILI : ModuleImports)
 539     ImportsOS << ILI.first() << "\n";
 540   return std::error_code();
 541 }
 542
 543 /// Fixup WeakForLinker linkages in \p TheModule based on summary analysis.
 544 void llvm::thinLTOResolveWeakForLinkerModule(
 545     Module &TheModule, const GVSummaryMapTy &DefinedGlobals) {
 546   auto ConvertToDeclaration = [](GlobalValue &GV) {
 547     DEBUG(dbgs() << "Converting to a declaration: `" << GV.getName() << "\n");
 548     if (Function *F = dyn_cast<Function>(&GV)) {
 549       F->deleteBody();
 550       F->clearMetadata();
 551     } else if (GlobalVariable *V = dyn_cast<GlobalVariable>(&GV)) {
 552       V->setInitializer(nullptr);
 553       V->setLinkage(GlobalValue::ExternalLinkage);
 554       V->clearMetadata();
 555     } else
 556       // For now we don't resolve or drop aliases. Once we do we'll
 557       // need to add support here for creating either a function or
 558       // variable declaration, and return the new GlobalValue* for
 559       // the caller to use.
 560       llvm_unreachable("Expected function or variable");
 561   };
 562
 563   auto updateLinkage = [&](GlobalValue &GV) {
 564     if (!GlobalValue::isWeakForLinker(GV.getLinkage()))
 565       return;
 566     // See if the global summary analysis computed a new resolved linkage.
 567     const auto &GS = DefinedGlobals.find(GV.getGUID());
 568     if (GS == DefinedGlobals.end())
 569       return;
 570     auto NewLinkage = GS->second->linkage();
 571     if (NewLinkage == GV.getLinkage())
 572       return;
 573     // Check for a non-prevailing def that has interposable linkage
 574     // (e.g. non-odr weak or linkonce). In that case we can't simply
 575     // convert to available_externally, since it would lose the
 576     // interposable property and possibly get inlined. Simply drop
 577     // the definition in that case.
 578     if (GlobalValue::isAvailableExternallyLinkage(NewLinkage) &&
 579         GlobalValue::isInterposableLinkage(GV.getLinkage()))
 580       ConvertToDeclaration(GV);
 581     else {
 582       DEBUG(dbgs() << "ODR fixing up linkage for `" << GV.getName() << "` from "
 583                    << GV.getLinkage() << " to " << NewLinkage << "\n");
 584       GV.setLinkage(NewLinkage);
 585     }
 586     // Remove declarations from comdats, including available_externally
 587     // as this is a declaration for the linker, and will be dropped eventually.
 588     // It is illegal for comdats to contain declarations.
 589     auto *GO = dyn_cast_or_null<GlobalObject>(&GV);
 590     if (GO && GO->isDeclarationForLinker() && GO->hasComdat())
 591       GO->setComdat(nullptr);
 592   };
 593
 594   // Process functions and global now
 595   for (auto &GV : TheModule)
 596     updateLinkage(GV);
 597   for (auto &GV : TheModule.globals())
 598     updateLinkage(GV);
 599   for (auto &GV : TheModule.aliases())
 600     updateLinkage(GV);
 601 }
 602
 603 /// Run internalization on \p TheModule based on symmary analysis.
 604 void llvm::thinLTOInternalizeModule(Module &TheModule,
 605                                     const GVSummaryMapTy &DefinedGlobals) {
 606   // Parse inline ASM and collect the list of symbols that are not defined in
 607   // the current module.
 608   StringSet<> AsmUndefinedRefs;
 609   ModuleSymbolTable::CollectAsmSymbols(
 610       TheModule,
 611       [&AsmUndefinedRefs](StringRef Name, object::BasicSymbolRef::Flags Flags) {
 612         if (Flags & object::BasicSymbolRef::SF_Undefined)
 613           AsmUndefinedRefs.insert(Name);
 614       });
 615
 616   // Declare a callback for the internalize pass that will ask for every
 617   // candidate GlobalValue if it can be internalized or not.
 618   auto MustPreserveGV = [&](const GlobalValue &GV) -> bool {
 619     // Can't be internalized if referenced in inline asm.
 620     if (AsmUndefinedRefs.count(GV.getName()))
 621       return true;
 622
 623     // Lookup the linkage recorded in the summaries during global analysis.
 624     const auto &GS = DefinedGlobals.find(GV.getGUID());
 625     GlobalValue::LinkageTypes Linkage;
 626     if (GS == DefinedGlobals.end()) {
 627       // Must have been promoted (possibly conservatively). Find original
 628       // name so that we can access the correct summary and see if it can
 629       // be internalized again.
 630       // FIXME: Eventually we should control promotion instead of promoting
 631       // and internalizing again.
 632       StringRef OrigName =
 633           ModuleSummaryIndex::getOriginalNameBeforePromote(GV.getName());
 634       std::string OrigId = GlobalValue::getGlobalIdentifier(
 635           OrigName, GlobalValue::InternalLinkage,
 636           TheModule.getSourceFileName());
 637       const auto &GS = DefinedGlobals.find(GlobalValue::getGUID(OrigId));
 638       if (GS == DefinedGlobals.end()) {
 639         // Also check the original non-promoted non-globalized name. In some
 640         // cases a preempted weak value is linked in as a local copy because
 641         // it is referenced by an alias (IRLinker::linkGlobalValueProto).
 642         // In that case, since it was originally not a local value, it was
 643         // recorded in the index using the original name.
 644         // FIXME: This may not be needed once PR27866 is fixed.
 645         const auto &GS = DefinedGlobals.find(GlobalValue::getGUID(OrigName));
 646         assert(GS != DefinedGlobals.end());
 647         Linkage = GS->second->linkage();
 648       } else {
 649         Linkage = GS->second->linkage();
 650       }
 651     } else
 652       Linkage = GS->second->linkage();
 653     return !GlobalValue::isLocalLinkage(Linkage);
 654   };
 655
 656   // FIXME: See if we can just internalize directly here via linkage changes
 657   // based on the index, rather than invoking internalizeModule.
 658   llvm::internalizeModule(TheModule, MustPreserveGV);
 659 }
 660
 661 // Automatically import functions in Module \p DestModule based on the summaries
 662 // index.
 663 //
 664 Expected<bool> FunctionImporter::importFunctions(
 665     Module &DestModule, const FunctionImporter::ImportMapTy &ImportList) {
 666   DEBUG(dbgs() << "Starting import for Module "
 667                << DestModule.getModuleIdentifier() << "\n");
 668   unsigned ImportedCount = 0;
 669
 670   IRMover Mover(DestModule);
 671   // Do the actual import of functions now, one Module at a time
 672   std::set<StringRef> ModuleNameOrderedList;
 673   for (auto &FunctionsToImportPerModule : ImportList) {
 674     ModuleNameOrderedList.insert(FunctionsToImportPerModule.first());
 675   }
 676   for (auto &Name : ModuleNameOrderedList) {
 677     // Get the module for the import
 678     const auto &FunctionsToImportPerModule = ImportList.find(Name);
 679     assert(FunctionsToImportPerModule != ImportList.end());
 680     Expected<std::unique_ptr<Module>> SrcModuleOrErr = ModuleLoader(Name);
 681     if (!SrcModuleOrErr)
 682       return SrcModuleOrErr.takeError();
 683     std::unique_ptr<Module> SrcModule = std::move(*SrcModuleOrErr);
 684     assert(&DestModule.getContext() == &SrcModule->getContext() &&
 685            "Context mismatch");
 686
 687     // If modules were created with lazy metadata loading, materialize it
 688     // now, before linking it (otherwise this will be a noop).
 689     if (Error Err = SrcModule->materializeMetadata())
 690       return std::move(Err);
 691
 692     auto &ImportGUIDs = FunctionsToImportPerModule->second;
 693     // Find the globals to import
 694     SetVector<GlobalValue *> GlobalsToImport;
 695     for (Function &F : *SrcModule) {
 696       if (!F.hasName())
 697         continue;
 698       auto GUID = F.getGUID();
 699       auto Import = ImportGUIDs.count(GUID);
 700       DEBUG(dbgs() << (Import ? "Is" : "Not") << " importing function " << GUID
 701                    << " " << F.getName() << " from "
 702                    << SrcModule->getSourceFileName() << "\n");
 703       if (Import) {
 704         if (Error Err = F.materialize())
 705           return std::move(Err);
 706         if (EnableImportMetadata) {
 707           // Add 'thinlto_src_module' metadata for statistics and debugging.
 708           F.setMetadata(
 709               "thinlto_src_module",
 710               llvm::MDNode::get(
 711                   DestModule.getContext(),
 712                   {llvm::MDString::get(DestModule.getContext(),
 713                                        SrcModule->getSourceFileName())}));
 714         }
 715         GlobalsToImport.insert(&F);
 716       }
 717     }
 718     for (GlobalVariable &GV : SrcModule->globals()) {
 719       if (!GV.hasName())
 720         continue;
 721       auto GUID = GV.getGUID();
 722       auto Import = ImportGUIDs.count(GUID);
 723       DEBUG(dbgs() << (Import ? "Is" : "Not") << " importing global " << GUID
 724                    << " " << GV.getName() << " from "
 725                    << SrcModule->getSourceFileName() << "\n");
 726       if (Import) {
 727         if (Error Err = GV.materialize())
 728           return std::move(Err);
 729         GlobalsToImport.insert(&GV);
 730       }
 731     }
 732     for (GlobalAlias &GA : SrcModule->aliases()) {
 733       // FIXME: This should eventually be controlled entirely by the summary.
 734       if (FunctionImportGlobalProcessing::doImportAsDefinition(
 735               &GA, &GlobalsToImport)) {
 736         GlobalsToImport.insert(&GA);
 737         continue;
 738       }
 739
 740       if (!GA.hasName())
 741         continue;
 742       auto GUID = GA.getGUID();
 743       auto Import = ImportGUIDs.count(GUID);
 744       DEBUG(dbgs() << (Import ? "Is" : "Not") << " importing alias " << GUID
 745                    << " " << GA.getName() << " from "
 746                    << SrcModule->getSourceFileName() << "\n");
 747       if (Import) {
 748         // Alias can't point to "available_externally". However when we import
 749         // linkOnceODR the linkage does not change. So we import the alias
 750         // and aliasee only in this case. This has been handled by
 751         // computeImportForFunction()
 752         GlobalObject *GO = GA.getBaseObject();
 753         assert(GO->hasLinkOnceODRLinkage() &&
 754                "Unexpected alias to a non-linkonceODR in import list");
 755 #ifndef NDEBUG
 756         if (!GlobalsToImport.count(GO))
 757           DEBUG(dbgs() << " alias triggers importing aliasee " << GO->getGUID()
 758                        << " " << GO->getName() << " from "
 759                        << SrcModule->getSourceFileName() << "\n");
 760 #endif
 761         if (Error Err = GO->materialize())
 762           return std::move(Err);
 763         GlobalsToImport.insert(GO);
 764         if (Error Err = GA.materialize())
 765           return std::move(Err);
 766         GlobalsToImport.insert(&GA);
 767       }
 768     }
 769
 770     // Upgrade debug info after we're done materializing all the globals and we
 771     // have loaded all the required metadata!
 772     UpgradeDebugInfo(*SrcModule);
 773
 774     // Link in the specified functions.
 775     if (renameModuleForThinLTO(*SrcModule, Index, &GlobalsToImport))
 776       return true;
 777
 778     if (PrintImports) {
 779       for (const auto *GV : GlobalsToImport)
 780         dbgs() << DestModule.getSourceFileName() << ": Import " << GV->getName()
 781                << " from " << SrcModule->getSourceFileName() << "\n";
 782     }
 783
 784     if (Mover.move(std::move(SrcModule), GlobalsToImport.getArrayRef(),
 785                    [](GlobalValue &, IRMover::ValueAdder) {},
 786                    /*IsPerformingImport=*/true))
 787       report_fatal_error("Function Import: link error");
 788
 789     ImportedCount += GlobalsToImport.size();
 790     NumImportedModules++;
 791   }
 792
 793   NumImportedFunctions += ImportedCount;
 794
 795   DEBUG(dbgs() << "Imported " << ImportedCount << " functions for Module "
 796                << DestModule.getModuleIdentifier() << "\n");
 797   return ImportedCount;
 798 }
 799
 800 /// Summary file to use for function importing when using -function-import from
 801 /// the command line.
 802 static cl::opt<std::string>
 803     SummaryFile("summary-file",
 804                 cl::desc("The summary file to use for function importing."));
 805
 806 static bool doImportingForModule(Module &M) {
 807   if (SummaryFile.empty())
 808     report_fatal_error("error: -function-import requires -summary-file\n");
 809   Expected<std::unique_ptr<ModuleSummaryIndex>> IndexPtrOrErr =
 810       getModuleSummaryIndexForFile(SummaryFile);
 811   if (!IndexPtrOrErr) {
 812     logAllUnhandledErrors(IndexPtrOrErr.takeError(), errs(),
 813                           "Error loading file '" + SummaryFile + "': ");
 814     return false;
 815   }
 816   std::unique_ptr<ModuleSummaryIndex> Index = std::move(*IndexPtrOrErr);
 817
 818   // First step is collecting the import list.
 819   FunctionImporter::ImportMapTy ImportList;
 820   ComputeCrossModuleImportForModule(M.getModuleIdentifier(), *Index,
 821                                     ImportList);
 822
 823   // Conservatively mark all internal values as promoted. This interface is
 824   // only used when doing importing via the function importing pass. The pass
 825   // is only enabled when testing importing via the 'opt' tool, which does
 826   // not do the ThinLink that would normally determine what values to promote.
 827   for (auto &I : *Index) {
 828     for (auto &S : I.second) {
 829       if (GlobalValue::isLocalLinkage(S->linkage()))
 830         S->setLinkage(GlobalValue::ExternalLinkage);
 831     }
 832   }
 833
 834   // Next we need to promote to global scope and rename any local values that
 835   // are potentially exported to other modules.
 836   if (renameModuleForThinLTO(M, *Index, nullptr)) {
 837     errs() << "Error renaming module\n";
 838     return false;
 839   }
 840
 841   // Perform the import now.
 842   auto ModuleLoader = [&M](StringRef Identifier) {
 843     return loadFile(Identifier, M.getContext());
 844   };
 845   FunctionImporter Importer(*Index, ModuleLoader);
 846   Expected<bool> Result = Importer.importFunctions(M, ImportList);
 847
 848   // FIXME: Probably need to propagate Errors through the pass manager.
 849   if (!Result) {
 850     logAllUnhandledErrors(Result.takeError(), errs(),
 851                           "Error importing module: ");
 852     return false;
 853   }
 854
 855   return *Result;
 856 }
 857
 858 namespace {
 859 /// Pass that performs cross-module function import provided a summary file.
 860 class FunctionImportLegacyPass : public ModulePass {
 861 public:
 862   /// Pass identification, replacement for typeid
 863   static char ID;
 864
 865   /// Specify pass name for debug output
 866   StringRef getPassName() const override { return "Function Importing"; }
 867
 868   explicit FunctionImportLegacyPass() : ModulePass(ID) {}
 869
 870   bool runOnModule(Module &M) override {
 871     if (skipModule(M))
 872       return false;
 873
 874     return doImportingForModule(M);
 875   }
 876 };
 877 } // anonymous namespace
 878
 879 PreservedAnalyses FunctionImportPass::run(Module &M,
 880                                           ModuleAnalysisManager &AM) {
 881   if (!doImportingForModule(M))
 882     return PreservedAnalyses::all();
 883
 884   return PreservedAnalyses::none();
 885 }
 886
 887 char FunctionImportLegacyPass::ID = 0;
 888 INITIALIZE_PASS(FunctionImportLegacyPass, "function-import",
 889                 "Summary Based Function Import", false, false)
 890
 891 namespace llvm {
 892 Pass *createFunctionImportPass() {
 893   return new FunctionImportLegacyPass();
 894 }
 895 }