1 //===-- llvm/FunctionInfo.h - Function Info Index ---------------*- 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 /// @file 11 /// FunctionInfo.h This file contains the declarations the classes that hold 12 /// the function info index and summary. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #ifndef LLVM_IR_FUNCTIONINFO_H 17 #define LLVM_IR_FUNCTIONINFO_H 18 19 #include "llvm/ADT/SmallString.h" 20 #include "llvm/ADT/StringMap.h" 21 #include "llvm/IR/Module.h" 22 #include "llvm/Support/MemoryBuffer.h" 23 #include "llvm/Support/raw_ostream.h" 24 25 namespace llvm { 26 27 /// \brief Function summary information to aid decisions and implementation of 28 /// importing. 29 /// 30 /// This is a separate class from FunctionInfo to enable lazy reading of this 31 /// function summary information from the combined index file during imporing. 32 class FunctionSummary { 33 private: 34 /// \brief Path of module containing function IR, used to locate module when 35 /// importing this function. 36 /// 37 /// This is only used during parsing of the combined function index, or when 38 /// parsing the per-module index for creation of the combined function index, 39 /// not during writing of the per-module index which doesn't contain a 40 /// module path string table. 41 StringRef ModulePath; 42 43 /// \brief Used to flag functions that have local linkage types and need to 44 /// have module identifier appended before placing into the combined 45 /// index, to disambiguate from other functions with the same name. 46 /// 47 /// This is only used in the per-module function index, as it is consumed 48 /// while creating the combined index. 49 bool IsLocalFunction; 50 51 // The rest of the information is used to help decide whether importing 52 // is likely to be profitable. 53 // Other information will be added as the importing is tuned, such 54 // as hotness (when profile available), and other function characteristics. 55 56 /// Number of instructions (ignoring debug instructions, e.g.) computed 57 /// during the initial compile step when the function index is first built. 58 unsigned InstCount; 59 60 public: 61 /// Construct a summary object from summary data expected for all 62 /// summary records. FunctionSummary(unsigned NumInsts)63 FunctionSummary(unsigned NumInsts) : InstCount(NumInsts) {} 64 65 /// Set the path to the module containing this function, for use in 66 /// the combined index. setModulePath(StringRef ModPath)67 void setModulePath(StringRef ModPath) { ModulePath = ModPath; } 68 69 /// Get the path to the module containing this function. modulePath()70 StringRef modulePath() const { return ModulePath; } 71 72 /// Record whether this is a local function in the per-module index. setLocalFunction(bool IsLocal)73 void setLocalFunction(bool IsLocal) { IsLocalFunction = IsLocal; } 74 75 /// Check whether this was a local function, for use in creating 76 /// the combined index. isLocalFunction()77 bool isLocalFunction() const { return IsLocalFunction; } 78 79 /// Get the instruction count recorded for this function. instCount()80 unsigned instCount() const { return InstCount; } 81 }; 82 83 /// \brief Class to hold pointer to function summary and information required 84 /// for parsing it. 85 /// 86 /// For the per-module index, this holds the bitcode offset 87 /// of the corresponding function block. For the combined index, 88 /// after parsing of the \a ValueSymbolTable, this initially 89 /// holds the offset of the corresponding function summary bitcode 90 /// record. After parsing the associated summary information from the summary 91 /// block the \a FunctionSummary is populated and stored here. 92 class FunctionInfo { 93 private: 94 /// Function summary information used to help make ThinLTO importing 95 /// decisions. 96 std::unique_ptr<FunctionSummary> Summary; 97 98 /// \brief The bitcode offset corresponding to either the associated 99 /// function's function body record, or its function summary record, 100 /// depending on whether this is a per-module or combined index. 101 /// 102 /// This bitcode offset is written to or read from the associated 103 /// \a ValueSymbolTable entry for the function. 104 /// For the per-module index this holds the bitcode offset of the 105 /// function's body record within bitcode module block in its module, 106 /// which is used during lazy function parsing or ThinLTO importing. 107 /// For the combined index this holds the offset of the corresponding 108 /// function summary record, to enable associating the combined index 109 /// VST records with the summary records. 110 uint64_t BitcodeIndex; 111 112 public: 113 /// Constructor used during parsing of VST entries. FunctionInfo(uint64_t FuncOffset)114 FunctionInfo(uint64_t FuncOffset) 115 : Summary(nullptr), BitcodeIndex(FuncOffset) {} 116 117 /// Constructor used for per-module index bitcode writing. FunctionInfo(uint64_t FuncOffset,std::unique_ptr<FunctionSummary> FuncSummary)118 FunctionInfo(uint64_t FuncOffset, 119 std::unique_ptr<FunctionSummary> FuncSummary) 120 : Summary(std::move(FuncSummary)), BitcodeIndex(FuncOffset) {} 121 122 /// Record the function summary information parsed out of the function 123 /// summary block during parsing or combined index creation. setFunctionSummary(std::unique_ptr<FunctionSummary> FuncSummary)124 void setFunctionSummary(std::unique_ptr<FunctionSummary> FuncSummary) { 125 Summary = std::move(FuncSummary); 126 } 127 128 /// Get the function summary recorded for this function. functionSummary()129 FunctionSummary *functionSummary() const { return Summary.get(); } 130 131 /// Get the bitcode index recorded for this function, depending on 132 /// the index type. bitcodeIndex()133 uint64_t bitcodeIndex() const { return BitcodeIndex; } 134 135 /// Record the bitcode index for this function, depending on 136 /// the index type. setBitcodeIndex(uint64_t FuncOffset)137 void setBitcodeIndex(uint64_t FuncOffset) { BitcodeIndex = FuncOffset; } 138 }; 139 140 /// List of function info structures for a particular function name held 141 /// in the FunctionMap. Requires a vector in the case of multiple 142 /// COMDAT functions of the same name. 143 typedef std::vector<std::unique_ptr<FunctionInfo>> FunctionInfoList; 144 145 /// Map from function name to corresponding function info structures. 146 typedef StringMap<FunctionInfoList> FunctionInfoMapTy; 147 148 /// Type used for iterating through the function info map. 149 typedef FunctionInfoMapTy::const_iterator const_funcinfo_iterator; 150 typedef FunctionInfoMapTy::iterator funcinfo_iterator; 151 152 /// String table to hold/own module path strings, which additionally holds the 153 /// module ID assigned to each module during the plugin step. The StringMap 154 /// makes a copy of and owns inserted strings. 155 typedef StringMap<uint64_t> ModulePathStringTableTy; 156 157 /// Class to hold module path string table and function map, 158 /// and encapsulate methods for operating on them. 159 class FunctionInfoIndex { 160 private: 161 /// Map from function name to list of function information instances 162 /// for functions of that name (may be duplicates in the COMDAT case, e.g.). 163 FunctionInfoMapTy FunctionMap; 164 165 /// Holds strings for combined index, mapping to the corresponding module ID. 166 ModulePathStringTableTy ModulePathStringTable; 167 168 public: 169 FunctionInfoIndex() = default; 170 171 // Disable the copy constructor and assignment operators, so 172 // no unexpected copying/moving occurs. 173 FunctionInfoIndex(const FunctionInfoIndex &) = delete; 174 void operator=(const FunctionInfoIndex &) = delete; 175 begin()176 funcinfo_iterator begin() { return FunctionMap.begin(); } begin()177 const_funcinfo_iterator begin() const { return FunctionMap.begin(); } end()178 funcinfo_iterator end() { return FunctionMap.end(); } end()179 const_funcinfo_iterator end() const { return FunctionMap.end(); } 180 181 /// Get the list of function info objects for a given function. getFunctionInfoList(StringRef FuncName)182 const FunctionInfoList &getFunctionInfoList(StringRef FuncName) { 183 return FunctionMap[FuncName]; 184 } 185 186 /// Get the list of function info objects for a given function. findFunctionInfoList(StringRef FuncName)187 const const_funcinfo_iterator findFunctionInfoList(StringRef FuncName) const { 188 return FunctionMap.find(FuncName); 189 } 190 191 /// Add a function info for a function of the given name. addFunctionInfo(StringRef FuncName,std::unique_ptr<FunctionInfo> Info)192 void addFunctionInfo(StringRef FuncName, std::unique_ptr<FunctionInfo> Info) { 193 FunctionMap[FuncName].push_back(std::move(Info)); 194 } 195 196 /// Iterator to allow writer to walk through table during emission. 197 iterator_range<StringMap<uint64_t>::const_iterator> modPathStringEntries()198 modPathStringEntries() const { 199 return llvm::make_range(ModulePathStringTable.begin(), 200 ModulePathStringTable.end()); 201 } 202 203 /// Get the module ID recorded for the given module path. getModuleId(const StringRef ModPath)204 uint64_t getModuleId(const StringRef ModPath) const { 205 return ModulePathStringTable.lookup(ModPath); 206 } 207 208 /// Add the given per-module index into this function index/summary, 209 /// assigning it the given module ID. Each module merged in should have 210 /// a unique ID, necessary for consistent renaming of promoted 211 /// static (local) variables. 212 void mergeFrom(std::unique_ptr<FunctionInfoIndex> Other, 213 uint64_t NextModuleId); 214 215 /// Convenience method for creating a promoted global name 216 /// for the given value name of a local, and its original module's ID. getGlobalNameForLocal(StringRef Name,uint64_t ModId)217 static std::string getGlobalNameForLocal(StringRef Name, uint64_t ModId) { 218 SmallString<256> NewName(Name); 219 NewName += ".llvm."; 220 raw_svector_ostream(NewName) << ModId; 221 return NewName.str(); 222 } 223 224 /// Add a new module path, mapped to the given module Id, and return StringRef 225 /// owned by string table map. addModulePath(StringRef ModPath,uint64_t ModId)226 StringRef addModulePath(StringRef ModPath, uint64_t ModId) { 227 return ModulePathStringTable.insert(std::make_pair(ModPath, ModId)) 228 .first->first(); 229 } 230 231 /// Check if the given Module has any functions available for exporting 232 /// in the index. We consider any module present in the ModulePathStringTable 233 /// to have exported functions. hasExportedFunctions(const Module & M)234 bool hasExportedFunctions(const Module &M) const { 235 return ModulePathStringTable.count(M.getModuleIdentifier()); 236 } 237 }; 238 239 } // End llvm namespace 240 241 #endif 242