contrib/llvm/include/llvm/Transforms/IPO/FunctionImport.h

   1 //===- llvm/Transforms/IPO/FunctionImport.h - ThinLTO importing -*- C++ -*-===//
   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 #ifndef LLVM_TRANSFORMS_IPO_FUNCTIONIMPORT_H
  11 #define LLVM_TRANSFORMS_IPO_FUNCTIONIMPORT_H
  12
  13 #include "llvm/ADT/DenseSet.h"
  14 #include "llvm/ADT/StringMap.h"
  15 #include "llvm/ADT/StringRef.h"
  16 #include "llvm/IR/GlobalValue.h"
  17 #include "llvm/IR/ModuleSummaryIndex.h"
  18 #include "llvm/IR/PassManager.h"
  19 #include "llvm/Support/Error.h"
  20 #include <functional>
  21 #include <map>
  22 #include <memory>
  23 #include <string>
  24 #include <system_error>
  25 #include <unordered_set>
  26 #include <utility>
  27
  28 namespace llvm {
  29
  30 class Module;
  31
  32 /// The function importer is automatically importing function from other modules
  33 /// based on the provided summary informations.
  34 class FunctionImporter {
  35 public:
  36   /// Set of functions to import from a source module. Each entry is a set
  37   /// containing all the GUIDs of all functions to import for a source module.
  38   using FunctionsToImportTy = std::unordered_set<GlobalValue::GUID>;
  39
  40   /// Map of callee GUID considered for import into a given module to a pair
  41   /// consisting of the largest threshold applied when deciding whether to
  42   /// import it and, if we decided to import, a pointer to the summary instance
  43   /// imported. If we decided not to import, the summary will be nullptr.
  44   using ImportThresholdsTy =
  45       DenseMap<GlobalValue::GUID,
  46                std::pair<unsigned, const GlobalValueSummary *>>;
  47
  48   /// The map contains an entry for every module to import from, the key being
  49   /// the module identifier to pass to the ModuleLoader. The value is the set of
  50   /// functions to import.
  51   using ImportMapTy = StringMap<FunctionsToImportTy>;
  52
  53   /// The set contains an entry for every global value the module exports.
  54   using ExportSetTy = std::unordered_set<GlobalValue::GUID>;
  55
  56   /// A function of this type is used to load modules referenced by the index.
  57   using ModuleLoaderTy =
  58       std::function<Expected<std::unique_ptr<Module>>(StringRef Identifier)>;
  59
  60   /// Create a Function Importer.
  61   FunctionImporter(const ModuleSummaryIndex &Index, ModuleLoaderTy ModuleLoader)
  62       : Index(Index), ModuleLoader(std::move(ModuleLoader)) {}
  63
  64   /// Import functions in Module \p M based on the supplied import list.
  65   Expected<bool> importFunctions(Module &M, const ImportMapTy &ImportList);
  66
  67 private:
  68   /// The summaries index used to trigger importing.
  69   const ModuleSummaryIndex &Index;
  70
  71   /// Factory function to load a Module for a given identifier
  72   ModuleLoaderTy ModuleLoader;
  73 };
  74
  75 /// The function importing pass
  76 class FunctionImportPass : public PassInfoMixin<FunctionImportPass> {
  77 public:
  78   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
  79 };
  80
  81 /// Compute all the imports and exports for every module in the Index.
  82 ///
  83 /// \p ModuleToDefinedGVSummaries contains for each Module a map
  84 /// (GUID -> Summary) for every global defined in the module.
  85 ///
  86 /// \p ImportLists will be populated with an entry for every Module we are
  87 /// importing into. This entry is itself a map that can be passed to
  88 /// FunctionImporter::importFunctions() above (see description there).
  89 ///
  90 /// \p ExportLists contains for each Module the set of globals (GUID) that will
  91 /// be imported by another module, or referenced by such a function. I.e. this
  92 /// is the set of globals that need to be promoted/renamed appropriately.
  93 void ComputeCrossModuleImport(
  94     const ModuleSummaryIndex &Index,
  95     const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
  96     StringMap<FunctionImporter::ImportMapTy> &ImportLists,
  97     StringMap<FunctionImporter::ExportSetTy> &ExportLists);
  98
  99 /// Compute all the imports for the given module using the Index.
 100 ///
 101 /// \p ImportList will be populated with a map that can be passed to
 102 /// FunctionImporter::importFunctions() above (see description there).
 103 void ComputeCrossModuleImportForModule(
 104     StringRef ModulePath, const ModuleSummaryIndex &Index,
 105     FunctionImporter::ImportMapTy &ImportList);
 106
 107 /// Mark all external summaries in \p Index for import into the given module.
 108 /// Used for distributed builds using a distributed index.
 109 ///
 110 /// \p ImportList will be populated with a map that can be passed to
 111 /// FunctionImporter::importFunctions() above (see description there).
 112 void ComputeCrossModuleImportForModuleFromIndex(
 113     StringRef ModulePath, const ModuleSummaryIndex &Index,
 114     FunctionImporter::ImportMapTy &ImportList);
 115
 116 /// PrevailingType enum used as a return type of callback passed
 117 /// to computeDeadSymbols. Yes and No values used when status explicitly
 118 /// set by symbols resolution, otherwise status is Unknown.
 119 enum class PrevailingType { Yes, No, Unknown };
 120
 121 /// Compute all the symbols that are "dead": i.e these that can't be reached
 122 /// in the graph from any of the given symbols listed in
 123 /// \p GUIDPreservedSymbols. Non-prevailing symbols are symbols without a
 124 /// prevailing copy anywhere in IR and are normally dead, \p isPrevailing
 125 /// predicate returns status of symbol.
 126 void computeDeadSymbols(
 127     ModuleSummaryIndex &Index,
 128     const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols,
 129     function_ref<PrevailingType(GlobalValue::GUID)> isPrevailing);
 130
 131 /// Converts value \p GV to declaration, or replaces with a declaration if
 132 /// it is an alias. Returns true if converted, false if replaced.
 133 bool convertToDeclaration(GlobalValue &GV);
 134
 135 /// Compute the set of summaries needed for a ThinLTO backend compilation of
 136 /// \p ModulePath.
 137 //
 138 /// This includes summaries from that module (in case any global summary based
 139 /// optimizations were recorded) and from any definitions in other modules that
 140 /// should be imported.
 141 //
 142 /// \p ModuleToSummariesForIndex will be populated with the needed summaries
 143 /// from each required module path. Use a std::map instead of StringMap to get
 144 /// stable order for bitcode emission.
 145 void gatherImportedSummariesForModule(
 146     StringRef ModulePath,
 147     const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
 148     const FunctionImporter::ImportMapTy &ImportList,
 149     std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex);
 150
 151 /// Emit into \p OutputFilename the files module \p ModulePath will import from.
 152 std::error_code EmitImportsFiles(
 153     StringRef ModulePath, StringRef OutputFilename,
 154     const std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex);
 155
 156 /// Resolve WeakForLinker values in \p TheModule based on the information
 157 /// recorded in the summaries during global summary-based analysis.
 158 void thinLTOResolveWeakForLinkerModule(Module &TheModule,
 159                                        const GVSummaryMapTy &DefinedGlobals);
 160
 161 /// Internalize \p TheModule based on the information recorded in the summaries
 162 /// during global summary-based analysis.
 163 void thinLTOInternalizeModule(Module &TheModule,
 164                               const GVSummaryMapTy &DefinedGlobals);
 165
 166 } // end namespace llvm
 167
 168 #endif // LLVM_TRANSFORMS_IPO_FUNCTIONIMPORT_H