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 // Master symbol table. As modules are loaded and external symbols are
133 // resolved, their addresses are stored here as a SectionID/Offset pair.
134 typedef std::pair<unsigned, uintptr_t> SymbolLoc;
135 StringMap<SymbolLoc> SymbolTable;
136 typedef DenseMap<const char*, SymbolLoc> LocalSymbolMap;
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;
151 // Relocations to external symbols that are not yet resolved.
152 // Indexed by symbol name.
153 StringMap<RelocationList> SymbolRelocations;
155 typedef std::map<RelocationValueRef, uintptr_t> StubMap;
157 Triple::ArchType Arch;
159 inline unsigned getMaxStubSize() {
160 if (Arch == Triple::arm || Arch == Triple::thumb)
161 return 8; // 32-bit instruction and 32-bit address
167 std::string ErrorStr;
169 // Set the error state and record an error string.
170 bool Error(const Twine &Msg) {
171 ErrorStr = Msg.str();
176 uint8_t *getSectionAddress(unsigned SectionID) {
177 return (uint8_t*)Sections[SectionID].Address;
180 /// \brief Emits a section containing common symbols.
181 /// \return SectionID.
182 unsigned emitCommonSymbols(ObjectImage &Obj,
183 const CommonSymbolMap &Map,
185 LocalSymbolMap &Symbols);
187 /// \brief Emits section data from the object file to the MemoryManager.
188 /// \param IsCode if it's true then allocateCodeSection() will be
189 /// used for emits, else allocateDataSection() will be used.
190 /// \return SectionID.
191 unsigned emitSection(ObjectImage &Obj,
192 const SectionRef &Section,
195 /// \brief Find Section in LocalSections. If the secton is not found - emit
196 /// it and store in LocalSections.
197 /// \param IsCode if it's true then allocateCodeSection() will be
198 /// used for emmits, else allocateDataSection() will be used.
199 /// \return SectionID.
200 unsigned findOrEmitSection(ObjectImage &Obj,
201 const SectionRef &Section,
203 ObjSectionToIDMap &LocalSections);
205 /// \brief If Value.SymbolName is NULL then store relocation to the
206 /// Relocations, else store it in the SymbolRelocations.
207 void addRelocation(const RelocationValueRef &Value, unsigned SectionID,
208 uintptr_t Offset, uint32_t RelType);
210 /// \brief Emits long jump instruction to Addr.
211 /// \return Pointer to the memory area for emitting target address.
212 uint8_t* createStubFunction(uint8_t *Addr);
214 /// \brief Resolves relocations from Relocs list with address from Value.
215 void resolveRelocationList(const RelocationList &Relocs, uint64_t Value);
216 void resolveRelocationEntry(const RelocationEntry &RE, uint64_t Value);
218 /// \brief A object file specific relocation resolver
219 /// \param Address Address to apply the relocation action
220 /// \param Value Target symbol address to apply the relocation action
221 /// \param Type object file specific relocation type
222 /// \param Addend A constant addend used to compute the value to be stored
223 /// into the relocatable field
224 virtual void resolveRelocation(uint8_t *LocalAddress,
225 uint64_t FinalAddress,
230 /// \brief Parses the object file relocation and stores it to Relocations
231 /// or SymbolRelocations (this depends on the object file type).
232 virtual void processRelocationRef(const ObjRelocationInfo &Rel,
234 ObjSectionToIDMap &ObjSectionToID,
235 LocalSymbolMap &Symbols,
238 void resolveSymbols();
239 virtual ObjectImage *createObjectImage(const MemoryBuffer *InputBuffer);
240 virtual void handleObjectLoaded(ObjectImage *Obj)
242 // Subclasses may choose to retain this image if they have a use for it
247 RuntimeDyldImpl(RTDyldMemoryManager *mm) : MemMgr(mm), HasError(false) {}
249 virtual ~RuntimeDyldImpl();
251 bool loadObject(const MemoryBuffer *InputBuffer);
253 void *getSymbolAddress(StringRef Name) {
254 // FIXME: Just look up as a function for now. Overly simple of course.
256 if (SymbolTable.find(Name) == SymbolTable.end())
258 SymbolLoc Loc = SymbolTable.lookup(Name);
259 return getSectionAddress(Loc.first) + Loc.second;
262 void resolveRelocations();
264 void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
266 void mapSectionAddress(void *LocalAddress, uint64_t TargetAddress);
268 // Is the linker in an error state?
269 bool hasError() { return HasError; }
271 // Mark the error condition as handled and continue.
272 void clearError() { HasError = false; }
274 // Get the error message.
275 StringRef getErrorString() { return ErrorStr; }
277 virtual bool isCompatibleFormat(const MemoryBuffer *InputBuffer) const = 0;
281 } // end namespace llvm