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. FunctionImporter(const ModuleSummaryIndex & Index,ModuleLoaderTy ModuleLoader)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 169