RuntimeDyldImpl.h revision ade047463fd6e0fbb447145eb06015b8e7836482 
1//===-- RuntimeDyldImpl.h - Run-time dynamic linker for MC-JIT --*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// Interface for the implementations of runtime dynamic linker facilities.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_RUNTIME_DYLD_IMPL_H
15#define LLVM_RUNTIME_DYLD_IMPL_H
16
17#include "llvm/ExecutionEngine/RuntimeDyld.h"
18#include "llvm/ExecutionEngine/ObjectImage.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/Host.h"
28#include "llvm/Support/SwapByteOrder.h"
29#include "llvm/Support/raw_ostream.h"
30#include "llvm/Support/system_error.h"
31#include <map>
32
33using namespace llvm;
34using namespace llvm::object;
35
36namespace llvm {
37
38class ObjectBuffer;
39class Twine;
40
41
42/// SectionEntry - represents a section emitted into memory by the dynamic
43/// linker.
44class SectionEntry {
45public:
46  /// Name - section name.
47  StringRef Name;
48
49  /// Address - address in the linker's memory where the section resides.
50  uint8_t *Address;
51
52  /// Size - section size.
53  size_t Size;
54
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.
59  uint64_t LoadAddress;
60
61  /// StubOffset - used for architectures with stub functions for far
62  /// relocations (like ARM).
63  uintptr_t StubOffset;
64
65  /// ObjAddress - address of the section in the in-memory object file.  Used
66  /// for calculating relocations in some object formats (like MachO).
67  uintptr_t ObjAddress;
68
69  SectionEntry(StringRef name, uint8_t *address, size_t size,
70	       uintptr_t stubOffset, uintptr_t objAddress)
71    : Name(name), Address(address), Size(size), LoadAddress((uintptr_t)address),
72      StubOffset(stubOffset), ObjAddress(objAddress) {}
73};
74
75/// RelocationEntry - used to represent relocations internally in the dynamic
76/// linker.
77class RelocationEntry {
78public:
79  /// SectionID - the section this relocation points to.
80  unsigned SectionID;
81
82  /// Offset - offset into the section.
83  uintptr_t Offset;
84
85  /// RelType - relocation type.
86  uint32_t RelType;
87
88  /// Addend - the relocation addend encoded in the instruction itself.  Also
89  /// used to make a relocation section relative instead of symbol relative.
90  intptr_t Addend;
91
92  RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend)
93    : SectionID(id), Offset(offset), RelType(type), Addend(addend) {}
94};
95
96/// ObjRelocationInfo - relocation information as read from the object file.
97/// Used to pass around data taken from object::RelocationRef, together with
98/// the section to which the relocation points (represented by a SectionID).
99class ObjRelocationInfo {
100public:
101  unsigned  SectionID;
102  uint64_t  Offset;
103  SymbolRef Symbol;
104  uint64_t  Type;
105  int64_t   AdditionalInfo;
106};
107
108class RelocationValueRef {
109public:
110  unsigned  SectionID;
111  intptr_t  Addend;
112  const char *SymbolName;
113  RelocationValueRef(): SectionID(0), Addend(0), SymbolName(0) {}
114
115  inline bool operator==(const RelocationValueRef &Other) const {
116    return std::memcmp(this, &Other, sizeof(RelocationValueRef)) == 0;
117  }
118  inline bool operator <(const RelocationValueRef &Other) const {
119    return std::memcmp(this, &Other, sizeof(RelocationValueRef)) < 0;
120  }
121};
122
123class RuntimeDyldImpl {
124protected:
125  // The MemoryManager to load objects into.
126  RTDyldMemoryManager *MemMgr;
127
128  // A list of all sections emitted by the dynamic linker.  These sections are
129  // referenced in the code by means of their index in this list - SectionID.
130  typedef SmallVector<SectionEntry, 64> SectionList;
131  SectionList Sections;
132
133  // Keep a map of sections from object file to the SectionID which
134  // references it.
135  typedef std::map<SectionRef, unsigned> ObjSectionToIDMap;
136
137  // A global symbol table for symbols from all loaded modules.  Maps the
138  // symbol name to a (SectionID, offset in section) pair.
139  typedef std::pair<unsigned, uintptr_t> SymbolLoc;
140  typedef StringMap<SymbolLoc> SymbolTableMap;
141  SymbolTableMap GlobalSymbolTable;
142
143  // Pair representing the size and alignment requirement for a common symbol.
144  typedef std::pair<unsigned, unsigned> CommonSymbolInfo;
145  // Keep a map of common symbols to their info pairs
146  typedef std::map<SymbolRef, CommonSymbolInfo> CommonSymbolMap;
147
148  // For each symbol, keep a list of relocations based on it. Anytime
149  // its address is reassigned (the JIT re-compiled the function, e.g.),
150  // the relocations get re-resolved.
151  // The symbol (or section) the relocation is sourced from is the Key
152  // in the relocation list where it's stored.
153  typedef SmallVector<RelocationEntry, 64> RelocationList;
154  // Relocations to sections already loaded. Indexed by SectionID which is the
155  // source of the address. The target where the address will be written is
156  // SectionID/Offset in the relocation itself.
157  DenseMap<unsigned, RelocationList> Relocations;
158
159  // Relocations to external symbols that are not yet resolved.  Symbols are
160  // external when they aren't found in the global symbol table of all loaded
161  // modules.  This map is indexed by symbol name.
162  StringMap<RelocationList> ExternalSymbolRelocations;
163
164  typedef std::map<RelocationValueRef, uintptr_t> StubMap;
165
166  Triple::ArchType Arch;
167
168  inline unsigned getMaxStubSize() {
169    if (Arch == Triple::arm || Arch == Triple::thumb)
170      return 8; // 32-bit instruction and 32-bit address
171    else if (Arch == Triple::mipsel or Arch == Triple::mips)
172      return 16;
173    else if (Arch == Triple::ppc64)
174      return 44;
175    else
176      return 0;
177  }
178
179  bool HasError;
180  std::string ErrorStr;
181
182  // Set the error state and record an error string.
183  bool Error(const Twine &Msg) {
184    ErrorStr = Msg.str();
185    HasError = true;
186    return true;
187  }
188
189  uint64_t getSectionLoadAddress(unsigned SectionID) {
190    return Sections[SectionID].LoadAddress;
191  }
192
193  uint8_t *getSectionAddress(unsigned SectionID) {
194    return (uint8_t*)Sections[SectionID].Address;
195  }
196
197  // Subclasses can override this method to get the alignment requirement of
198  // a common symbol. Returns no alignment requirement if not implemented.
199  virtual unsigned getCommonSymbolAlignment(const SymbolRef &Sym) {
200    return 0;
201  }
202
203
204  void writeInt16BE(uint8_t *Addr, uint16_t Value) {
205    if (sys::isLittleEndianHost())
206      Value = sys::SwapByteOrder(Value);
207    *Addr     = (Value >> 8) & 0xFF;
208    *(Addr+1) = Value & 0xFF;
209  }
210
211  void writeInt32BE(uint8_t *Addr, uint32_t Value) {
212    if (sys::isLittleEndianHost())
213      Value = sys::SwapByteOrder(Value);
214    *Addr     = (Value >> 24) & 0xFF;
215    *(Addr+1) = (Value >> 16) & 0xFF;
216    *(Addr+2) = (Value >> 8) & 0xFF;
217    *(Addr+3) = Value & 0xFF;
218  }
219
220  void writeInt64BE(uint8_t *Addr, uint64_t Value) {
221    if (sys::isLittleEndianHost())
222      Value = sys::SwapByteOrder(Value);
223    *Addr     = (Value >> 56) & 0xFF;
224    *(Addr+1) = (Value >> 48) & 0xFF;
225    *(Addr+2) = (Value >> 40) & 0xFF;
226    *(Addr+3) = (Value >> 32) & 0xFF;
227    *(Addr+4) = (Value >> 24) & 0xFF;
228    *(Addr+5) = (Value >> 16) & 0xFF;
229    *(Addr+6) = (Value >> 8) & 0xFF;
230    *(Addr+7) = Value & 0xFF;
231  }
232
233  /// \brief Given the common symbols discovered in the object file, emit a
234  /// new section for them and update the symbol mappings in the object and
235  /// symbol table.
236  void emitCommonSymbols(ObjectImage &Obj,
237                         const CommonSymbolMap &CommonSymbols,
238                         uint64_t TotalSize,
239                         SymbolTableMap &SymbolTable);
240
241  /// \brief Emits section data from the object file to the MemoryManager.
242  /// \param IsCode if it's true then allocateCodeSection() will be
243  ///        used for emits, else allocateDataSection() will be used.
244  /// \return SectionID.
245  unsigned emitSection(ObjectImage &Obj,
246                       const SectionRef &Section,
247                       bool IsCode);
248
249  /// \brief Find Section in LocalSections. If the secton is not found - emit
250  ///        it and store in LocalSections.
251  /// \param IsCode if it's true then allocateCodeSection() will be
252  ///        used for emmits, else allocateDataSection() will be used.
253  /// \return SectionID.
254  unsigned findOrEmitSection(ObjectImage &Obj,
255                             const SectionRef &Section,
256                             bool IsCode,
257                             ObjSectionToIDMap &LocalSections);
258
259  // \brief Add a relocation entry that uses the given section.
260  void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID);
261
262  // \brief Add a relocation entry that uses the given symbol.  This symbol may
263  // be found in the global symbol table, or it may be external.
264  void addRelocationForSymbol(const RelocationEntry &RE, StringRef SymbolName);
265
266  /// \brief Emits long jump instruction to Addr.
267  /// \return Pointer to the memory area for emitting target address.
268  uint8_t* createStubFunction(uint8_t *Addr);
269
270  /// \brief Resolves relocations from Relocs list with address from Value.
271  void resolveRelocationList(const RelocationList &Relocs, uint64_t Value);
272  void resolveRelocationEntry(const RelocationEntry &RE, uint64_t Value);
273
274  /// \brief A object file specific relocation resolver
275  /// \param Section The section where the relocation is being applied
276  /// \param Offset The offset into the section for this relocation
277  /// \param Value Target symbol address to apply the relocation action
278  /// \param Type object file specific relocation type
279  /// \param Addend A constant addend used to compute the value to be stored
280  ///        into the relocatable field
281  virtual void resolveRelocation(const SectionEntry &Section,
282                                 uint64_t Offset,
283                                 uint64_t Value,
284                                 uint32_t Type,
285                                 int64_t Addend) = 0;
286
287  /// \brief Parses the object file relocation and stores it to Relocations
288  ///        or SymbolRelocations (this depends on the object file type).
289  virtual void processRelocationRef(const ObjRelocationInfo &Rel,
290                                    ObjectImage &Obj,
291                                    ObjSectionToIDMap &ObjSectionToID,
292                                    const SymbolTableMap &Symbols,
293                                    StubMap &Stubs) = 0;
294
295  /// \brief Resolve relocations to external symbols.
296  void resolveExternalSymbols();
297  virtual ObjectImage *createObjectImage(ObjectBuffer *InputBuffer);
298public:
299  RuntimeDyldImpl(RTDyldMemoryManager *mm) : MemMgr(mm), HasError(false) {}
300
301  virtual ~RuntimeDyldImpl();
302
303  ObjectImage *loadObject(ObjectBuffer *InputBuffer);
304
305  void *getSymbolAddress(StringRef Name) {
306    // FIXME: Just look up as a function for now. Overly simple of course.
307    // Work in progress.
308    if (GlobalSymbolTable.find(Name) == GlobalSymbolTable.end())
309      return 0;
310    SymbolLoc Loc = GlobalSymbolTable.lookup(Name);
311    return getSectionAddress(Loc.first) + Loc.second;
312  }
313
314  uint64_t getSymbolLoadAddress(StringRef Name) {
315    // FIXME: Just look up as a function for now. Overly simple of course.
316    // Work in progress.
317    if (GlobalSymbolTable.find(Name) == GlobalSymbolTable.end())
318      return 0;
319    SymbolLoc Loc = GlobalSymbolTable.lookup(Name);
320    return getSectionLoadAddress(Loc.first) + Loc.second;
321  }
322
323  void resolveRelocations();
324
325  void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
326
327  void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress);
328
329  // Is the linker in an error state?
330  bool hasError() { return HasError; }
331
332  // Mark the error condition as handled and continue.
333  void clearError() { HasError = false; }
334
335  // Get the error message.
336  StringRef getErrorString() { return ErrorStr; }
337
338  virtual bool isCompatibleFormat(const ObjectBuffer *Buffer) const = 0;
339};
340
341} // end namespace llvm
342
343
344#endif
345