1 //===-- RuntimeDyldImpl.h - Run-time dynamic linker for MC-JIT --*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Interface for the implementations of runtime dynamic linker facilities.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_RUNTIME_DYLD_IMPL_H
15 #define LLVM_RUNTIME_DYLD_IMPL_H
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/Mutex.h"
29 #include "llvm/Support/SwapByteOrder.h"
30 #include "llvm/Support/raw_ostream.h"
32 #include <system_error>
35 using namespace llvm::object;
42 /// SectionEntry - represents a section emitted into memory by the dynamic
46 /// Name - section name.
49 /// Address - address in the linker's memory where the section resides.
52 /// Size - section size. Doesn't include the stubs.
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.
61 /// StubOffset - used for architectures with stub functions for far
62 /// relocations (like ARM).
65 /// ObjAddress - address of the section in the in-memory object file. Used
66 /// for calculating relocations in some object formats (like MachO).
69 SectionEntry(StringRef name, uint8_t *address, size_t size,
71 : Name(name), Address(address), Size(size),
72 LoadAddress((uintptr_t)address), StubOffset(size),
73 ObjAddress(objAddress) {}
76 /// RelocationEntry - used to represent relocations internally in the dynamic
78 class RelocationEntry {
80 /// SectionID - the section this relocation points to.
83 /// Offset - offset into the section.
86 /// RelType - relocation type.
89 /// Addend - the relocation addend encoded in the instruction itself. Also
90 /// used to make a relocation section relative instead of symbol relative.
98 /// SymOffset - Section offset of the relocation entry's symbol (used for GOT
102 SectionPair Sections;
105 /// True if this is a PCRel relocation (MachO specific).
108 /// The size of this relocation (MachO specific).
111 RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend)
112 : SectionID(id), Offset(offset), RelType(type), Addend(addend),
113 SymOffset(0), IsPCRel(false), Size(0) {}
115 RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend,
117 : SectionID(id), Offset(offset), RelType(type), Addend(addend),
118 SymOffset(symoffset), IsPCRel(false), Size(0) {}
120 RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend,
121 bool IsPCRel, unsigned Size)
122 : SectionID(id), Offset(offset), RelType(type), Addend(addend),
123 SymOffset(0), IsPCRel(IsPCRel), Size(Size) {}
125 RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend,
126 unsigned SectionA, uint64_t SectionAOffset, unsigned SectionB,
127 uint64_t SectionBOffset, bool IsPCRel, unsigned Size)
128 : SectionID(id), Offset(offset), RelType(type),
129 Addend(SectionAOffset - SectionBOffset + addend), IsPCRel(IsPCRel),
131 Sections.SectionA = SectionA;
132 Sections.SectionB = SectionB;
136 class RelocationValueRef {
141 const char *SymbolName;
142 RelocationValueRef() : SectionID(0), Offset(0), Addend(0),
143 SymbolName(nullptr) {}
145 inline bool operator==(const RelocationValueRef &Other) const {
146 return SectionID == Other.SectionID && Offset == Other.Offset &&
147 Addend == Other.Addend && SymbolName == Other.SymbolName;
149 inline bool operator<(const RelocationValueRef &Other) const {
150 if (SectionID != Other.SectionID)
151 return SectionID < Other.SectionID;
152 if (Offset != Other.Offset)
153 return Offset < Other.Offset;
154 if (Addend != Other.Addend)
155 return Addend < Other.Addend;
156 return SymbolName < Other.SymbolName;
160 class RuntimeDyldImpl {
162 // The MemoryManager to load objects into.
163 RTDyldMemoryManager *MemMgr;
165 // A list of all sections emitted by the dynamic linker. These sections are
166 // referenced in the code by means of their index in this list - SectionID.
167 typedef SmallVector<SectionEntry, 64> SectionList;
168 SectionList Sections;
170 typedef unsigned SID; // Type for SectionIDs
171 #define RTDYLD_INVALID_SECTION_ID ((SID)(-1))
173 // Keep a map of sections from object file to the SectionID which
175 typedef std::map<SectionRef, unsigned> ObjSectionToIDMap;
177 // A global symbol table for symbols from all loaded modules. Maps the
178 // symbol name to a (SectionID, offset in section) pair.
179 typedef std::pair<unsigned, uintptr_t> SymbolLoc;
180 typedef StringMap<SymbolLoc> SymbolTableMap;
181 SymbolTableMap GlobalSymbolTable;
183 // Pair representing the size and alignment requirement for a common symbol.
184 typedef std::pair<unsigned, unsigned> CommonSymbolInfo;
185 // Keep a map of common symbols to their info pairs
186 typedef std::map<SymbolRef, CommonSymbolInfo> CommonSymbolMap;
188 // For each symbol, keep a list of relocations based on it. Anytime
189 // its address is reassigned (the JIT re-compiled the function, e.g.),
190 // the relocations get re-resolved.
191 // The symbol (or section) the relocation is sourced from is the Key
192 // in the relocation list where it's stored.
193 typedef SmallVector<RelocationEntry, 64> RelocationList;
194 // Relocations to sections already loaded. Indexed by SectionID which is the
195 // source of the address. The target where the address will be written is
196 // SectionID/Offset in the relocation itself.
197 DenseMap<unsigned, RelocationList> Relocations;
199 // Relocations to external symbols that are not yet resolved. Symbols are
200 // external when they aren't found in the global symbol table of all loaded
201 // modules. This map is indexed by symbol name.
202 StringMap<RelocationList> ExternalSymbolRelocations;
204 typedef std::map<RelocationValueRef, uintptr_t> StubMap;
206 Triple::ArchType Arch;
207 bool IsTargetLittleEndian;
209 // True if all sections should be passed to the memory manager, false if only
210 // sections containing relocations should be. Defaults to 'false'.
211 bool ProcessAllSections;
213 // This mutex prevents simultaneously loading objects from two different
214 // threads. This keeps us from having to protect individual data structures
215 // and guarantees that section allocation requests to the memory manager
216 // won't be interleaved between modules. It is also used in mapSectionAddress
217 // and resolveRelocations to protect write access to internal data structures.
219 // loadObject may be called on the same thread during the handling of of
220 // processRelocations, and that's OK. The handling of the relocation lists
221 // is written in such a way as to work correctly if new elements are added to
222 // the end of the list while the list is being processed.
225 virtual unsigned getMaxStubSize() = 0;
226 virtual unsigned getStubAlignment() = 0;
229 std::string ErrorStr;
231 // Set the error state and record an error string.
232 bool Error(const Twine &Msg) {
233 ErrorStr = Msg.str();
238 uint64_t getSectionLoadAddress(unsigned SectionID) {
239 return Sections[SectionID].LoadAddress;
242 uint8_t *getSectionAddress(unsigned SectionID) {
243 return (uint8_t *)Sections[SectionID].Address;
246 void writeInt16BE(uint8_t *Addr, uint16_t Value) {
247 if (IsTargetLittleEndian)
248 Value = sys::SwapByteOrder(Value);
249 *Addr = (Value >> 8) & 0xFF;
250 *(Addr + 1) = Value & 0xFF;
253 void writeInt32BE(uint8_t *Addr, uint32_t Value) {
254 if (IsTargetLittleEndian)
255 Value = sys::SwapByteOrder(Value);
256 *Addr = (Value >> 24) & 0xFF;
257 *(Addr + 1) = (Value >> 16) & 0xFF;
258 *(Addr + 2) = (Value >> 8) & 0xFF;
259 *(Addr + 3) = Value & 0xFF;
262 void writeInt64BE(uint8_t *Addr, uint64_t Value) {
263 if (IsTargetLittleEndian)
264 Value = sys::SwapByteOrder(Value);
265 *Addr = (Value >> 56) & 0xFF;
266 *(Addr + 1) = (Value >> 48) & 0xFF;
267 *(Addr + 2) = (Value >> 40) & 0xFF;
268 *(Addr + 3) = (Value >> 32) & 0xFF;
269 *(Addr + 4) = (Value >> 24) & 0xFF;
270 *(Addr + 5) = (Value >> 16) & 0xFF;
271 *(Addr + 6) = (Value >> 8) & 0xFF;
272 *(Addr + 7) = Value & 0xFF;
275 /// \brief Given the common symbols discovered in the object file, emit a
276 /// new section for them and update the symbol mappings in the object and
278 void emitCommonSymbols(ObjectImage &Obj, const CommonSymbolMap &CommonSymbols,
279 uint64_t TotalSize, SymbolTableMap &SymbolTable);
281 /// \brief Emits section data from the object file to the MemoryManager.
282 /// \param IsCode if it's true then allocateCodeSection() will be
283 /// used for emits, else allocateDataSection() will be used.
284 /// \return SectionID.
285 unsigned emitSection(ObjectImage &Obj, const SectionRef &Section,
288 /// \brief Find Section in LocalSections. If the secton is not found - emit
289 /// it and store in LocalSections.
290 /// \param IsCode if it's true then allocateCodeSection() will be
291 /// used for emmits, else allocateDataSection() will be used.
292 /// \return SectionID.
293 unsigned findOrEmitSection(ObjectImage &Obj, const SectionRef &Section,
294 bool IsCode, ObjSectionToIDMap &LocalSections);
296 // \brief Add a relocation entry that uses the given section.
297 void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID);
299 // \brief Add a relocation entry that uses the given symbol. This symbol may
300 // be found in the global symbol table, or it may be external.
301 void addRelocationForSymbol(const RelocationEntry &RE, StringRef SymbolName);
303 /// \brief Emits long jump instruction to Addr.
304 /// \return Pointer to the memory area for emitting target address.
305 uint8_t *createStubFunction(uint8_t *Addr);
307 /// \brief Resolves relocations from Relocs list with address from Value.
308 void resolveRelocationList(const RelocationList &Relocs, uint64_t Value);
310 /// \brief A object file specific relocation resolver
311 /// \param RE The relocation to be resolved
312 /// \param Value Target symbol address to apply the relocation action
313 virtual void resolveRelocation(const RelocationEntry &RE, uint64_t Value) = 0;
315 /// \brief Parses one or more object file relocations (some object files use
316 /// relocation pairs) and stores it to Relocations or SymbolRelocations
317 /// (this depends on the object file type).
318 /// \return Iterator to the next relocation that needs to be parsed.
319 virtual relocation_iterator
320 processRelocationRef(unsigned SectionID, relocation_iterator RelI,
321 ObjectImage &Obj, ObjSectionToIDMap &ObjSectionToID,
322 const SymbolTableMap &Symbols, StubMap &Stubs) = 0;
324 /// \brief Resolve relocations to external symbols.
325 void resolveExternalSymbols();
327 /// \brief Update GOT entries for external symbols.
328 // The base class does nothing. ELF overrides this.
329 virtual void updateGOTEntries(StringRef Name, uint64_t Addr) {}
331 // \brief Compute an upper bound of the memory that is required to load all
333 void computeTotalAllocSize(ObjectImage &Obj, uint64_t &CodeSize,
334 uint64_t &DataSizeRO, uint64_t &DataSizeRW);
336 // \brief Compute the stub buffer size required for a section
337 unsigned computeSectionStubBufSize(ObjectImage &Obj,
338 const SectionRef &Section);
341 RuntimeDyldImpl(RTDyldMemoryManager *mm)
342 : MemMgr(mm), ProcessAllSections(false), HasError(false) {}
344 virtual ~RuntimeDyldImpl();
346 void setProcessAllSections(bool ProcessAllSections) {
347 this->ProcessAllSections = ProcessAllSections;
350 ObjectImage *loadObject(ObjectImage *InputObject);
352 void *getSymbolAddress(StringRef Name) {
353 // FIXME: Just look up as a function for now. Overly simple of course.
355 SymbolTableMap::const_iterator pos = GlobalSymbolTable.find(Name);
356 if (pos == GlobalSymbolTable.end())
358 SymbolLoc Loc = pos->second;
359 return getSectionAddress(Loc.first) + Loc.second;
362 uint64_t getSymbolLoadAddress(StringRef Name) {
363 // FIXME: Just look up as a function for now. Overly simple of course.
365 SymbolTableMap::const_iterator pos = GlobalSymbolTable.find(Name);
366 if (pos == GlobalSymbolTable.end())
368 SymbolLoc Loc = pos->second;
369 return getSectionLoadAddress(Loc.first) + Loc.second;
372 void resolveRelocations();
374 void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
376 void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress);
378 // Is the linker in an error state?
379 bool hasError() { return HasError; }
381 // Mark the error condition as handled and continue.
382 void clearError() { HasError = false; }
384 // Get the error message.
385 StringRef getErrorString() { return ErrorStr; }
387 virtual bool isCompatibleFormat(const ObjectBuffer *Buffer) const = 0;
388 virtual bool isCompatibleFile(const ObjectFile *Obj) const = 0;
390 virtual void registerEHFrames();
392 virtual void deregisterEHFrames();
394 virtual void finalizeLoad(ObjectImage &ObjImg, ObjSectionToIDMap &SectionMap) {}
397 } // end namespace llvm