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 written 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
164 else if (Arch == Triple::mipsel)
171 std::string ErrorStr;
173 // Set the error state and record an error string.
174 bool Error(const Twine &Msg) {
175 ErrorStr = Msg.str();
180 uint64_t getSectionLoadAddress(unsigned SectionID) {
181 return Sections[SectionID].LoadAddress;
184 uint8_t *getSectionAddress(unsigned SectionID) {
185 return (uint8_t*)Sections[SectionID].Address;
188 /// \brief Given the common symbols discovered in the object file, emit a
189 /// new section for them and update the symbol mappings in the object and
191 void emitCommonSymbols(ObjectImage &Obj,
192 const CommonSymbolMap &CommonSymbols,
194 SymbolTableMap &SymbolTable);
196 /// \brief Emits section data from the object file to the MemoryManager.
197 /// \param IsCode if it's true then allocateCodeSection() will be
198 /// used for emits, else allocateDataSection() will be used.
199 /// \return SectionID.
200 unsigned emitSection(ObjectImage &Obj,
201 const SectionRef &Section,
204 /// \brief Find Section in LocalSections. If the secton is not found - emit
205 /// it and store in LocalSections.
206 /// \param IsCode if it's true then allocateCodeSection() will be
207 /// used for emmits, else allocateDataSection() will be used.
208 /// \return SectionID.
209 unsigned findOrEmitSection(ObjectImage &Obj,
210 const SectionRef &Section,
212 ObjSectionToIDMap &LocalSections);
214 // \brief Add a relocation entry that uses the given section.
215 void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID);
217 // \brief Add a relocation entry that uses the given symbol. This symbol may
218 // be found in the global symbol table, or it may be external.
219 void addRelocationForSymbol(const RelocationEntry &RE, StringRef SymbolName);
221 /// \brief Emits long jump instruction to Addr.
222 /// \return Pointer to the memory area for emitting target address.
223 uint8_t* createStubFunction(uint8_t *Addr);
225 /// \brief Resolves relocations from Relocs list with address from Value.
226 void resolveRelocationList(const RelocationList &Relocs, uint64_t Value);
227 void resolveRelocationEntry(const RelocationEntry &RE, uint64_t Value);
229 /// \brief A object file specific relocation resolver
230 /// \param LocalAddress The address to apply the relocation action
231 /// \param FinalAddress If the linker prepare code for remote executon then
232 /// FinalAddress has the remote address to apply the
233 /// relocation action, otherwise is same as LocalAddress
234 /// \param Value Target symbol address to apply the relocation action
235 /// \param Type object file specific relocation type
236 /// \param Addend A constant addend used to compute the value to be stored
237 /// into the relocatable field
238 virtual void resolveRelocation(uint8_t *LocalAddress,
239 uint64_t FinalAddress,
244 /// \brief Parses the object file relocation and stores it to Relocations
245 /// or SymbolRelocations (this depends on the object file type).
246 virtual void processRelocationRef(const ObjRelocationInfo &Rel,
248 ObjSectionToIDMap &ObjSectionToID,
249 const SymbolTableMap &Symbols,
252 /// \brief Resolve relocations to external symbols.
253 void resolveExternalSymbols();
254 virtual ObjectImage *createObjectImage(const MemoryBuffer *InputBuffer);
255 virtual void handleObjectLoaded(ObjectImage *Obj)
257 // Subclasses may choose to retain this image if they have a use for it
262 RuntimeDyldImpl(RTDyldMemoryManager *mm) : MemMgr(mm), HasError(false) {}
264 virtual ~RuntimeDyldImpl();
266 bool loadObject(const MemoryBuffer *InputBuffer);
268 void *getSymbolAddress(StringRef Name) {
269 // FIXME: Just look up as a function for now. Overly simple of course.
271 if (GlobalSymbolTable.find(Name) == GlobalSymbolTable.end())
273 SymbolLoc Loc = GlobalSymbolTable.lookup(Name);
274 return getSectionAddress(Loc.first) + Loc.second;
277 uint64_t getSymbolLoadAddress(StringRef Name) {
278 // FIXME: Just look up as a function for now. Overly simple of course.
280 if (GlobalSymbolTable.find(Name) == GlobalSymbolTable.end())
282 SymbolLoc Loc = GlobalSymbolTable.lookup(Name);
283 return getSectionLoadAddress(Loc.first) + Loc.second;
286 void resolveRelocations();
288 void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
290 void mapSectionAddress(void *LocalAddress, uint64_t TargetAddress);
292 // Is the linker in an error state?
293 bool hasError() { return HasError; }
295 // Mark the error condition as handled and continue.
296 void clearError() { HasError = false; }
298 // Get the error message.
299 StringRef getErrorString() { return ErrorStr; }
301 virtual bool isCompatibleFormat(const MemoryBuffer *InputBuffer) const = 0;
305 } // end namespace llvm