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_LIB_EXECUTIONENGINE_RUNTIMEDYLD_RUNTIMEDYLDIMPL_H 15 #define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_RUNTIMEDYLDIMPL_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/RTDyldMemoryManager.h" 22 #include "llvm/ExecutionEngine/RuntimeDyld.h" 23 #include "llvm/ExecutionEngine/RuntimeDyldChecker.h" 24 #include "llvm/Object/ObjectFile.h" 25 #include "llvm/Support/Debug.h" 26 #include "llvm/Support/ErrorHandling.h" 27 #include "llvm/Support/Format.h" 28 #include "llvm/Support/Host.h" 29 #include "llvm/Support/Mutex.h" 30 #include "llvm/Support/SwapByteOrder.h" 31 #include "llvm/Support/raw_ostream.h" 32 #include <map> 33 #include <system_error> 34 35 using namespace llvm; 36 using namespace llvm::object; 37 38 namespace llvm { 39 40 // Helper for extensive error checking in debug builds. 41 inline std::error_code Check(std::error_code Err) { 42 if (Err) { 43 report_fatal_error(Err.message()); 44 } 45 return Err; 46 } 47 48 class Twine; 49 50 /// SectionEntry - represents a section emitted into memory by the dynamic 51 /// linker. 52 class SectionEntry { 53 public: 54 /// Name - section name. 55 std::string Name; 56 57 /// Address - address in the linker's memory where the section resides. 58 uint8_t *Address; 59 60 /// Size - section size. Doesn't include the stubs. 61 size_t Size; 62 63 /// LoadAddress - the address of the section in the target process's memory. 64 /// Used for situations in which JIT-ed code is being executed in the address 65 /// space of a separate process. If the code executes in the same address 66 /// space where it was JIT-ed, this just equals Address. 67 uint64_t LoadAddress; 68 69 /// StubOffset - used for architectures with stub functions for far 70 /// relocations (like ARM). 71 uintptr_t StubOffset; 72 73 /// ObjAddress - address of the section in the in-memory object file. Used 74 /// for calculating relocations in some object formats (like MachO). 75 uintptr_t ObjAddress; 76 77 SectionEntry(StringRef name, uint8_t *address, size_t size, 78 uintptr_t objAddress) 79 : Name(name), Address(address), Size(size), 80 LoadAddress(reinterpret_cast<uintptr_t>(address)), StubOffset(size), 81 ObjAddress(objAddress) {} 82 }; 83 84 /// RelocationEntry - used to represent relocations internally in the dynamic 85 /// linker. 86 class RelocationEntry { 87 public: 88 /// SectionID - the section this relocation points to. 89 unsigned SectionID; 90 91 /// Offset - offset into the section. 92 uint64_t Offset; 93 94 /// RelType - relocation type. 95 uint32_t RelType; 96 97 /// Addend - the relocation addend encoded in the instruction itself. Also 98 /// used to make a relocation section relative instead of symbol relative. 99 int64_t Addend; 100 101 struct SectionPair { 102 uint32_t SectionA; 103 uint32_t SectionB; 104 }; 105 106 /// SymOffset - Section offset of the relocation entry's symbol (used for GOT 107 /// lookup). 108 union { 109 uint64_t SymOffset; 110 SectionPair Sections; 111 }; 112 113 /// True if this is a PCRel relocation (MachO specific). 114 bool IsPCRel; 115 116 /// The size of this relocation (MachO specific). 117 unsigned Size; 118 119 RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend) 120 : SectionID(id), Offset(offset), RelType(type), Addend(addend), 121 SymOffset(0), IsPCRel(false), Size(0) {} 122 123 RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend, 124 uint64_t symoffset) 125 : SectionID(id), Offset(offset), RelType(type), Addend(addend), 126 SymOffset(symoffset), IsPCRel(false), Size(0) {} 127 128 RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend, 129 bool IsPCRel, unsigned Size) 130 : SectionID(id), Offset(offset), RelType(type), Addend(addend), 131 SymOffset(0), IsPCRel(IsPCRel), Size(Size) {} 132 133 RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend, 134 unsigned SectionA, uint64_t SectionAOffset, unsigned SectionB, 135 uint64_t SectionBOffset, bool IsPCRel, unsigned Size) 136 : SectionID(id), Offset(offset), RelType(type), 137 Addend(SectionAOffset - SectionBOffset + addend), IsPCRel(IsPCRel), 138 Size(Size) { 139 Sections.SectionA = SectionA; 140 Sections.SectionB = SectionB; 141 } 142 }; 143 144 class RelocationValueRef { 145 public: 146 unsigned SectionID; 147 uint64_t Offset; 148 int64_t Addend; 149 const char *SymbolName; 150 RelocationValueRef() : SectionID(0), Offset(0), Addend(0), 151 SymbolName(nullptr) {} 152 153 inline bool operator==(const RelocationValueRef &Other) const { 154 return SectionID == Other.SectionID && Offset == Other.Offset && 155 Addend == Other.Addend && SymbolName == Other.SymbolName; 156 } 157 inline bool operator<(const RelocationValueRef &Other) const { 158 if (SectionID != Other.SectionID) 159 return SectionID < Other.SectionID; 160 if (Offset != Other.Offset) 161 return Offset < Other.Offset; 162 if (Addend != Other.Addend) 163 return Addend < Other.Addend; 164 return SymbolName < Other.SymbolName; 165 } 166 }; 167 168 /// @brief Symbol info for RuntimeDyld. 169 class SymbolTableEntry : public JITSymbolBase { 170 public: 171 SymbolTableEntry() 172 : JITSymbolBase(JITSymbolFlags::None), Offset(0), SectionID(0) {} 173 174 SymbolTableEntry(unsigned SectionID, uint64_t Offset, JITSymbolFlags Flags) 175 : JITSymbolBase(Flags), Offset(Offset), SectionID(SectionID) {} 176 177 unsigned getSectionID() const { return SectionID; } 178 uint64_t getOffset() const { return Offset; } 179 180 private: 181 uint64_t Offset; 182 unsigned SectionID; 183 }; 184 185 typedef StringMap<SymbolTableEntry> RTDyldSymbolTable; 186 187 class RuntimeDyldImpl { 188 friend class RuntimeDyld::LoadedObjectInfo; 189 friend class RuntimeDyldCheckerImpl; 190 protected: 191 // The MemoryManager to load objects into. 192 RuntimeDyld::MemoryManager &MemMgr; 193 194 // The symbol resolver to use for external symbols. 195 RuntimeDyld::SymbolResolver &Resolver; 196 197 // Attached RuntimeDyldChecker instance. Null if no instance attached. 198 RuntimeDyldCheckerImpl *Checker; 199 200 // A list of all sections emitted by the dynamic linker. These sections are 201 // referenced in the code by means of their index in this list - SectionID. 202 typedef SmallVector<SectionEntry, 64> SectionList; 203 SectionList Sections; 204 205 typedef unsigned SID; // Type for SectionIDs 206 #define RTDYLD_INVALID_SECTION_ID ((SID)(-1)) 207 208 // Keep a map of sections from object file to the SectionID which 209 // references it. 210 typedef std::map<SectionRef, unsigned> ObjSectionToIDMap; 211 212 // A global symbol table for symbols from all loaded modules. 213 RTDyldSymbolTable GlobalSymbolTable; 214 215 // Keep a map of common symbols to their info pairs 216 typedef std::vector<SymbolRef> CommonSymbolList; 217 218 // For each symbol, keep a list of relocations based on it. Anytime 219 // its address is reassigned (the JIT re-compiled the function, e.g.), 220 // the relocations get re-resolved. 221 // The symbol (or section) the relocation is sourced from is the Key 222 // in the relocation list where it's stored. 223 typedef SmallVector<RelocationEntry, 64> RelocationList; 224 // Relocations to sections already loaded. Indexed by SectionID which is the 225 // source of the address. The target where the address will be written is 226 // SectionID/Offset in the relocation itself. 227 DenseMap<unsigned, RelocationList> Relocations; 228 229 // Relocations to external symbols that are not yet resolved. Symbols are 230 // external when they aren't found in the global symbol table of all loaded 231 // modules. This map is indexed by symbol name. 232 StringMap<RelocationList> ExternalSymbolRelocations; 233 234 235 typedef std::map<RelocationValueRef, uintptr_t> StubMap; 236 237 Triple::ArchType Arch; 238 bool IsTargetLittleEndian; 239 240 // True if all sections should be passed to the memory manager, false if only 241 // sections containing relocations should be. Defaults to 'false'. 242 bool ProcessAllSections; 243 244 // This mutex prevents simultaneously loading objects from two different 245 // threads. This keeps us from having to protect individual data structures 246 // and guarantees that section allocation requests to the memory manager 247 // won't be interleaved between modules. It is also used in mapSectionAddress 248 // and resolveRelocations to protect write access to internal data structures. 249 // 250 // loadObject may be called on the same thread during the handling of of 251 // processRelocations, and that's OK. The handling of the relocation lists 252 // is written in such a way as to work correctly if new elements are added to 253 // the end of the list while the list is being processed. 254 sys::Mutex lock; 255 256 virtual unsigned getMaxStubSize() = 0; 257 virtual unsigned getStubAlignment() = 0; 258 259 bool HasError; 260 std::string ErrorStr; 261 262 // Set the error state and record an error string. 263 bool Error(const Twine &Msg) { 264 ErrorStr = Msg.str(); 265 HasError = true; 266 return true; 267 } 268 269 uint64_t getSectionLoadAddress(unsigned SectionID) const { 270 return Sections[SectionID].LoadAddress; 271 } 272 273 uint8_t *getSectionAddress(unsigned SectionID) const { 274 return (uint8_t *)Sections[SectionID].Address; 275 } 276 277 void writeInt16BE(uint8_t *Addr, uint16_t Value) { 278 if (IsTargetLittleEndian) 279 sys::swapByteOrder(Value); 280 *Addr = (Value >> 8) & 0xFF; 281 *(Addr + 1) = Value & 0xFF; 282 } 283 284 void writeInt32BE(uint8_t *Addr, uint32_t Value) { 285 if (IsTargetLittleEndian) 286 sys::swapByteOrder(Value); 287 *Addr = (Value >> 24) & 0xFF; 288 *(Addr + 1) = (Value >> 16) & 0xFF; 289 *(Addr + 2) = (Value >> 8) & 0xFF; 290 *(Addr + 3) = Value & 0xFF; 291 } 292 293 void writeInt64BE(uint8_t *Addr, uint64_t Value) { 294 if (IsTargetLittleEndian) 295 sys::swapByteOrder(Value); 296 *Addr = (Value >> 56) & 0xFF; 297 *(Addr + 1) = (Value >> 48) & 0xFF; 298 *(Addr + 2) = (Value >> 40) & 0xFF; 299 *(Addr + 3) = (Value >> 32) & 0xFF; 300 *(Addr + 4) = (Value >> 24) & 0xFF; 301 *(Addr + 5) = (Value >> 16) & 0xFF; 302 *(Addr + 6) = (Value >> 8) & 0xFF; 303 *(Addr + 7) = Value & 0xFF; 304 } 305 306 /// Endian-aware read Read the least significant Size bytes from Src. 307 uint64_t readBytesUnaligned(uint8_t *Src, unsigned Size) const; 308 309 /// Endian-aware write. Write the least significant Size bytes from Value to 310 /// Dst. 311 void writeBytesUnaligned(uint64_t Value, uint8_t *Dst, unsigned Size) const; 312 313 /// \brief Given the common symbols discovered in the object file, emit a 314 /// new section for them and update the symbol mappings in the object and 315 /// symbol table. 316 void emitCommonSymbols(const ObjectFile &Obj, CommonSymbolList &CommonSymbols); 317 318 /// \brief Emits section data from the object file to the MemoryManager. 319 /// \param IsCode if it's true then allocateCodeSection() will be 320 /// used for emits, else allocateDataSection() will be used. 321 /// \return SectionID. 322 unsigned emitSection(const ObjectFile &Obj, const SectionRef &Section, 323 bool IsCode); 324 325 /// \brief Find Section in LocalSections. If the secton is not found - emit 326 /// it and store in LocalSections. 327 /// \param IsCode if it's true then allocateCodeSection() will be 328 /// used for emmits, else allocateDataSection() will be used. 329 /// \return SectionID. 330 unsigned findOrEmitSection(const ObjectFile &Obj, const SectionRef &Section, 331 bool IsCode, ObjSectionToIDMap &LocalSections); 332 333 // \brief Add a relocation entry that uses the given section. 334 void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID); 335 336 // \brief Add a relocation entry that uses the given symbol. This symbol may 337 // be found in the global symbol table, or it may be external. 338 void addRelocationForSymbol(const RelocationEntry &RE, StringRef SymbolName); 339 340 /// \brief Emits long jump instruction to Addr. 341 /// \return Pointer to the memory area for emitting target address. 342 uint8_t *createStubFunction(uint8_t *Addr, unsigned AbiVariant = 0); 343 344 /// \brief Resolves relocations from Relocs list with address from Value. 345 void resolveRelocationList(const RelocationList &Relocs, uint64_t Value); 346 347 /// \brief A object file specific relocation resolver 348 /// \param RE The relocation to be resolved 349 /// \param Value Target symbol address to apply the relocation action 350 virtual void resolveRelocation(const RelocationEntry &RE, uint64_t Value) = 0; 351 352 /// \brief Parses one or more object file relocations (some object files use 353 /// relocation pairs) and stores it to Relocations or SymbolRelocations 354 /// (this depends on the object file type). 355 /// \return Iterator to the next relocation that needs to be parsed. 356 virtual relocation_iterator 357 processRelocationRef(unsigned SectionID, relocation_iterator RelI, 358 const ObjectFile &Obj, ObjSectionToIDMap &ObjSectionToID, 359 StubMap &Stubs) = 0; 360 361 /// \brief Resolve relocations to external symbols. 362 void resolveExternalSymbols(); 363 364 // \brief Compute an upper bound of the memory that is required to load all 365 // sections 366 void computeTotalAllocSize(const ObjectFile &Obj, uint64_t &CodeSize, 367 uint64_t &DataSizeRO, uint64_t &DataSizeRW); 368 369 // \brief Compute the stub buffer size required for a section 370 unsigned computeSectionStubBufSize(const ObjectFile &Obj, 371 const SectionRef &Section); 372 373 // \brief Implementation of the generic part of the loadObject algorithm. 374 std::pair<unsigned, unsigned> loadObjectImpl(const object::ObjectFile &Obj); 375 376 public: 377 RuntimeDyldImpl(RuntimeDyld::MemoryManager &MemMgr, 378 RuntimeDyld::SymbolResolver &Resolver) 379 : MemMgr(MemMgr), Resolver(Resolver), Checker(nullptr), 380 ProcessAllSections(false), HasError(false) { 381 } 382 383 virtual ~RuntimeDyldImpl(); 384 385 void setProcessAllSections(bool ProcessAllSections) { 386 this->ProcessAllSections = ProcessAllSections; 387 } 388 389 void setRuntimeDyldChecker(RuntimeDyldCheckerImpl *Checker) { 390 this->Checker = Checker; 391 } 392 393 virtual std::unique_ptr<RuntimeDyld::LoadedObjectInfo> 394 loadObject(const object::ObjectFile &Obj) = 0; 395 396 uint8_t* getSymbolLocalAddress(StringRef Name) const { 397 // FIXME: Just look up as a function for now. Overly simple of course. 398 // Work in progress. 399 RTDyldSymbolTable::const_iterator pos = GlobalSymbolTable.find(Name); 400 if (pos == GlobalSymbolTable.end()) 401 return nullptr; 402 const auto &SymInfo = pos->second; 403 return getSectionAddress(SymInfo.getSectionID()) + SymInfo.getOffset(); 404 } 405 406 RuntimeDyld::SymbolInfo getSymbol(StringRef Name) const { 407 // FIXME: Just look up as a function for now. Overly simple of course. 408 // Work in progress. 409 RTDyldSymbolTable::const_iterator pos = GlobalSymbolTable.find(Name); 410 if (pos == GlobalSymbolTable.end()) 411 return nullptr; 412 const auto &SymEntry = pos->second; 413 uint64_t TargetAddr = 414 getSectionLoadAddress(SymEntry.getSectionID()) + SymEntry.getOffset(); 415 return RuntimeDyld::SymbolInfo(TargetAddr, SymEntry.getFlags()); 416 } 417 418 void resolveRelocations(); 419 420 void reassignSectionAddress(unsigned SectionID, uint64_t Addr); 421 422 void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress); 423 424 // Is the linker in an error state? 425 bool hasError() { return HasError; } 426 427 // Mark the error condition as handled and continue. 428 void clearError() { HasError = false; } 429 430 // Get the error message. 431 StringRef getErrorString() { return ErrorStr; } 432 433 virtual bool isCompatibleFile(const ObjectFile &Obj) const = 0; 434 435 virtual void registerEHFrames(); 436 437 virtual void deregisterEHFrames(); 438 439 virtual void finalizeLoad(const ObjectFile &ObjImg, 440 ObjSectionToIDMap &SectionMap) {} 441 }; 442 443 } // end namespace llvm 444 445 #endif 446
