RuntimeDyldMachO.h revision 76463fdeb603e1d89b05f094bfd6fe73b90d0b61 
1//===-- RuntimeDyldMachO.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// MachO support for MC-JIT runtime dynamic linker.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_RUNTIME_DYLD_MACHO_H
15#define LLVM_RUNTIME_DYLD_MACHO_H
16
17#include "llvm/ADT/IndexedMap.h"
18#include "llvm/Object/MachOObject.h"
19#include "llvm/Support/Format.h"
20#include "RuntimeDyldImpl.h"
21
22using namespace llvm;
23using namespace llvm::object;
24
25
26namespace llvm {
27class RuntimeDyldMachO : public RuntimeDyldImpl {
28
29  // For each symbol, keep a list of relocations based on it. Anytime
30  // its address is reassigned (the JIT re-compiled the function, e.g.),
31  // the relocations get re-resolved.
32  // The symbol (or section) the relocation is sourced from is the Key
33  // in the relocation list where it's stored.
34  struct RelocationEntry {
35    unsigned    SectionID;  // Section the relocation is contained in.
36    uint64_t    Offset;     // Offset into the section for the relocation.
37    uint32_t    Data;       // Second word of the raw macho relocation entry.
38    int64_t     Addend;     // Addend encoded in the instruction itself, if any,
39                            // plus the offset into the source section for
40                            // the symbol once the relocation is resolvable.
41
42    RelocationEntry(unsigned id, uint64_t offset, uint32_t data, int64_t addend)
43      : SectionID(id), Offset(offset), Data(data), Addend(addend) {}
44  };
45  typedef SmallVector<RelocationEntry, 4> RelocationList;
46  // Relocations to sections already loaded. Indexed by SectionID which is the
47  // source of the address. The target where the address will be writen is
48  // SectionID/Offset in the relocation itself.
49  IndexedMap<RelocationList> Relocations;
50  // Relocations to symbols that are not yet resolved. Must be external
51  // relocations by definition. Indexed by symbol name.
52  StringMap<RelocationList> UnresolvedRelocations;
53
54  bool resolveRelocation(uint8_t *Address, uint64_t Value, bool isPCRel,
55                         unsigned Type, unsigned Size, int64_t Addend);
56  bool resolveX86_64Relocation(uintptr_t Address, uintptr_t Value, bool isPCRel,
57                               unsigned Type, unsigned Size, int64_t Addend);
58  bool resolveARMRelocation(uintptr_t Address, uintptr_t Value, bool isPCRel,
59                            unsigned Type, unsigned Size, int64_t Addend);
60
61  bool loadSegment32(const MachOObject *Obj,
62                     const MachOObject::LoadCommandInfo *SegmentLCI,
63                     const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC);
64  bool loadSegment64(const MachOObject *Obj,
65                     const MachOObject::LoadCommandInfo *SegmentLCI,
66                     const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC);
67  bool processSymbols32(const MachOObject *Obj,
68                      SmallVectorImpl<unsigned> &SectionMap,
69                      SmallVectorImpl<StringRef> &SymbolNames,
70                      const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC);
71  bool processSymbols64(const MachOObject *Obj,
72                      SmallVectorImpl<unsigned> &SectionMap,
73                      SmallVectorImpl<StringRef> &SymbolNames,
74                      const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC);
75
76  void resolveSymbol(StringRef Name);
77
78public:
79  RuntimeDyldMachO(RTDyldMemoryManager *mm) : RuntimeDyldImpl(mm) {}
80
81  bool loadObject(MemoryBuffer *InputBuffer);
82
83  void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
84
85  static bool isKnownFormat(const MemoryBuffer *InputBuffer);
86
87  bool isCompatibleFormat(const MemoryBuffer *InputBuffer) const {
88    return isKnownFormat(InputBuffer);
89  }
90};
91
92} // end namespace llvm
93
94#endif
95
96//===-- RuntimeDyldMachO.h - Run-time dynamic linker for MC-JIT ---*- C++ -*-=//
97//
98//                     The LLVM Compiler Infrastructure
99//
100// This file is distributed under the University of Illinois Open Source
101// License. See LICENSE.TXT for details.
102//
103//===----------------------------------------------------------------------===//
104//
105// MachO support for MC-JIT runtime dynamic linker.
106//
107//===----------------------------------------------------------------------===//
108
109#ifndef LLVM_RUNTIME_DYLD_MACHO_H
110#define LLVM_RUNTIME_DYLD_MACHO_H
111
112#include "llvm/ADT/IndexedMap.h"
113#include "llvm/Object/MachOObject.h"
114#include "llvm/Support/Format.h"
115#include "RuntimeDyldImpl.h"
116
117using namespace llvm;
118using namespace llvm::object;
119
120
121namespace llvm {
122class RuntimeDyldMachO : public RuntimeDyldImpl {
123
124  // For each symbol, keep a list of relocations based on it. Anytime
125  // its address is reassigned (the JIT re-compiled the function, e.g.),
126  // the relocations get re-resolved.
127  // The symbol (or section) the relocation is sourced from is the Key
128  // in the relocation list where it's stored.
129  struct RelocationEntry {
130    unsigned    SectionID;  // Section the relocation is contained in.
131    uint64_t    Offset;     // Offset into the section for the relocation.
132    uint32_t    Data;       // Second word of the raw macho relocation entry.
133    int64_t     Addend;     // Addend encoded in the instruction itself, if any,
134                            // plus the offset into the source section for
135                            // the symbol once the relocation is resolvable.
136
137    RelocationEntry(unsigned id, uint64_t offset, uint32_t data, int64_t addend)
138      : SectionID(id), Offset(offset), Data(data), Addend(addend) {}
139  };
140  typedef SmallVector<RelocationEntry, 4> RelocationList;
141  // Relocations to sections already loaded. Indexed by SectionID which is the
142  // source of the address. The target where the address will be writen is
143  // SectionID/Offset in the relocation itself.
144  IndexedMap<RelocationList> Relocations;
145  // Relocations to symbols that are not yet resolved. Must be external
146  // relocations by definition. Indexed by symbol name.
147  StringMap<RelocationList> UnresolvedRelocations;
148
149  bool resolveRelocation(uint8_t *Address, uint64_t Value, bool isPCRel,
150                         unsigned Type, unsigned Size, int64_t Addend);
151  bool resolveX86_64Relocation(uintptr_t Address, uintptr_t Value, bool isPCRel,
152                               unsigned Type, unsigned Size, int64_t Addend);
153  bool resolveARMRelocation(uintptr_t Address, uintptr_t Value, bool isPCRel,
154                            unsigned Type, unsigned Size, int64_t Addend);
155
156  bool loadSegment32(const MachOObject *Obj,
157                     const MachOObject::LoadCommandInfo *SegmentLCI,
158                     const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC);
159  bool loadSegment64(const MachOObject *Obj,
160                     const MachOObject::LoadCommandInfo *SegmentLCI,
161                     const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC);
162  bool processSymbols32(const MachOObject *Obj,
163                      SmallVectorImpl<unsigned> &SectionMap,
164                      SmallVectorImpl<StringRef> &SymbolNames,
165                      const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC);
166  bool processSymbols64(const MachOObject *Obj,
167                      SmallVectorImpl<unsigned> &SectionMap,
168                      SmallVectorImpl<StringRef> &SymbolNames,
169                      const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC);
170
171  void resolveSymbol(StringRef Name);
172
173public:
174  RuntimeDyldMachO(RTDyldMemoryManager *mm) : RuntimeDyldImpl(mm) {}
175
176  bool loadObject(MemoryBuffer *InputBuffer);
177
178  void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
179
180  static bool isKnownFormat(const MemoryBuffer *InputBuffer);
181
182  bool isCompatibleFormat(const MemoryBuffer *InputBuffer) const {
183    return isKnownFormat(InputBuffer);
184  }
185};
186
187} // end namespace llvm
188
189#endif
190
191