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