[Modules] Fix potential ODR violations by sinking the DEBUG_TYPE
[oota-llvm.git] / lib / ExecutionEngine / RuntimeDyld / RuntimeDyldMachO.cpp
1 //===-- RuntimeDyldMachO.cpp - 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 // Implementation of the MC-JIT runtime dynamic linker.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "RuntimeDyldMachO.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/ADT/StringRef.h"
17 using namespace llvm;
18 using namespace llvm::object;
19
20 #define DEBUG_TYPE "dyld"
21
22 namespace llvm {
23
24 static unsigned char *processFDE(unsigned char *P, intptr_t DeltaForText,
25                                  intptr_t DeltaForEH) {
26   uint32_t Length = *((uint32_t *)P);
27   P += 4;
28   unsigned char *Ret = P + Length;
29   uint32_t Offset = *((uint32_t *)P);
30   if (Offset == 0) // is a CIE
31     return Ret;
32
33   P += 4;
34   intptr_t FDELocation = *((intptr_t *)P);
35   intptr_t NewLocation = FDELocation - DeltaForText;
36   *((intptr_t *)P) = NewLocation;
37   P += sizeof(intptr_t);
38
39   // Skip the FDE address range
40   P += sizeof(intptr_t);
41
42   uint8_t Augmentationsize = *P;
43   P += 1;
44   if (Augmentationsize != 0) {
45     intptr_t LSDA = *((intptr_t *)P);
46     intptr_t NewLSDA = LSDA - DeltaForEH;
47     *((intptr_t *)P) = NewLSDA;
48   }
49
50   return Ret;
51 }
52
53 static intptr_t computeDelta(SectionEntry *A, SectionEntry *B) {
54   intptr_t ObjDistance = A->ObjAddress - B->ObjAddress;
55   intptr_t MemDistance = A->LoadAddress - B->LoadAddress;
56   return ObjDistance - MemDistance;
57 }
58
59 void RuntimeDyldMachO::registerEHFrames() {
60
61   if (!MemMgr)
62     return;
63   for (int i = 0, e = UnregisteredEHFrameSections.size(); i != e; ++i) {
64     EHFrameRelatedSections &SectionInfo = UnregisteredEHFrameSections[i];
65     if (SectionInfo.EHFrameSID == RTDYLD_INVALID_SECTION_ID ||
66         SectionInfo.TextSID == RTDYLD_INVALID_SECTION_ID)
67       continue;
68     SectionEntry *Text = &Sections[SectionInfo.TextSID];
69     SectionEntry *EHFrame = &Sections[SectionInfo.EHFrameSID];
70     SectionEntry *ExceptTab = NULL;
71     if (SectionInfo.ExceptTabSID != RTDYLD_INVALID_SECTION_ID)
72       ExceptTab = &Sections[SectionInfo.ExceptTabSID];
73
74     intptr_t DeltaForText = computeDelta(Text, EHFrame);
75     intptr_t DeltaForEH = 0;
76     if (ExceptTab)
77       DeltaForEH = computeDelta(ExceptTab, EHFrame);
78
79     unsigned char *P = EHFrame->Address;
80     unsigned char *End = P + EHFrame->Size;
81     do {
82       P = processFDE(P, DeltaForText, DeltaForEH);
83     } while (P != End);
84
85     MemMgr->registerEHFrames(EHFrame->Address, EHFrame->LoadAddress,
86                              EHFrame->Size);
87   }
88   UnregisteredEHFrameSections.clear();
89 }
90
91 void RuntimeDyldMachO::finalizeLoad(ObjSectionToIDMap &SectionMap) {
92   unsigned EHFrameSID = RTDYLD_INVALID_SECTION_ID;
93   unsigned TextSID = RTDYLD_INVALID_SECTION_ID;
94   unsigned ExceptTabSID = RTDYLD_INVALID_SECTION_ID;
95   ObjSectionToIDMap::iterator i, e;
96   for (i = SectionMap.begin(), e = SectionMap.end(); i != e; ++i) {
97     const SectionRef &Section = i->first;
98     StringRef Name;
99     Section.getName(Name);
100     if (Name == "__eh_frame")
101       EHFrameSID = i->second;
102     else if (Name == "__text")
103       TextSID = i->second;
104     else if (Name == "__gcc_except_tab")
105       ExceptTabSID = i->second;
106   }
107   UnregisteredEHFrameSections.push_back(
108       EHFrameRelatedSections(EHFrameSID, TextSID, ExceptTabSID));
109 }
110
111 // The target location for the relocation is described by RE.SectionID and
112 // RE.Offset.  RE.SectionID can be used to find the SectionEntry.  Each
113 // SectionEntry has three members describing its location.
114 // SectionEntry::Address is the address at which the section has been loaded
115 // into memory in the current (host) process.  SectionEntry::LoadAddress is the
116 // address that the section will have in the target process.
117 // SectionEntry::ObjAddress is the address of the bits for this section in the
118 // original emitted object image (also in the current address space).
119 //
120 // Relocations will be applied as if the section were loaded at
121 // SectionEntry::LoadAddress, but they will be applied at an address based
122 // on SectionEntry::Address.  SectionEntry::ObjAddress will be used to refer to
123 // Target memory contents if they are required for value calculations.
124 //
125 // The Value parameter here is the load address of the symbol for the
126 // relocation to be applied.  For relocations which refer to symbols in the
127 // current object Value will be the LoadAddress of the section in which
128 // the symbol resides (RE.Addend provides additional information about the
129 // symbol location).  For external symbols, Value will be the address of the
130 // symbol in the target address space.
131 void RuntimeDyldMachO::resolveRelocation(const RelocationEntry &RE,
132                                          uint64_t Value) {
133   const SectionEntry &Section = Sections[RE.SectionID];
134   return resolveRelocation(Section, RE.Offset, Value, RE.RelType, RE.Addend,
135                            RE.IsPCRel, RE.Size);
136 }
137
138 void RuntimeDyldMachO::resolveRelocation(const SectionEntry &Section,
139                                          uint64_t Offset, uint64_t Value,
140                                          uint32_t Type, int64_t Addend,
141                                          bool isPCRel, unsigned LogSize) {
142   uint8_t *LocalAddress = Section.Address + Offset;
143   uint64_t FinalAddress = Section.LoadAddress + Offset;
144   unsigned MachoType = Type;
145   unsigned Size = 1 << LogSize;
146
147   DEBUG(dbgs() << "resolveRelocation LocalAddress: "
148                << format("%p", LocalAddress)
149                << " FinalAddress: " << format("%p", FinalAddress)
150                << " Value: " << format("%p", Value) << " Addend: " << Addend
151                << " isPCRel: " << isPCRel << " MachoType: " << MachoType
152                << " Size: " << Size << "\n");
153
154   // This just dispatches to the proper target specific routine.
155   switch (Arch) {
156   default:
157     llvm_unreachable("Unsupported CPU type!");
158   case Triple::x86_64:
159     resolveX86_64Relocation(LocalAddress, FinalAddress, (uintptr_t)Value,
160                             isPCRel, MachoType, Size, Addend);
161     break;
162   case Triple::x86:
163     resolveI386Relocation(LocalAddress, FinalAddress, (uintptr_t)Value, isPCRel,
164                           MachoType, Size, Addend);
165     break;
166   case Triple::arm: // Fall through.
167   case Triple::thumb:
168     resolveARMRelocation(LocalAddress, FinalAddress, (uintptr_t)Value, isPCRel,
169                          MachoType, Size, Addend);
170     break;
171   case Triple::arm64:
172     resolveARM64Relocation(LocalAddress, FinalAddress, (uintptr_t)Value,
173                            isPCRel, MachoType, Size, Addend);
174     break;
175   }
176 }
177
178 bool RuntimeDyldMachO::resolveI386Relocation(uint8_t *LocalAddress,
179                                              uint64_t FinalAddress,
180                                              uint64_t Value, bool isPCRel,
181                                              unsigned Type, unsigned Size,
182                                              int64_t Addend) {
183   if (isPCRel)
184     Value -= FinalAddress + 4; // see resolveX86_64Relocation
185
186   switch (Type) {
187   default:
188     llvm_unreachable("Invalid relocation type!");
189   case MachO::GENERIC_RELOC_VANILLA: {
190     uint8_t *p = LocalAddress;
191     uint64_t ValueToWrite = Value + Addend;
192     for (unsigned i = 0; i < Size; ++i) {
193       *p++ = (uint8_t)(ValueToWrite & 0xff);
194       ValueToWrite >>= 8;
195     }
196     return false;
197   }
198   case MachO::GENERIC_RELOC_SECTDIFF:
199   case MachO::GENERIC_RELOC_LOCAL_SECTDIFF:
200   case MachO::GENERIC_RELOC_PB_LA_PTR:
201     return Error("Relocation type not implemented yet!");
202   }
203 }
204
205 bool RuntimeDyldMachO::resolveX86_64Relocation(uint8_t *LocalAddress,
206                                                uint64_t FinalAddress,
207                                                uint64_t Value, bool isPCRel,
208                                                unsigned Type, unsigned Size,
209                                                int64_t Addend) {
210   // If the relocation is PC-relative, the value to be encoded is the
211   // pointer difference.
212   if (isPCRel)
213     // FIXME: It seems this value needs to be adjusted by 4 for an effective PC
214     // address. Is that expected? Only for branches, perhaps?
215     Value -= FinalAddress + 4;
216
217   switch (Type) {
218   default:
219     llvm_unreachable("Invalid relocation type!");
220   case MachO::X86_64_RELOC_SIGNED_1:
221   case MachO::X86_64_RELOC_SIGNED_2:
222   case MachO::X86_64_RELOC_SIGNED_4:
223   case MachO::X86_64_RELOC_SIGNED:
224   case MachO::X86_64_RELOC_UNSIGNED:
225   case MachO::X86_64_RELOC_BRANCH: {
226     Value += Addend;
227     // Mask in the target value a byte at a time (we don't have an alignment
228     // guarantee for the target address, so this is safest).
229     uint8_t *p = (uint8_t *)LocalAddress;
230     for (unsigned i = 0; i < Size; ++i) {
231       *p++ = (uint8_t)Value;
232       Value >>= 8;
233     }
234     return false;
235   }
236   case MachO::X86_64_RELOC_GOT_LOAD:
237   case MachO::X86_64_RELOC_GOT:
238   case MachO::X86_64_RELOC_SUBTRACTOR:
239   case MachO::X86_64_RELOC_TLV:
240     return Error("Relocation type not implemented yet!");
241   }
242 }
243
244 bool RuntimeDyldMachO::resolveARMRelocation(uint8_t *LocalAddress,
245                                             uint64_t FinalAddress,
246                                             uint64_t Value, bool isPCRel,
247                                             unsigned Type, unsigned Size,
248                                             int64_t Addend) {
249   // If the relocation is PC-relative, the value to be encoded is the
250   // pointer difference.
251   if (isPCRel) {
252     Value -= FinalAddress;
253     // ARM PCRel relocations have an effective-PC offset of two instructions
254     // (four bytes in Thumb mode, 8 bytes in ARM mode).
255     // FIXME: For now, assume ARM mode.
256     Value -= 8;
257   }
258
259   switch (Type) {
260   default:
261     llvm_unreachable("Invalid relocation type!");
262   case MachO::ARM_RELOC_VANILLA: {
263     // Mask in the target value a byte at a time (we don't have an alignment
264     // guarantee for the target address, so this is safest).
265     uint8_t *p = (uint8_t *)LocalAddress;
266     for (unsigned i = 0; i < Size; ++i) {
267       *p++ = (uint8_t)Value;
268       Value >>= 8;
269     }
270     break;
271   }
272   case MachO::ARM_RELOC_BR24: {
273     // Mask the value into the target address. We know instructions are
274     // 32-bit aligned, so we can do it all at once.
275     uint32_t *p = (uint32_t *)LocalAddress;
276     // The low two bits of the value are not encoded.
277     Value >>= 2;
278     // Mask the value to 24 bits.
279     Value &= 0xffffff;
280     // FIXME: If the destination is a Thumb function (and the instruction
281     // is a non-predicated BL instruction), we need to change it to a BLX
282     // instruction instead.
283
284     // Insert the value into the instruction.
285     *p = (*p & ~0xffffff) | Value;
286     break;
287   }
288   case MachO::ARM_THUMB_RELOC_BR22:
289   case MachO::ARM_THUMB_32BIT_BRANCH:
290   case MachO::ARM_RELOC_HALF:
291   case MachO::ARM_RELOC_HALF_SECTDIFF:
292   case MachO::ARM_RELOC_PAIR:
293   case MachO::ARM_RELOC_SECTDIFF:
294   case MachO::ARM_RELOC_LOCAL_SECTDIFF:
295   case MachO::ARM_RELOC_PB_LA_PTR:
296     return Error("Relocation type not implemented yet!");
297   }
298   return false;
299 }
300
301 bool RuntimeDyldMachO::resolveARM64Relocation(uint8_t *LocalAddress,
302                                               uint64_t FinalAddress,
303                                               uint64_t Value, bool isPCRel,
304                                               unsigned Type, unsigned Size,
305                                               int64_t Addend) {
306   // If the relocation is PC-relative, the value to be encoded is the
307   // pointer difference.
308   if (isPCRel)
309     Value -= FinalAddress;
310
311   switch (Type) {
312   default:
313     llvm_unreachable("Invalid relocation type!");
314   case MachO::ARM64_RELOC_UNSIGNED: {
315     // Mask in the target value a byte at a time (we don't have an alignment
316     // guarantee for the target address, so this is safest).
317     uint8_t *p = (uint8_t *)LocalAddress;
318     for (unsigned i = 0; i < Size; ++i) {
319       *p++ = (uint8_t)Value;
320       Value >>= 8;
321     }
322     break;
323   }
324   case MachO::ARM64_RELOC_BRANCH26: {
325     // Mask the value into the target address. We know instructions are
326     // 32-bit aligned, so we can do it all at once.
327     uint32_t *p = (uint32_t *)LocalAddress;
328     // The low two bits of the value are not encoded.
329     Value >>= 2;
330     // Mask the value to 26 bits.
331     Value &= 0x3ffffff;
332     // Insert the value into the instruction.
333     *p = (*p & ~0x3ffffff) | Value;
334     break;
335   }
336   case MachO::ARM64_RELOC_SUBTRACTOR:
337   case MachO::ARM64_RELOC_PAGE21:
338   case MachO::ARM64_RELOC_PAGEOFF12:
339   case MachO::ARM64_RELOC_GOT_LOAD_PAGE21:
340   case MachO::ARM64_RELOC_GOT_LOAD_PAGEOFF12:
341   case MachO::ARM64_RELOC_POINTER_TO_GOT:
342   case MachO::ARM64_RELOC_TLVP_LOAD_PAGE21:
343   case MachO::ARM64_RELOC_TLVP_LOAD_PAGEOFF12:
344   case MachO::ARM64_RELOC_ADDEND:
345     return Error("Relocation type not implemented yet!");
346   }
347   return false;
348 }
349
350 relocation_iterator RuntimeDyldMachO::processRelocationRef(
351     unsigned SectionID, relocation_iterator RelI, ObjectImage &Obj,
352     ObjSectionToIDMap &ObjSectionToID, const SymbolTableMap &Symbols,
353     StubMap &Stubs) {
354   const ObjectFile *OF = Obj.getObjectFile();
355   const MachOObjectFile *MachO = static_cast<const MachOObjectFile *>(OF);
356   MachO::any_relocation_info RE =
357       MachO->getRelocation(RelI->getRawDataRefImpl());
358
359   uint32_t RelType = MachO->getAnyRelocationType(RE);
360
361   // FIXME: Properly handle scattered relocations.
362   //        For now, optimistically skip these: they can often be ignored, as
363   //        the static linker will already have applied the relocation, and it
364   //        only needs to be reapplied if symbols move relative to one another.
365   //        Note: This will fail horribly where the relocations *do* need to be
366   //        applied, but that was already the case.
367   if (MachO->isRelocationScattered(RE))
368     return ++RelI;
369
370   RelocationValueRef Value;
371   SectionEntry &Section = Sections[SectionID];
372
373   bool isExtern = MachO->getPlainRelocationExternal(RE);
374   bool IsPCRel = MachO->getAnyRelocationPCRel(RE);
375   unsigned Size = MachO->getAnyRelocationLength(RE);
376   uint64_t Offset;
377   RelI->getOffset(Offset);
378   uint8_t *LocalAddress = Section.Address + Offset;
379   unsigned NumBytes = 1 << Size;
380   uint64_t Addend = 0;
381   memcpy(&Addend, LocalAddress, NumBytes);
382
383   if (isExtern) {
384     // Obtain the symbol name which is referenced in the relocation
385     symbol_iterator Symbol = RelI->getSymbol();
386     StringRef TargetName;
387     Symbol->getName(TargetName);
388     // First search for the symbol in the local symbol table
389     SymbolTableMap::const_iterator lsi = Symbols.find(TargetName.data());
390     if (lsi != Symbols.end()) {
391       Value.SectionID = lsi->second.first;
392       Value.Addend = lsi->second.second + Addend;
393     } else {
394       // Search for the symbol in the global symbol table
395       SymbolTableMap::const_iterator gsi =
396           GlobalSymbolTable.find(TargetName.data());
397       if (gsi != GlobalSymbolTable.end()) {
398         Value.SectionID = gsi->second.first;
399         Value.Addend = gsi->second.second + Addend;
400       } else {
401         Value.SymbolName = TargetName.data();
402         Value.Addend = Addend;
403       }
404     }
405   } else {
406     SectionRef Sec = MachO->getRelocationSection(RE);
407     bool IsCode = false;
408     Sec.isText(IsCode);
409     Value.SectionID = findOrEmitSection(Obj, Sec, IsCode, ObjSectionToID);
410     uint64_t Addr;
411     Sec.getAddress(Addr);
412     Value.Addend = Addend - Addr;
413     if (IsPCRel)
414       Value.Addend += Offset + NumBytes;
415   }
416
417   if (Arch == Triple::x86_64 && (RelType == MachO::X86_64_RELOC_GOT ||
418                                  RelType == MachO::X86_64_RELOC_GOT_LOAD)) {
419     assert(IsPCRel);
420     assert(Size == 2);
421     StubMap::const_iterator i = Stubs.find(Value);
422     uint8_t *Addr;
423     if (i != Stubs.end()) {
424       Addr = Section.Address + i->second;
425     } else {
426       Stubs[Value] = Section.StubOffset;
427       uint8_t *GOTEntry = Section.Address + Section.StubOffset;
428       RelocationEntry RE(SectionID, Section.StubOffset,
429                          MachO::X86_64_RELOC_UNSIGNED, 0, false, 3);
430       if (Value.SymbolName)
431         addRelocationForSymbol(RE, Value.SymbolName);
432       else
433         addRelocationForSection(RE, Value.SectionID);
434       Section.StubOffset += 8;
435       Addr = GOTEntry;
436     }
437     resolveRelocation(Section, Offset, (uint64_t)Addr,
438                       MachO::X86_64_RELOC_UNSIGNED, Value.Addend, true, 2);
439   } else if (Arch == Triple::arm && (RelType & 0xf) == MachO::ARM_RELOC_BR24) {
440     // This is an ARM branch relocation, need to use a stub function.
441
442     //  Look up for existing stub.
443     StubMap::const_iterator i = Stubs.find(Value);
444     if (i != Stubs.end())
445       resolveRelocation(Section, Offset, (uint64_t)Section.Address + i->second,
446                         RelType, 0, IsPCRel, Size);
447     else {
448       // Create a new stub function.
449       Stubs[Value] = Section.StubOffset;
450       uint8_t *StubTargetAddr =
451           createStubFunction(Section.Address + Section.StubOffset);
452       RelocationEntry RE(SectionID, StubTargetAddr - Section.Address,
453                          MachO::GENERIC_RELOC_VANILLA, Value.Addend);
454       if (Value.SymbolName)
455         addRelocationForSymbol(RE, Value.SymbolName);
456       else
457         addRelocationForSection(RE, Value.SectionID);
458       resolveRelocation(Section, Offset,
459                         (uint64_t)Section.Address + Section.StubOffset, RelType,
460                         0, IsPCRel, Size);
461       Section.StubOffset += getMaxStubSize();
462     }
463   } else {
464     RelocationEntry RE(SectionID, Offset, RelType, Value.Addend, IsPCRel, Size);
465     if (Value.SymbolName)
466       addRelocationForSymbol(RE, Value.SymbolName);
467     else
468       addRelocationForSection(RE, Value.SectionID);
469   }
470   return ++RelI;
471 }
472
473 bool
474 RuntimeDyldMachO::isCompatibleFormat(const ObjectBuffer *InputBuffer) const {
475   if (InputBuffer->getBufferSize() < 4)
476     return false;
477   StringRef Magic(InputBuffer->getBufferStart(), 4);
478   if (Magic == "\xFE\xED\xFA\xCE")
479     return true;
480   if (Magic == "\xCE\xFA\xED\xFE")
481     return true;
482   if (Magic == "\xFE\xED\xFA\xCF")
483     return true;
484   if (Magic == "\xCF\xFA\xED\xFE")
485     return true;
486   return false;
487 }
488
489 bool RuntimeDyldMachO::isCompatibleFile(const object::ObjectFile *Obj) const {
490   return Obj->isMachO();
491 }
492
493 } // end namespace llvm