1 //===-LTOModule.h - LLVM Link Time Optimizer ------------------------------===// 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 declares the LTOModule class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_LTO_LTOMODULE_H 14 #define LLVM_LTO_LTOMODULE_H 15 16 #include "llvm-c/lto.h" 17 #include "llvm/ADT/StringMap.h" 18 #include "llvm/ADT/StringSet.h" 19 #include "llvm/IR/Module.h" 20 #include "llvm/LTO/LTO.h" 21 #include "llvm/Object/IRObjectFile.h" 22 #include "llvm/Object/ModuleSymbolTable.h" 23 #include "llvm/Target/TargetMachine.h" 24 #include <string> 25 #include <vector> 26 27 // Forward references to llvm classes. 28 namespace llvm { 29 class Function; 30 class GlobalValue; 31 class MemoryBuffer; 32 class TargetOptions; 33 class Value; 34 35 //===----------------------------------------------------------------------===// 36 /// C++ class which implements the opaque lto_module_t type. 37 /// 38 struct LTOModule { 39 private: 40 struct NameAndAttributes { 41 StringRef name; 42 uint32_t attributes = 0; 43 bool isFunction = 0; 44 const GlobalValue *symbol = 0; 45 }; 46 47 std::unique_ptr<LLVMContext> OwnedContext; 48 49 std::string LinkerOpts; 50 51 std::string DependentLibraries; 52 53 std::unique_ptr<Module> Mod; 54 MemoryBufferRef MBRef; 55 ModuleSymbolTable SymTab; 56 std::unique_ptr<TargetMachine> _target; 57 std::vector<NameAndAttributes> _symbols; 58 59 // _defines and _undefines only needed to disambiguate tentative definitions 60 StringSet<> _defines; 61 StringMap<NameAndAttributes> _undefines; 62 std::vector<StringRef> _asm_undefines; 63 64 LTOModule(std::unique_ptr<Module> M, MemoryBufferRef MBRef, 65 TargetMachine *TM); 66 67 public: 68 ~LTOModule(); 69 70 /// Returns 'true' if the file or memory contents is LLVM bitcode. 71 static bool isBitcodeFile(const void *mem, size_t length); 72 static bool isBitcodeFile(StringRef path); 73 74 /// Returns 'true' if the Module is produced for ThinLTO. 75 bool isThinLTO(); 76 77 /// Returns 'true' if the memory buffer is LLVM bitcode for the specified 78 /// triple. 79 static bool isBitcodeForTarget(MemoryBuffer *memBuffer, 80 StringRef triplePrefix); 81 82 /// Returns a string representing the producer identification stored in the 83 /// bitcode, or "" if the bitcode does not contains any. 84 /// 85 static std::string getProducerString(MemoryBuffer *Buffer); 86 87 /// Create a MemoryBuffer from a memory range with an optional name. 88 static std::unique_ptr<MemoryBuffer> 89 makeBuffer(const void *mem, size_t length, StringRef name = ""); 90 91 /// Create an LTOModule. N.B. These methods take ownership of the buffer. The 92 /// caller must have initialized the Targets, the TargetMCs, the AsmPrinters, 93 /// and the AsmParsers by calling: 94 /// 95 /// InitializeAllTargets(); 96 /// InitializeAllTargetMCs(); 97 /// InitializeAllAsmPrinters(); 98 /// InitializeAllAsmParsers(); 99 static ErrorOr<std::unique_ptr<LTOModule>> 100 createFromFile(LLVMContext &Context, StringRef path, 101 const TargetOptions &options); 102 static ErrorOr<std::unique_ptr<LTOModule>> 103 createFromOpenFile(LLVMContext &Context, int fd, StringRef path, size_t size, 104 const TargetOptions &options); 105 static ErrorOr<std::unique_ptr<LTOModule>> 106 createFromOpenFileSlice(LLVMContext &Context, int fd, StringRef path, 107 size_t map_size, off_t offset, 108 const TargetOptions &options); 109 static ErrorOr<std::unique_ptr<LTOModule>> 110 createFromBuffer(LLVMContext &Context, const void *mem, size_t length, 111 const TargetOptions &options, StringRef path = ""); 112 static ErrorOr<std::unique_ptr<LTOModule>> 113 createInLocalContext(std::unique_ptr<LLVMContext> Context, const void *mem, 114 size_t length, const TargetOptions &options, 115 StringRef path); 116 getModuleLTOModule117 const Module &getModule() const { return *Mod; } getModuleLTOModule118 Module &getModule() { return *Mod; } 119 takeModuleLTOModule120 std::unique_ptr<Module> takeModule() { return std::move(Mod); } 121 122 /// Return the Module's target triple. getTargetTripleLTOModule123 const std::string &getTargetTriple() { 124 return getModule().getTargetTriple(); 125 } 126 127 /// Set the Module's target triple. setTargetTripleLTOModule128 void setTargetTriple(StringRef Triple) { 129 getModule().setTargetTriple(Triple); 130 } 131 132 /// Get the number of symbols getSymbolCountLTOModule133 uint32_t getSymbolCount() { 134 return _symbols.size(); 135 } 136 137 /// Get the attributes for a symbol at the specified index. getSymbolAttributesLTOModule138 lto_symbol_attributes getSymbolAttributes(uint32_t index) { 139 if (index < _symbols.size()) 140 return lto_symbol_attributes(_symbols[index].attributes); 141 return lto_symbol_attributes(0); 142 } 143 144 /// Get the name of the symbol at the specified index. getSymbolNameLTOModule145 StringRef getSymbolName(uint32_t index) { 146 if (index < _symbols.size()) 147 return _symbols[index].name; 148 return StringRef(); 149 } 150 getSymbolGVLTOModule151 const GlobalValue *getSymbolGV(uint32_t index) { 152 if (index < _symbols.size()) 153 return _symbols[index].symbol; 154 return nullptr; 155 } 156 getLinkerOptsLTOModule157 StringRef getLinkerOpts() { return LinkerOpts; } 158 getAsmUndefinedRefsLTOModule159 const std::vector<StringRef> &getAsmUndefinedRefs() { return _asm_undefines; } 160 161 static lto::InputFile *createInputFile(const void *buffer, size_t buffer_size, 162 const char *path, std::string &out_error); 163 164 static size_t getDependentLibraryCount(lto::InputFile *input); 165 166 static const char *getDependentLibrary(lto::InputFile *input, size_t index, size_t *size); 167 168 private: 169 /// Parse metadata from the module 170 // FIXME: it only parses "llvm.linker.options" metadata at the moment 171 // FIXME: can't access metadata in lazily loaded modules 172 void parseMetadata(); 173 174 /// Parse the symbols from the module and model-level ASM and add them to 175 /// either the defined or undefined lists. 176 void parseSymbols(); 177 178 /// Add a symbol which isn't defined just yet to a list to be resolved later. 179 void addPotentialUndefinedSymbol(ModuleSymbolTable::Symbol Sym, 180 bool isFunc); 181 182 /// Add a defined symbol to the list. 183 void addDefinedSymbol(StringRef Name, const GlobalValue *def, 184 bool isFunction); 185 186 /// Add a data symbol as defined to the list. 187 void addDefinedDataSymbol(ModuleSymbolTable::Symbol Sym); 188 void addDefinedDataSymbol(StringRef Name, const GlobalValue *v); 189 190 /// Add a function symbol as defined to the list. 191 void addDefinedFunctionSymbol(ModuleSymbolTable::Symbol Sym); 192 void addDefinedFunctionSymbol(StringRef Name, const Function *F); 193 194 /// Add a global symbol from module-level ASM to the defined list. 195 void addAsmGlobalSymbol(StringRef, lto_symbol_attributes scope); 196 197 /// Add a global symbol from module-level ASM to the undefined list. 198 void addAsmGlobalSymbolUndef(StringRef); 199 200 /// Parse i386/ppc ObjC class data structure. 201 void addObjCClass(const GlobalVariable *clgv); 202 203 /// Parse i386/ppc ObjC category data structure. 204 void addObjCCategory(const GlobalVariable *clgv); 205 206 /// Parse i386/ppc ObjC class list data structure. 207 void addObjCClassRef(const GlobalVariable *clgv); 208 209 /// Get string that the data pointer points to. 210 bool objcClassNameFromExpression(const Constant *c, std::string &name); 211 212 /// Create an LTOModule (private version). 213 static ErrorOr<std::unique_ptr<LTOModule>> 214 makeLTOModule(MemoryBufferRef Buffer, const TargetOptions &options, 215 LLVMContext &Context, bool ShouldBeLazy); 216 }; 217 } 218 #endif 219