1 //===-- RuntimeDyldMachO.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 // MachO support for MC-JIT runtime dynamic linker.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_RUNTIME_DYLD_MACHO_H
15 #define LLVM_RUNTIME_DYLD_MACHO_H
17 #include "llvm/ADT/IndexedMap.h"
18 #include "llvm/Object/MachOObject.h"
19 #include "llvm/Support/Format.h"
20 #include "RuntimeDyldImpl.h"
23 using namespace llvm::object;
27 class RuntimeDyldMachO : public RuntimeDyldImpl {
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.
42 RelocationEntry(unsigned id, uint64_t offset, uint32_t data, int64_t addend)
43 : SectionID(id), Offset(offset), Data(data), Addend(addend) {}
45 typedef SmallVector<RelocationEntry, 4> RelocationList;
47 // For each section, keep a list of referrers in that section that are clients
48 // of relocations in other sections. Whenever a relocation gets created,
49 // create a corresponding referrer. Whenever relocations are re-resolved,
50 // re-resolve the referrers' relocations as well.
52 unsigned SectionID; // Section whose RelocationList contains the relocation.
53 uint32_t Index; // Index of the RelocatonEntry in that RelocationList.
55 Referrer(unsigned id, uint32_t index)
56 : SectionID(id), Index(index) {}
58 typedef SmallVector<Referrer, 4> ReferrerList;
60 // Relocations to sections already loaded. Indexed by SectionID which is the
61 // source of the address. The target where the address will be writen is
62 // SectionID/Offset in the relocation itself.
63 IndexedMap<RelocationList> Relocations;
64 // Referrers corresponding to Relocations.
65 IndexedMap<ReferrerList> Referrers;
66 // Relocations to symbols that are not yet resolved. Must be external
67 // relocations by definition. Indexed by symbol name.
68 StringMap<RelocationList> UnresolvedRelocations;
70 bool resolveRelocation(uint8_t *LocalAddress,
71 uint64_t FinalAddress,
77 bool resolveI386Relocation(uint8_t *LocalAddress,
78 uint64_t FinalAddress,
84 bool resolveX86_64Relocation(uint8_t *LocalAddress,
85 uint64_t FinalAddress,
91 bool resolveARMRelocation(uint8_t *LocalAddress,
92 uint64_t FinalAddress,
99 bool loadSegment32(const MachOObject *Obj,
100 const MachOObject::LoadCommandInfo *SegmentLCI,
101 const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC);
102 bool loadSegment64(const MachOObject *Obj,
103 const MachOObject::LoadCommandInfo *SegmentLCI,
104 const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC);
105 bool processSymbols32(const MachOObject *Obj,
106 SmallVectorImpl<unsigned> &SectionMap,
107 SmallVectorImpl<StringRef> &SymbolNames,
108 const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC);
109 bool processSymbols64(const MachOObject *Obj,
110 SmallVectorImpl<unsigned> &SectionMap,
111 SmallVectorImpl<StringRef> &SymbolNames,
112 const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC);
114 void resolveSymbol(StringRef Name);
117 RuntimeDyldMachO(RTDyldMemoryManager *mm) : RuntimeDyldImpl(mm) {}
119 bool loadObject(MemoryBuffer *InputBuffer);
121 void reassignSectionAddress(unsigned SectionID, uint64_t Addr);
123 static bool isKnownFormat(const MemoryBuffer *InputBuffer);
125 bool isCompatibleFormat(const MemoryBuffer *InputBuffer) const {
126 return isKnownFormat(InputBuffer);
130 } // end namespace llvm