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 "ObjectImage.h"
18 #include "llvm/ExecutionEngine/RuntimeDyld.h"
19 #include "llvm/ADT/DenseMap.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/StringMap.h"
22 #include "llvm/ADT/Triple.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/raw_ostream.h"
28 #include "llvm/Support/system_error.h"
32 using namespace llvm::object;
40 /// SectionEntry - represents a section emitted into memory by the dynamic
44 /// Address - address in the linker's memory where the section resides.
47 /// Size - section size.
50 /// LoadAddress - the address of the section in the target process's memory.
51 /// Used for situations in which JIT-ed code is being executed in the address
52 /// space of a separate process. If the code executes in the same address
53 /// space where it was JIT-ed, this just equals Address.
56 /// StubOffset - used for architectures with stub functions for far
57 /// relocations (like ARM).
60 /// ObjAddress - address of the section in the in-memory object file. Used
61 /// for calculating relocations in some object formats (like MachO).
64 SectionEntry(uint8_t *address, size_t size, uintptr_t stubOffset,
66 : Address(address), Size(size), LoadAddress((uintptr_t)address),
67 StubOffset(stubOffset), ObjAddress(objAddress) {}
70 /// RelocationEntry - used to represent relocations internally in the dynamic
72 class RelocationEntry {
74 /// SectionID - the section this relocation points to.
77 /// Offset - offset into the section.
80 /// RelType - relocation type.
83 /// Addend - the relocation addend encoded in the instruction itself. Also
84 /// used to make a relocation section relative instead of symbol relative.
87 RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend)
88 : SectionID(id), Offset(offset), RelType(type), Addend(addend) {}
91 /// ObjRelocationInfo - relocation information as read from the object file.
92 /// Used to pass around data taken from object::RelocationRef, together with
93 /// the section to which the relocation points (represented by a SectionID).
94 class ObjRelocationInfo {
100 int64_t AdditionalInfo;
103 class RelocationValueRef {
107 const char *SymbolName;
108 RelocationValueRef(): SectionID(0), Addend(0), SymbolName(0) {}
110 inline bool operator==(const RelocationValueRef &Other) const {
111 return std::memcmp(this, &Other, sizeof(RelocationValueRef)) == 0;
113 inline bool operator <(const RelocationValueRef &Other) const {
114 return std::memcmp(this, &Other, sizeof(RelocationValueRef)) < 0;
118 class RuntimeDyldImpl {
120 // The MemoryManager to load objects into.
121 RTDyldMemoryManager *MemMgr;
123 // A list of all sections emitted by the dynamic linker. These sections are
124 // referenced in the code by means of their index in this list - SectionID.
125 typedef SmallVector<SectionEntry, 64> SectionList;
126 SectionList Sections;
128 // Keep a map of sections from object file to the SectionID which
130 typedef std::map<SectionRef, unsigned> ObjSectionToIDMap;
132 // A global symbol table for symbols from all loaded modules. Maps the
133 // symbol name to a (SectionID, offset in section) pair.
134 typedef std::pair<unsigned, uintptr_t> SymbolLoc;
135 typedef StringMap<SymbolLoc> SymbolTableMap;
136 SymbolTableMap GlobalSymbolTable;
138 // Keep a map of common symbols to their sizes
139 typedef std::map<SymbolRef, unsigned> CommonSymbolMap;
141 // For each symbol, keep a list of relocations based on it. Anytime
142 // its address is reassigned (the JIT re-compiled the function, e.g.),
143 // the relocations get re-resolved.
144 // The symbol (or section) the relocation is sourced from is the Key
145 // in the relocation list where it's stored.
146 typedef SmallVector<RelocationEntry, 64> RelocationList;
147 // Relocations to sections already loaded. Indexed by SectionID which is the
148 // source of the address. The target where the address will be writen is
149 // SectionID/Offset in the relocation itself.
150 DenseMap<unsigned, RelocationList> Relocations;
152 // Relocations to external symbols that are not yet resolved. Symbols are
153 // external when they aren't found in the global symbol table of all loaded
154 // modules. This map is indexed by symbol name.
155 StringMap<RelocationList> ExternalSymbolRelocations;
157 typedef std::map<RelocationValueRef, uintptr_t> StubMap;
159 Triple::ArchType Arch;
161 inline unsigned getMaxStubSize() {
162 if (Arch == Triple::arm || Arch == Triple::thumb)
163 return 8; // 32-bit instruction and 32-bit address
169 std::string ErrorStr;
171 // Set the error state and record an error string.
172 bool Error(const Twine &Msg) {
173 ErrorStr = Msg.str();
178 uint8_t *getSectionAddress(unsigned SectionID) {
179 return (uint8_t*)Sections[SectionID].Address;
182 /// \brief Emits a section containing common symbols.
183 /// \return SectionID.
184 unsigned emitCommonSymbols(ObjectImage &Obj,
185 const CommonSymbolMap &Map,
187 SymbolTableMap &Symbols);
189 /// \brief Emits section data from the object file to the MemoryManager.
190 /// \param IsCode if it's true then allocateCodeSection() will be
191 /// used for emits, else allocateDataSection() will be used.
192 /// \return SectionID.
193 unsigned emitSection(ObjectImage &Obj,
194 const SectionRef &Section,
197 /// \brief Find Section in LocalSections. If the secton is not found - emit
198 /// it and store in LocalSections.
199 /// \param IsCode if it's true then allocateCodeSection() will be
200 /// used for emmits, else allocateDataSection() will be used.
201 /// \return SectionID.
202 unsigned findOrEmitSection(ObjectImage &Obj,
203 const SectionRef &Section,
205 ObjSectionToIDMap &LocalSections);
207 /// \brief If Value.SymbolName is NULL then store relocation to the
208 /// Relocations, else store it in the SymbolRelocations.
209 void addRelocation(const RelocationValueRef &Value, unsigned SectionID,
210 uintptr_t Offset, uint32_t RelType);
212 /// \brief Emits long jump instruction to Addr.
213 /// \return Pointer to the memory area for emitting target address.
214 uint8_t* createStubFunction(uint8_t *Addr);
216 /// \brief Resolves relocations from Relocs list with address from Value.
217 void resolveRelocationList(const RelocationList &Relocs, uint64_t Value);
218 void resolveRelocationEntry(const RelocationEntry &RE, uint64_t Value);
220 /// \brief A object file specific relocation resolver
221 /// \param Address Address to apply the relocation action
222 /// \param Value Target symbol address to apply the relocation action
223 /// \param Type object file specific relocation type
224 /// \param Addend A constant addend used to compute the value to be stored
225 /// into the relocatable field
226 virtual void resolveRelocation(uint8_t *LocalAddress,
227 uint64_t FinalAddress,
232 /// \brief Parses the object file relocation and stores it to Relocations
233 /// or SymbolRelocations (this depends on the object file type).
234 virtual void processRelocationRef(const ObjRelocationInfo &Rel,
236 ObjSectionToIDMap &ObjSectionToID,
237 const SymbolTableMap &Symbols,
240 /// \brief Resolve relocations to external symbols.
241 void resolveExternalSymbols();
242 virtual ObjectImage *createObjectImage(const MemoryBuffer *InputBuffer);
243 virtual void handleObjectLoaded(ObjectImage *Obj)
245 // Subclasses may choose to retain this image if they have a use for it
250 RuntimeDyldImpl(RTDyldMemoryManager *mm) : MemMgr(mm), HasError(false) {}
252 virtual ~RuntimeDyldImpl();
254 bool loadObject(const MemoryBuffer *InputBuffer);
256 void *getSymbolAddress(StringRef Name) {
257 // FIXME: Just look up as a function for now. Overly simple of course.
259 if (GlobalSymbolTable.find(Name) == GlobalSymbolTable.end())
261 SymbolLoc Loc = GlobalSymbolTable.lookup(Name);
262 return getSectionAddress(Loc.first) + Loc.second;
265 void resolveRelocations();
267 void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
269 void mapSectionAddress(void *LocalAddress, uint64_t TargetAddress);
271 // Is the linker in an error state?
272 bool hasError() { return HasError; }
274 // Mark the error condition as handled and continue.
275 void clearError() { HasError = false; }
277 // Get the error message.
278 StringRef getErrorString() { return ErrorStr; }
280 virtual bool isCompatibleFormat(const MemoryBuffer *InputBuffer) const = 0;
284 } // end namespace llvm