1 //===-- RuntimeDyldImpl.h - Run-time dynamic linker for MC-JIT --*- 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 // Interface for the implementations of runtime dynamic linker facilities. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_RUNTIME_DYLD_IMPL_H 15 #define LLVM_RUNTIME_DYLD_IMPL_H 16 17 #include "llvm/ADT/DenseMap.h" 18 #include "llvm/ADT/SmallVector.h" 19 #include "llvm/ADT/StringMap.h" 20 #include "llvm/ADT/Triple.h" 21 #include "llvm/ExecutionEngine/ObjectImage.h" 22 #include "llvm/ExecutionEngine/RuntimeDyld.h" 23 #include "llvm/Object/ObjectFile.h" 24 #include "llvm/Support/Debug.h" 25 #include "llvm/Support/ErrorHandling.h" 26 #include "llvm/Support/Format.h" 27 #include "llvm/Support/Host.h" 28 #include "llvm/Support/SwapByteOrder.h" 29 #include "llvm/Support/raw_ostream.h" 30 #include "llvm/Support/system_error.h" 31 #include <map> 32 33 using namespace llvm; 34 using namespace llvm::object; 35 36 namespace llvm { 37 38 class ObjectBuffer; 39 class Twine; 40 41 42 /// SectionEntry - represents a section emitted into memory by the dynamic 43 /// linker. 44 class SectionEntry { 45 public: 46 /// Name - section name. 47 StringRef Name; 48 49 /// Address - address in the linker's memory where the section resides. 50 uint8_t *Address; 51 52 /// Size - section size. Doesn't include the stubs. 53 size_t Size; 54 55 /// LoadAddress - the address of the section in the target process's memory. 56 /// Used for situations in which JIT-ed code is being executed in the address 57 /// space of a separate process. If the code executes in the same address 58 /// space where it was JIT-ed, this just equals Address. 59 uint64_t LoadAddress; 60 61 /// StubOffset - used for architectures with stub functions for far 62 /// relocations (like ARM). 63 uintptr_t StubOffset; 64 65 /// ObjAddress - address of the section in the in-memory object file. Used 66 /// for calculating relocations in some object formats (like MachO). 67 uintptr_t ObjAddress; 68 69 SectionEntry(StringRef name, uint8_t *address, size_t size, 70 uintptr_t objAddress) 71 : Name(name), Address(address), Size(size), LoadAddress((uintptr_t)address), 72 StubOffset(size), ObjAddress(objAddress) {} 73 }; 74 75 /// RelocationEntry - used to represent relocations internally in the dynamic 76 /// linker. 77 class RelocationEntry { 78 public: 79 /// SectionID - the section this relocation points to. 80 unsigned SectionID; 81 82 /// Offset - offset into the section. 83 uintptr_t Offset; 84 85 /// RelType - relocation type. 86 uint32_t RelType; 87 88 /// Addend - the relocation addend encoded in the instruction itself. Also 89 /// used to make a relocation section relative instead of symbol relative. 90 intptr_t Addend; 91 92 /// True if this is a PCRel relocation (MachO specific). 93 bool IsPCRel; 94 95 /// The size of this relocation (MachO specific). 96 unsigned Size; 97 98 RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend) 99 : SectionID(id), Offset(offset), RelType(type), Addend(addend), 100 IsPCRel(false), Size(0) {} 101 102 RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend, 103 bool IsPCRel, unsigned Size) 104 : SectionID(id), Offset(offset), RelType(type), Addend(addend), 105 IsPCRel(IsPCRel), Size(Size) {} 106 }; 107 108 class RelocationValueRef { 109 public: 110 unsigned SectionID; 111 intptr_t Addend; 112 const char *SymbolName; 113 RelocationValueRef(): SectionID(0), Addend(0), SymbolName(0) {} 114 115 inline bool operator==(const RelocationValueRef &Other) const { 116 return std::memcmp(this, &Other, sizeof(RelocationValueRef)) == 0; 117 } 118 inline bool operator <(const RelocationValueRef &Other) const { 119 return std::memcmp(this, &Other, sizeof(RelocationValueRef)) < 0; 120 } 121 }; 122 123 class RuntimeDyldImpl { 124 protected: 125 // The MemoryManager to load objects into. 126 RTDyldMemoryManager *MemMgr; 127 128 // A list of all sections emitted by the dynamic linker. These sections are 129 // referenced in the code by means of their index in this list - SectionID. 130 typedef SmallVector<SectionEntry, 64> SectionList; 131 SectionList Sections; 132 133 // Keep a map of sections from object file to the SectionID which 134 // references it. 135 typedef std::map<SectionRef, unsigned> ObjSectionToIDMap; 136 137 // A global symbol table for symbols from all loaded modules. Maps the 138 // symbol name to a (SectionID, offset in section) pair. 139 typedef std::pair<unsigned, uintptr_t> SymbolLoc; 140 typedef StringMap<SymbolLoc> SymbolTableMap; 141 SymbolTableMap GlobalSymbolTable; 142 143 // Pair representing the size and alignment requirement for a common symbol. 144 typedef std::pair<unsigned, unsigned> CommonSymbolInfo; 145 // Keep a map of common symbols to their info pairs 146 typedef std::map<SymbolRef, CommonSymbolInfo> CommonSymbolMap; 147 148 // For each symbol, keep a list of relocations based on it. Anytime 149 // its address is reassigned (the JIT re-compiled the function, e.g.), 150 // the relocations get re-resolved. 151 // The symbol (or section) the relocation is sourced from is the Key 152 // in the relocation list where it's stored. 153 typedef SmallVector<RelocationEntry, 64> RelocationList; 154 // Relocations to sections already loaded. Indexed by SectionID which is the 155 // source of the address. The target where the address will be written is 156 // SectionID/Offset in the relocation itself. 157 DenseMap<unsigned, RelocationList> Relocations; 158 159 // Relocations to external symbols that are not yet resolved. Symbols are 160 // external when they aren't found in the global symbol table of all loaded 161 // modules. This map is indexed by symbol name. 162 StringMap<RelocationList> ExternalSymbolRelocations; 163 164 typedef std::map<RelocationValueRef, uintptr_t> StubMap; 165 166 Triple::ArchType Arch; 167 168 inline unsigned getMaxStubSize() { 169 if (Arch == Triple::aarch64) 170 return 20; // movz; movk; movk; movk; br 171 if (Arch == Triple::arm || Arch == Triple::thumb) 172 return 8; // 32-bit instruction and 32-bit address 173 else if (Arch == Triple::mipsel || Arch == Triple::mips) 174 return 16; 175 else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) 176 return 44; 177 else if (Arch == Triple::x86_64) 178 return 8; // GOT 179 else if (Arch == Triple::systemz) 180 return 16; 181 else 182 return 0; 183 } 184 185 inline unsigned getStubAlignment() { 186 if (Arch == Triple::systemz) 187 return 8; 188 else 189 return 1; 190 } 191 192 bool HasError; 193 std::string ErrorStr; 194 195 // Set the error state and record an error string. 196 bool Error(const Twine &Msg) { 197 ErrorStr = Msg.str(); 198 HasError = true; 199 return true; 200 } 201 202 uint64_t getSectionLoadAddress(unsigned SectionID) { 203 return Sections[SectionID].LoadAddress; 204 } 205 206 uint8_t *getSectionAddress(unsigned SectionID) { 207 return (uint8_t*)Sections[SectionID].Address; 208 } 209 210 void writeInt16BE(uint8_t *Addr, uint16_t Value) { 211 if (sys::IsLittleEndianHost) 212 Value = sys::SwapByteOrder(Value); 213 *Addr = (Value >> 8) & 0xFF; 214 *(Addr+1) = Value & 0xFF; 215 } 216 217 void writeInt32BE(uint8_t *Addr, uint32_t Value) { 218 if (sys::IsLittleEndianHost) 219 Value = sys::SwapByteOrder(Value); 220 *Addr = (Value >> 24) & 0xFF; 221 *(Addr+1) = (Value >> 16) & 0xFF; 222 *(Addr+2) = (Value >> 8) & 0xFF; 223 *(Addr+3) = Value & 0xFF; 224 } 225 226 void writeInt64BE(uint8_t *Addr, uint64_t Value) { 227 if (sys::IsLittleEndianHost) 228 Value = sys::SwapByteOrder(Value); 229 *Addr = (Value >> 56) & 0xFF; 230 *(Addr+1) = (Value >> 48) & 0xFF; 231 *(Addr+2) = (Value >> 40) & 0xFF; 232 *(Addr+3) = (Value >> 32) & 0xFF; 233 *(Addr+4) = (Value >> 24) & 0xFF; 234 *(Addr+5) = (Value >> 16) & 0xFF; 235 *(Addr+6) = (Value >> 8) & 0xFF; 236 *(Addr+7) = Value & 0xFF; 237 } 238 239 /// \brief Given the common symbols discovered in the object file, emit a 240 /// new section for them and update the symbol mappings in the object and 241 /// symbol table. 242 void emitCommonSymbols(ObjectImage &Obj, 243 const CommonSymbolMap &CommonSymbols, 244 uint64_t TotalSize, 245 SymbolTableMap &SymbolTable); 246 247 /// \brief Emits section data from the object file to the MemoryManager. 248 /// \param IsCode if it's true then allocateCodeSection() will be 249 /// used for emits, else allocateDataSection() will be used. 250 /// \return SectionID. 251 unsigned emitSection(ObjectImage &Obj, 252 const SectionRef &Section, 253 bool IsCode); 254 255 /// \brief Find Section in LocalSections. If the secton is not found - emit 256 /// it and store in LocalSections. 257 /// \param IsCode if it's true then allocateCodeSection() will be 258 /// used for emmits, else allocateDataSection() will be used. 259 /// \return SectionID. 260 unsigned findOrEmitSection(ObjectImage &Obj, 261 const SectionRef &Section, 262 bool IsCode, 263 ObjSectionToIDMap &LocalSections); 264 265 // \brief Add a relocation entry that uses the given section. 266 void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID); 267 268 // \brief Add a relocation entry that uses the given symbol. This symbol may 269 // be found in the global symbol table, or it may be external. 270 void addRelocationForSymbol(const RelocationEntry &RE, StringRef SymbolName); 271 272 /// \brief Emits long jump instruction to Addr. 273 /// \return Pointer to the memory area for emitting target address. 274 uint8_t* createStubFunction(uint8_t *Addr); 275 276 /// \brief Resolves relocations from Relocs list with address from Value. 277 void resolveRelocationList(const RelocationList &Relocs, uint64_t Value); 278 279 /// \brief A object file specific relocation resolver 280 /// \param RE The relocation to be resolved 281 /// \param Value Target symbol address to apply the relocation action 282 virtual void resolveRelocation(const RelocationEntry &RE, uint64_t Value) = 0; 283 284 /// \brief Parses the object file relocation and stores it to Relocations 285 /// or SymbolRelocations (this depends on the object file type). 286 virtual void processRelocationRef(unsigned SectionID, 287 RelocationRef RelI, 288 ObjectImage &Obj, 289 ObjSectionToIDMap &ObjSectionToID, 290 const SymbolTableMap &Symbols, 291 StubMap &Stubs) = 0; 292 293 /// \brief Resolve relocations to external symbols. 294 void resolveExternalSymbols(); 295 virtual ObjectImage *createObjectImage(ObjectBuffer *InputBuffer); 296 public: 297 RuntimeDyldImpl(RTDyldMemoryManager *mm) : MemMgr(mm), HasError(false) {} 298 299 virtual ~RuntimeDyldImpl(); 300 301 ObjectImage *loadObject(ObjectBuffer *InputBuffer); 302 303 void *getSymbolAddress(StringRef Name) { 304 // FIXME: Just look up as a function for now. Overly simple of course. 305 // Work in progress. 306 if (GlobalSymbolTable.find(Name) == GlobalSymbolTable.end()) 307 return 0; 308 SymbolLoc Loc = GlobalSymbolTable.lookup(Name); 309 return getSectionAddress(Loc.first) + Loc.second; 310 } 311 312 uint64_t getSymbolLoadAddress(StringRef Name) { 313 // FIXME: Just look up as a function for now. Overly simple of course. 314 // Work in progress. 315 if (GlobalSymbolTable.find(Name) == GlobalSymbolTable.end()) 316 return 0; 317 SymbolLoc Loc = GlobalSymbolTable.lookup(Name); 318 return getSectionLoadAddress(Loc.first) + Loc.second; 319 } 320 321 void resolveRelocations(); 322 323 void reassignSectionAddress(unsigned SectionID, uint64_t Addr); 324 325 void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress); 326 327 // Is the linker in an error state? 328 bool hasError() { return HasError; } 329 330 // Mark the error condition as handled and continue. 331 void clearError() { HasError = false; } 332 333 // Get the error message. 334 StringRef getErrorString() { return ErrorStr; } 335 336 virtual bool isCompatibleFormat(const ObjectBuffer *Buffer) const = 0; 337 338 virtual StringRef getEHFrameSection(); 339 }; 340 341 } // end namespace llvm 342 343 344 #endif 345
