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 "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"
29#include <map>
30
31using namespace llvm;
32using namespace llvm::object;
33
34namespace llvm {
35
36class MemoryBuffer;
37class Twine;
38
39
40/// SectionEntry - represents a section emitted into memory by the dynamic
41/// linker.
42class SectionEntry {
43public:
44  /// Address - address in the linker's memory where the section resides.
45  uint8_t *Address;
46
47  /// Size - section size.
48  size_t Size;
49
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.
54  uint64_t LoadAddress;
55
56  /// StubOffset - used for architectures with stub functions for far
57  /// relocations (like ARM).
58  uintptr_t StubOffset;
59
60  /// ObjAddress - address of the section in the in-memory object file.  Used
61  /// for calculating relocations in some object formats (like MachO).
62  uintptr_t ObjAddress;
63
64  SectionEntry(uint8_t *address, size_t size, uintptr_t stubOffset,
65               uintptr_t objAddress)
66    : Address(address), Size(size), LoadAddress((uintptr_t)address),
67      StubOffset(stubOffset), ObjAddress(objAddress) {}
68};
69
70/// RelocationEntry - used to represent relocations internally in the dynamic
71/// linker.
72class RelocationEntry {
73public:
74  /// SectionID - the section this relocation points to.
75  unsigned SectionID;
76
77  /// Offset - offset into the section.
78  uintptr_t Offset;
79
80  /// RelType - relocation type.
81  uint32_t RelType;
82
83  /// Addend - the relocation addend encoded in the instruction itself.  Also
84  /// used to make a relocation section relative instead of symbol relative.
85  intptr_t Addend;
86
87  RelocationEntry(unsigned id, uint64_t offset, uint32_t type, int64_t addend)
88    : SectionID(id), Offset(offset), RelType(type), Addend(addend) {}
89};
90
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).
94class ObjRelocationInfo {
95public:
96  unsigned  SectionID;
97  uint64_t  Offset;
98  SymbolRef Symbol;
99  uint64_t  Type;
100  int64_t   AdditionalInfo;
101};
102
103class RelocationValueRef {
104public:
105  unsigned  SectionID;
106  intptr_t  Addend;
107  const char *SymbolName;
108  RelocationValueRef(): SectionID(0), Addend(0), SymbolName(0) {}
109
110  inline bool operator==(const RelocationValueRef &Other) const {
111    return std::memcmp(this, &Other, sizeof(RelocationValueRef)) == 0;
112  }
113  inline bool operator <(const RelocationValueRef &Other) const {
114    return std::memcmp(this, &Other, sizeof(RelocationValueRef)) < 0;
115  }
116};
117
118class RuntimeDyldImpl {
119protected:
120  // The MemoryManager to load objects into.
121  RTDyldMemoryManager *MemMgr;
122
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;
127
128  // Keep a map of sections from object file to the SectionID which
129  // references it.
130  typedef std::map<SectionRef, unsigned> ObjSectionToIDMap;
131
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;
137
138  // Keep a map of common symbols to their sizes
139  typedef std::map<SymbolRef, unsigned> CommonSymbolMap;
140
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;
151
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;
156
157  typedef std::map<RelocationValueRef, uintptr_t> StubMap;
158
159  Triple::ArchType Arch;
160
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)
165      return 16;
166    else
167      return 0;
168  }
169
170  bool HasError;
171  std::string ErrorStr;
172
173  // Set the error state and record an error string.
174  bool Error(const Twine &Msg) {
175    ErrorStr = Msg.str();
176    HasError = true;
177    return true;
178  }
179
180  uint64_t getSectionLoadAddress(unsigned SectionID) {
181    return Sections[SectionID].LoadAddress;
182  }
183
184  uint8_t *getSectionAddress(unsigned SectionID) {
185    return (uint8_t*)Sections[SectionID].Address;
186  }
187
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
190  /// symbol table.
191  void emitCommonSymbols(ObjectImage &Obj,
192                         const CommonSymbolMap &CommonSymbols,
193                         uint64_t TotalSize,
194                         SymbolTableMap &SymbolTable);
195
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,
202                       bool IsCode);
203
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,
211                             bool IsCode,
212                             ObjSectionToIDMap &LocalSections);
213
214  // \brief Add a relocation entry that uses the given section.
215  void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID);
216
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);
220
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);
224
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);
228
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,
240                                 uint64_t Value,
241                                 uint32_t Type,
242                                 int64_t Addend) = 0;
243
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,
247                                    ObjectImage &Obj,
248                                    ObjSectionToIDMap &ObjSectionToID,
249                                    const SymbolTableMap &Symbols,
250                                    StubMap &Stubs) = 0;
251
252  /// \brief Resolve relocations to external symbols.
253  void resolveExternalSymbols();
254  virtual ObjectImage *createObjectImage(const MemoryBuffer *InputBuffer);
255  virtual void handleObjectLoaded(ObjectImage *Obj)
256  {
257    // Subclasses may choose to retain this image if they have a use for it
258    delete Obj;
259  }
260
261public:
262  RuntimeDyldImpl(RTDyldMemoryManager *mm) : MemMgr(mm), HasError(false) {}
263
264  virtual ~RuntimeDyldImpl();
265
266  bool loadObject(const MemoryBuffer *InputBuffer);
267
268  void *getSymbolAddress(StringRef Name) {
269    // FIXME: Just look up as a function for now. Overly simple of course.
270    // Work in progress.
271    if (GlobalSymbolTable.find(Name) == GlobalSymbolTable.end())
272      return 0;
273    SymbolLoc Loc = GlobalSymbolTable.lookup(Name);
274    return getSectionAddress(Loc.first) + Loc.second;
275  }
276
277  uint64_t getSymbolLoadAddress(StringRef Name) {
278    // FIXME: Just look up as a function for now. Overly simple of course.
279    // Work in progress.
280    if (GlobalSymbolTable.find(Name) == GlobalSymbolTable.end())
281      return 0;
282    SymbolLoc Loc = GlobalSymbolTable.lookup(Name);
283    return getSectionLoadAddress(Loc.first) + Loc.second;
284  }
285
286  void resolveRelocations();
287
288  void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
289
290  void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress);
291
292  // Is the linker in an error state?
293  bool hasError() { return HasError; }
294
295  // Mark the error condition as handled and continue.
296  void clearError() { HasError = false; }
297
298  // Get the error message.
299  StringRef getErrorString() { return ErrorStr; }
300
301  virtual bool isCompatibleFormat(const MemoryBuffer *InputBuffer) const = 0;
302
303};
304
305} // end namespace llvm
306
307
308#endif
309