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/ADT/DenseMap.h"
18#include "llvm/ADT/SmallVector.h"
19#include "llvm/ADT/StringMap.h"
20#include "llvm/ADT/Triple.h"
21#include "llvm/ExecutionEngine/ObjectImage.h"
22#include "llvm/ExecutionEngine/RuntimeDyld.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. Doesn't include the stubs.
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 objAddress)
71    : Name(name), Address(address), Size(size), LoadAddress((uintptr_t)address),
72      StubOffset(size), 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  /// True if this is a PCRel relocation (MachO specific).
93  bool IsPCRel;
94
95  /// The size of this relocation (MachO specific).
96  unsigned Size;
97
98  RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend)
99    : SectionID(id), Offset(offset), RelType(type), Addend(addend),
100      IsPCRel(false), Size(0) {}
101
102  RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend,
103                  bool IsPCRel, unsigned Size)
104    : SectionID(id), Offset(offset), RelType(type), Addend(addend),
105      IsPCRel(IsPCRel), Size(Size) {}
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::aarch64)
170      return 20; // movz; movk; movk; movk; br
171    if (Arch == Triple::arm || Arch == Triple::thumb)
172      return 8; // 32-bit instruction and 32-bit address
173    else if (Arch == Triple::mipsel || Arch == Triple::mips)
174      return 16;
175    else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le)
176      return 44;
177    else if (Arch == Triple::x86_64)
178      return 8; // GOT
179    else if (Arch == Triple::systemz)
180      return 16;
181    else
182      return 0;
183  }
184
185  inline unsigned getStubAlignment() {
186    if (Arch == Triple::systemz)
187      return 8;
188    else
189      return 1;
190  }
191
192  bool HasError;
193  std::string ErrorStr;
194
195  // Set the error state and record an error string.
196  bool Error(const Twine &Msg) {
197    ErrorStr = Msg.str();
198    HasError = true;
199    return true;
200  }
201
202  uint64_t getSectionLoadAddress(unsigned SectionID) {
203    return Sections[SectionID].LoadAddress;
204  }
205
206  uint8_t *getSectionAddress(unsigned SectionID) {
207    return (uint8_t*)Sections[SectionID].Address;
208  }
209
210  void writeInt16BE(uint8_t *Addr, uint16_t Value) {
211    if (sys::IsLittleEndianHost)
212      Value = sys::SwapByteOrder(Value);
213    *Addr     = (Value >> 8) & 0xFF;
214    *(Addr+1) = Value & 0xFF;
215  }
216
217  void writeInt32BE(uint8_t *Addr, uint32_t Value) {
218    if (sys::IsLittleEndianHost)
219      Value = sys::SwapByteOrder(Value);
220    *Addr     = (Value >> 24) & 0xFF;
221    *(Addr+1) = (Value >> 16) & 0xFF;
222    *(Addr+2) = (Value >> 8) & 0xFF;
223    *(Addr+3) = Value & 0xFF;
224  }
225
226  void writeInt64BE(uint8_t *Addr, uint64_t Value) {
227    if (sys::IsLittleEndianHost)
228      Value = sys::SwapByteOrder(Value);
229    *Addr     = (Value >> 56) & 0xFF;
230    *(Addr+1) = (Value >> 48) & 0xFF;
231    *(Addr+2) = (Value >> 40) & 0xFF;
232    *(Addr+3) = (Value >> 32) & 0xFF;
233    *(Addr+4) = (Value >> 24) & 0xFF;
234    *(Addr+5) = (Value >> 16) & 0xFF;
235    *(Addr+6) = (Value >> 8) & 0xFF;
236    *(Addr+7) = Value & 0xFF;
237  }
238
239  /// \brief Given the common symbols discovered in the object file, emit a
240  /// new section for them and update the symbol mappings in the object and
241  /// symbol table.
242  void emitCommonSymbols(ObjectImage &Obj,
243                         const CommonSymbolMap &CommonSymbols,
244                         uint64_t TotalSize,
245                         SymbolTableMap &SymbolTable);
246
247  /// \brief Emits section data from the object file to the MemoryManager.
248  /// \param IsCode if it's true then allocateCodeSection() will be
249  ///        used for emits, else allocateDataSection() will be used.
250  /// \return SectionID.
251  unsigned emitSection(ObjectImage &Obj,
252                       const SectionRef &Section,
253                       bool IsCode);
254
255  /// \brief Find Section in LocalSections. If the secton is not found - emit
256  ///        it and store in LocalSections.
257  /// \param IsCode if it's true then allocateCodeSection() will be
258  ///        used for emmits, else allocateDataSection() will be used.
259  /// \return SectionID.
260  unsigned findOrEmitSection(ObjectImage &Obj,
261                             const SectionRef &Section,
262                             bool IsCode,
263                             ObjSectionToIDMap &LocalSections);
264
265  // \brief Add a relocation entry that uses the given section.
266  void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID);
267
268  // \brief Add a relocation entry that uses the given symbol.  This symbol may
269  // be found in the global symbol table, or it may be external.
270  void addRelocationForSymbol(const RelocationEntry &RE, StringRef SymbolName);
271
272  /// \brief Emits long jump instruction to Addr.
273  /// \return Pointer to the memory area for emitting target address.
274  uint8_t* createStubFunction(uint8_t *Addr);
275
276  /// \brief Resolves relocations from Relocs list with address from Value.
277  void resolveRelocationList(const RelocationList &Relocs, uint64_t Value);
278
279  /// \brief A object file specific relocation resolver
280  /// \param RE The relocation to be resolved
281  /// \param Value Target symbol address to apply the relocation action
282  virtual void resolveRelocation(const RelocationEntry &RE, uint64_t Value) = 0;
283
284  /// \brief Parses the object file relocation and stores it to Relocations
285  ///        or SymbolRelocations (this depends on the object file type).
286  virtual void processRelocationRef(unsigned SectionID,
287                                    RelocationRef RelI,
288                                    ObjectImage &Obj,
289                                    ObjSectionToIDMap &ObjSectionToID,
290                                    const SymbolTableMap &Symbols,
291                                    StubMap &Stubs) = 0;
292
293  /// \brief Resolve relocations to external symbols.
294  void resolveExternalSymbols();
295  virtual ObjectImage *createObjectImage(ObjectBuffer *InputBuffer);
296public:
297  RuntimeDyldImpl(RTDyldMemoryManager *mm) : MemMgr(mm), HasError(false) {}
298
299  virtual ~RuntimeDyldImpl();
300
301  ObjectImage *loadObject(ObjectBuffer *InputBuffer);
302
303  void *getSymbolAddress(StringRef Name) {
304    // FIXME: Just look up as a function for now. Overly simple of course.
305    // Work in progress.
306    if (GlobalSymbolTable.find(Name) == GlobalSymbolTable.end())
307      return 0;
308    SymbolLoc Loc = GlobalSymbolTable.lookup(Name);
309    return getSectionAddress(Loc.first) + Loc.second;
310  }
311
312  uint64_t getSymbolLoadAddress(StringRef Name) {
313    // FIXME: Just look up as a function for now. Overly simple of course.
314    // Work in progress.
315    if (GlobalSymbolTable.find(Name) == GlobalSymbolTable.end())
316      return 0;
317    SymbolLoc Loc = GlobalSymbolTable.lookup(Name);
318    return getSectionLoadAddress(Loc.first) + Loc.second;
319  }
320
321  void resolveRelocations();
322
323  void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
324
325  void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress);
326
327  // Is the linker in an error state?
328  bool hasError() { return HasError; }
329
330  // Mark the error condition as handled and continue.
331  void clearError() { HasError = false; }
332
333  // Get the error message.
334  StringRef getErrorString() { return ErrorStr; }
335
336  virtual bool isCompatibleFormat(const ObjectBuffer *Buffer) const = 0;
337
338  virtual StringRef getEHFrameSection();
339};
340
341} // end namespace llvm
342
343
344#endif
345