xref: /llvm-project/llvm/lib/Object/MachOObjectFile.cpp (revision bc14bd3bfb0e5faa52a85a161db53eccd8c2e1b4) 
1 //===- MachOObjectFile.cpp - Mach-O object file binding ---------*- 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 // This file defines the MachOObjectFile class, which binds the MachOObject
11 // class to the generic ObjectFile wrapper.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/ADT/Triple.h"
16 #include "llvm/Object/MachO.h"
17 #include "llvm/Object/MachOFormat.h"
18 #include "llvm/Support/Format.h"
19 #include "llvm/Support/MemoryBuffer.h"
20 
21 #include <cctype>
22 #include <cstring>
23 #include <limits>
24 
25 using namespace llvm;
26 using namespace object;
27 
28 namespace llvm {
29 namespace object {
30 
31 MachOObjectFile::MachOObjectFile(MemoryBuffer *Object, MachOObject *MOO,
32                                  error_code &ec)
33     : ObjectFile(Binary::isMachO, Object, ec),
34       MachOObj(MOO),
35       RegisteredStringTable(std::numeric_limits<uint32_t>::max()) {
36   DataRefImpl DRI;
37   DRI.d.a = DRI.d.b = 0;
38   moveToNextSection(DRI);
39   uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands;
40   while (DRI.d.a < LoadCommandCount) {
41     Sections.push_back(DRI);
42     DRI.d.b++;
43     moveToNextSection(DRI);
44   }
45 }
46 
47 
48 ObjectFile *ObjectFile::createMachOObjectFile(MemoryBuffer *Buffer) {
49   error_code ec;
50   std::string Err;
51   MachOObject *MachOObj = MachOObject::LoadFromBuffer(Buffer, &Err);
52   if (!MachOObj)
53     return NULL;
54   return new MachOObjectFile(Buffer, MachOObj, ec);
55 }
56 
57 /*===-- Symbols -----------------------------------------------------------===*/
58 
59 void MachOObjectFile::moveToNextSymbol(DataRefImpl &DRI) const {
60   uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands;
61   while (DRI.d.a < LoadCommandCount) {
62     LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
63     if (LCI.Command.Type == macho::LCT_Symtab) {
64       InMemoryStruct<macho::SymtabLoadCommand> SymtabLoadCmd;
65       MachOObj->ReadSymtabLoadCommand(LCI, SymtabLoadCmd);
66       if (DRI.d.b < SymtabLoadCmd->NumSymbolTableEntries)
67         return;
68     }
69 
70     DRI.d.a++;
71     DRI.d.b = 0;
72   }
73 }
74 
75 void MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI,
76     InMemoryStruct<macho::SymbolTableEntry> &Res) const {
77   InMemoryStruct<macho::SymtabLoadCommand> SymtabLoadCmd;
78   LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
79   MachOObj->ReadSymtabLoadCommand(LCI, SymtabLoadCmd);
80 
81   if (RegisteredStringTable != DRI.d.a) {
82     MachOObj->RegisterStringTable(*SymtabLoadCmd);
83     RegisteredStringTable = DRI.d.a;
84   }
85 
86   MachOObj->ReadSymbolTableEntry(SymtabLoadCmd->SymbolTableOffset, DRI.d.b,
87                                  Res);
88 }
89 
90 void MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI,
91     InMemoryStruct<macho::Symbol64TableEntry> &Res) const {
92   InMemoryStruct<macho::SymtabLoadCommand> SymtabLoadCmd;
93   LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
94   MachOObj->ReadSymtabLoadCommand(LCI, SymtabLoadCmd);
95 
96   if (RegisteredStringTable != DRI.d.a) {
97     MachOObj->RegisterStringTable(*SymtabLoadCmd);
98     RegisteredStringTable = DRI.d.a;
99   }
100 
101   MachOObj->ReadSymbol64TableEntry(SymtabLoadCmd->SymbolTableOffset, DRI.d.b,
102                                    Res);
103 }
104 
105 
106 error_code MachOObjectFile::getSymbolNext(DataRefImpl DRI,
107                                           SymbolRef &Result) const {
108   DRI.d.b++;
109   moveToNextSymbol(DRI);
110   Result = SymbolRef(DRI, this);
111   return object_error::success;
112 }
113 
114 error_code MachOObjectFile::getSymbolName(DataRefImpl DRI,
115                                           StringRef &Result) const {
116   if (MachOObj->is64Bit()) {
117     InMemoryStruct<macho::Symbol64TableEntry> Entry;
118     getSymbol64TableEntry(DRI, Entry);
119     Result = MachOObj->getStringAtIndex(Entry->StringIndex);
120   } else {
121     InMemoryStruct<macho::SymbolTableEntry> Entry;
122     getSymbolTableEntry(DRI, Entry);
123     Result = MachOObj->getStringAtIndex(Entry->StringIndex);
124   }
125   return object_error::success;
126 }
127 
128 error_code MachOObjectFile::getSymbolOffset(DataRefImpl DRI,
129                                              uint64_t &Result) const {
130   uint64_t SectionOffset;
131   uint8_t SectionIndex;
132   if (MachOObj->is64Bit()) {
133     InMemoryStruct<macho::Symbol64TableEntry> Entry;
134     getSymbol64TableEntry(DRI, Entry);
135     Result = Entry->Value;
136     SectionIndex = Entry->SectionIndex;
137   } else {
138     InMemoryStruct<macho::SymbolTableEntry> Entry;
139     getSymbolTableEntry(DRI, Entry);
140     Result = Entry->Value;
141     SectionIndex = Entry->SectionIndex;
142   }
143   getSectionAddress(Sections[SectionIndex-1], SectionOffset);
144   Result -= SectionOffset;
145 
146   return object_error::success;
147 }
148 
149 error_code MachOObjectFile::getSymbolAddress(DataRefImpl DRI,
150                                              uint64_t &Result) const {
151   if (MachOObj->is64Bit()) {
152     InMemoryStruct<macho::Symbol64TableEntry> Entry;
153     getSymbol64TableEntry(DRI, Entry);
154     Result = Entry->Value;
155   } else {
156     InMemoryStruct<macho::SymbolTableEntry> Entry;
157     getSymbolTableEntry(DRI, Entry);
158     Result = Entry->Value;
159   }
160   return object_error::success;
161 }
162 
163 error_code MachOObjectFile::getSymbolSize(DataRefImpl DRI,
164                                           uint64_t &Result) const {
165   Result = UnknownAddressOrSize;
166   return object_error::success;
167 }
168 
169 error_code MachOObjectFile::getSymbolNMTypeChar(DataRefImpl DRI,
170                                                 char &Result) const {
171   uint8_t Type, Flags;
172   if (MachOObj->is64Bit()) {
173     InMemoryStruct<macho::Symbol64TableEntry> Entry;
174     getSymbol64TableEntry(DRI, Entry);
175     Type = Entry->Type;
176     Flags = Entry->Flags;
177   } else {
178     InMemoryStruct<macho::SymbolTableEntry> Entry;
179     getSymbolTableEntry(DRI, Entry);
180     Type = Entry->Type;
181     Flags = Entry->Flags;
182   }
183 
184   char Char;
185   switch (Type & macho::STF_TypeMask) {
186     case macho::STT_Undefined:
187       Char = 'u';
188       break;
189     case macho::STT_Absolute:
190     case macho::STT_Section:
191       Char = 's';
192       break;
193     default:
194       Char = '?';
195       break;
196   }
197 
198   if (Flags & (macho::STF_External | macho::STF_PrivateExtern))
199     Char = toupper(Char);
200   Result = Char;
201   return object_error::success;
202 }
203 
204 error_code MachOObjectFile::isSymbolInternal(DataRefImpl DRI,
205                                              bool &Result) const {
206   if (MachOObj->is64Bit()) {
207     InMemoryStruct<macho::Symbol64TableEntry> Entry;
208     getSymbol64TableEntry(DRI, Entry);
209     Result = Entry->Flags & macho::STF_StabsEntryMask;
210   } else {
211     InMemoryStruct<macho::SymbolTableEntry> Entry;
212     getSymbolTableEntry(DRI, Entry);
213     Result = Entry->Flags & macho::STF_StabsEntryMask;
214   }
215   return object_error::success;
216 }
217 
218 error_code MachOObjectFile::isSymbolGlobal(DataRefImpl Symb, bool &Res) const {
219 
220   if (MachOObj->is64Bit()) {
221     InMemoryStruct<macho::Symbol64TableEntry> Entry;
222     getSymbol64TableEntry(Symb, Entry);
223     Res = Entry->Type & MachO::NlistMaskExternal;
224   } else {
225     InMemoryStruct<macho::SymbolTableEntry> Entry;
226     getSymbolTableEntry(Symb, Entry);
227     Res = Entry->Type & MachO::NlistMaskExternal;
228   }
229   return object_error::success;
230 }
231 
232 error_code MachOObjectFile::isSymbolWeak(DataRefImpl Symb, bool &Res) const {
233 
234   if (MachOObj->is64Bit()) {
235     InMemoryStruct<macho::Symbol64TableEntry> Entry;
236     getSymbol64TableEntry(Symb, Entry);
237     Res = Entry->Flags & (MachO::NListDescWeakRef | MachO::NListDescWeakDef);
238   } else {
239     InMemoryStruct<macho::SymbolTableEntry> Entry;
240     getSymbolTableEntry(Symb, Entry);
241     Res = Entry->Flags & (MachO::NListDescWeakRef | MachO::NListDescWeakDef);
242   }
243   return object_error::success;
244 }
245 
246 error_code MachOObjectFile::isSymbolAbsolute(DataRefImpl Symb, bool &Res) const{
247   uint8_t n_type;
248   if (MachOObj->is64Bit()) {
249     InMemoryStruct<macho::Symbol64TableEntry> Entry;
250     getSymbol64TableEntry(Symb, Entry);
251     n_type = Entry->Type;
252   } else {
253     InMemoryStruct<macho::SymbolTableEntry> Entry;
254     getSymbolTableEntry(Symb, Entry);
255     n_type = Entry->Type;
256   }
257 
258   Res = (n_type & MachO::NlistMaskType) == MachO::NListTypeAbsolute;
259   return object_error::success;
260 }
261 
262 error_code MachOObjectFile::getSymbolSection(DataRefImpl Symb,
263                                              section_iterator &Res) const {
264   uint8_t index;
265   if (MachOObj->is64Bit()) {
266     InMemoryStruct<macho::Symbol64TableEntry> Entry;
267     getSymbol64TableEntry(Symb, Entry);
268     index = Entry->SectionIndex;
269   } else {
270     InMemoryStruct<macho::SymbolTableEntry> Entry;
271     getSymbolTableEntry(Symb, Entry);
272     index = Entry->SectionIndex;
273   }
274 
275   if (index == 0)
276     Res = end_sections();
277   else
278     Res = section_iterator(SectionRef(Sections[index], this));
279 
280   return object_error::success;
281 }
282 
283 error_code MachOObjectFile::getSymbolType(DataRefImpl Symb,
284                                           SymbolRef::Type &Res) const {
285   uint8_t n_type;
286   if (MachOObj->is64Bit()) {
287     InMemoryStruct<macho::Symbol64TableEntry> Entry;
288     getSymbol64TableEntry(Symb, Entry);
289     n_type = Entry->Type;
290   } else {
291     InMemoryStruct<macho::SymbolTableEntry> Entry;
292     getSymbolTableEntry(Symb, Entry);
293     n_type = Entry->Type;
294   }
295   Res = SymbolRef::ST_Other;
296 
297   // If this is a STAB debugging symbol, we can do nothing more.
298   if (n_type & MachO::NlistMaskStab) {
299     Res = SymbolRef::ST_Debug;
300     return object_error::success;
301   }
302 
303   switch (n_type & MachO::NlistMaskType) {
304     case MachO::NListTypeUndefined :
305       Res = SymbolRef::ST_External;
306       break;
307     case MachO::NListTypeSection :
308       Res = SymbolRef::ST_Function;
309       break;
310   }
311   return object_error::success;
312 }
313 
314 
315 symbol_iterator MachOObjectFile::begin_symbols() const {
316   // DRI.d.a = segment number; DRI.d.b = symbol index.
317   DataRefImpl DRI;
318   DRI.d.a = DRI.d.b = 0;
319   moveToNextSymbol(DRI);
320   return symbol_iterator(SymbolRef(DRI, this));
321 }
322 
323 symbol_iterator MachOObjectFile::end_symbols() const {
324   DataRefImpl DRI;
325   DRI.d.a = MachOObj->getHeader().NumLoadCommands;
326   DRI.d.b = 0;
327   return symbol_iterator(SymbolRef(DRI, this));
328 }
329 
330 
331 /*===-- Sections ----------------------------------------------------------===*/
332 
333 void MachOObjectFile::moveToNextSection(DataRefImpl &DRI) const {
334   uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands;
335   while (DRI.d.a < LoadCommandCount) {
336     LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
337     if (LCI.Command.Type == macho::LCT_Segment) {
338       InMemoryStruct<macho::SegmentLoadCommand> SegmentLoadCmd;
339       MachOObj->ReadSegmentLoadCommand(LCI, SegmentLoadCmd);
340       if (DRI.d.b < SegmentLoadCmd->NumSections)
341         return;
342     } else if (LCI.Command.Type == macho::LCT_Segment64) {
343       InMemoryStruct<macho::Segment64LoadCommand> Segment64LoadCmd;
344       MachOObj->ReadSegment64LoadCommand(LCI, Segment64LoadCmd);
345       if (DRI.d.b < Segment64LoadCmd->NumSections)
346         return;
347     }
348 
349     DRI.d.a++;
350     DRI.d.b = 0;
351   }
352 }
353 
354 error_code MachOObjectFile::getSectionNext(DataRefImpl DRI,
355                                            SectionRef &Result) const {
356   DRI.d.b++;
357   moveToNextSection(DRI);
358   Result = SectionRef(DRI, this);
359   return object_error::success;
360 }
361 
362 void
363 MachOObjectFile::getSection(DataRefImpl DRI,
364                             InMemoryStruct<macho::Section> &Res) const {
365   InMemoryStruct<macho::SegmentLoadCommand> SLC;
366   LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
367   MachOObj->ReadSegmentLoadCommand(LCI, SLC);
368   MachOObj->ReadSection(LCI, DRI.d.b, Res);
369 }
370 
371 std::size_t MachOObjectFile::getSectionIndex(DataRefImpl Sec) const {
372   SectionList::const_iterator loc =
373     std::find(Sections.begin(), Sections.end(), Sec);
374   assert(loc != Sections.end() && "Sec is not a valid section!");
375   return std::distance(Sections.begin(), loc);
376 }
377 
378 void
379 MachOObjectFile::getSection64(DataRefImpl DRI,
380                             InMemoryStruct<macho::Section64> &Res) const {
381   InMemoryStruct<macho::Segment64LoadCommand> SLC;
382   LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
383   MachOObj->ReadSegment64LoadCommand(LCI, SLC);
384   MachOObj->ReadSection64(LCI, DRI.d.b, Res);
385 }
386 
387 static bool is64BitLoadCommand(const MachOObject *MachOObj, DataRefImpl DRI) {
388   LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
389   if (LCI.Command.Type == macho::LCT_Segment64)
390     return true;
391   assert(LCI.Command.Type == macho::LCT_Segment && "Unexpected Type.");
392   return false;
393 }
394 
395 error_code MachOObjectFile::getSectionName(DataRefImpl DRI,
396                                            StringRef &Result) const {
397   // FIXME: thread safety.
398   static char result[34];
399   if (is64BitLoadCommand(MachOObj, DRI)) {
400     InMemoryStruct<macho::Segment64LoadCommand> SLC;
401     LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
402     MachOObj->ReadSegment64LoadCommand(LCI, SLC);
403     InMemoryStruct<macho::Section64> Sect;
404     MachOObj->ReadSection64(LCI, DRI.d.b, Sect);
405 
406     strcpy(result, Sect->SegmentName);
407     strcat(result, ",");
408     strcat(result, Sect->Name);
409   } else {
410     InMemoryStruct<macho::SegmentLoadCommand> SLC;
411     LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
412     MachOObj->ReadSegmentLoadCommand(LCI, SLC);
413     InMemoryStruct<macho::Section> Sect;
414     MachOObj->ReadSection(LCI, DRI.d.b, Sect);
415 
416     strcpy(result, Sect->SegmentName);
417     strcat(result, ",");
418     strcat(result, Sect->Name);
419   }
420   Result = StringRef(result);
421   return object_error::success;
422 }
423 
424 error_code MachOObjectFile::getSectionAddress(DataRefImpl DRI,
425                                               uint64_t &Result) const {
426   if (is64BitLoadCommand(MachOObj, DRI)) {
427     InMemoryStruct<macho::Section64> Sect;
428     getSection64(DRI, Sect);
429     Result = Sect->Address;
430   } else {
431     InMemoryStruct<macho::Section> Sect;
432     getSection(DRI, Sect);
433     Result = Sect->Address;
434   }
435   return object_error::success;
436 }
437 
438 error_code MachOObjectFile::getSectionSize(DataRefImpl DRI,
439                                            uint64_t &Result) const {
440   if (is64BitLoadCommand(MachOObj, DRI)) {
441     InMemoryStruct<macho::Section64> Sect;
442     getSection64(DRI, Sect);
443     Result = Sect->Size;
444   } else {
445     InMemoryStruct<macho::Section> Sect;
446     getSection(DRI, Sect);
447     Result = Sect->Size;
448   }
449   return object_error::success;
450 }
451 
452 error_code MachOObjectFile::getSectionContents(DataRefImpl DRI,
453                                                StringRef &Result) const {
454   if (is64BitLoadCommand(MachOObj, DRI)) {
455     InMemoryStruct<macho::Section64> Sect;
456     getSection64(DRI, Sect);
457     Result = MachOObj->getData(Sect->Offset, Sect->Size);
458   } else {
459     InMemoryStruct<macho::Section> Sect;
460     getSection(DRI, Sect);
461     Result = MachOObj->getData(Sect->Offset, Sect->Size);
462   }
463   return object_error::success;
464 }
465 
466 error_code MachOObjectFile::getSectionAlignment(DataRefImpl DRI,
467                                                 uint64_t &Result) const {
468   if (is64BitLoadCommand(MachOObj, DRI)) {
469     InMemoryStruct<macho::Section64> Sect;
470     getSection64(DRI, Sect);
471     Result = uint64_t(1) << Sect->Align;
472   } else {
473     InMemoryStruct<macho::Section> Sect;
474     getSection(DRI, Sect);
475     Result = uint64_t(1) << Sect->Align;
476   }
477   return object_error::success;
478 }
479 
480 error_code MachOObjectFile::isSectionText(DataRefImpl DRI,
481                                           bool &Result) const {
482   if (is64BitLoadCommand(MachOObj, DRI)) {
483     InMemoryStruct<macho::Section64> Sect;
484     getSection64(DRI, Sect);
485     Result = !strcmp(Sect->Name, "__text");
486   } else {
487     InMemoryStruct<macho::Section> Sect;
488     getSection(DRI, Sect);
489     Result = !strcmp(Sect->Name, "__text");
490   }
491   return object_error::success;
492 }
493 
494 error_code MachOObjectFile::isSectionData(DataRefImpl DRI,
495                                           bool &Result) const {
496   // FIXME: Unimplemented.
497   Result = false;
498   return object_error::success;
499 }
500 
501 error_code MachOObjectFile::isSectionBSS(DataRefImpl DRI,
502                                          bool &Result) const {
503   // FIXME: Unimplemented.
504   Result = false;
505   return object_error::success;
506 }
507 
508 error_code MachOObjectFile::sectionContainsSymbol(DataRefImpl Sec,
509                                                   DataRefImpl Symb,
510                                                   bool &Result) const {
511   SymbolRef::Type ST;
512   getSymbolType(Symb, ST);
513   if (ST == SymbolRef::ST_External) {
514     Result = false;
515     return object_error::success;
516   }
517 
518   uint64_t SectBegin, SectEnd;
519   getSectionAddress(Sec, SectBegin);
520   getSectionSize(Sec, SectEnd);
521   SectEnd += SectBegin;
522 
523   if (MachOObj->is64Bit()) {
524     InMemoryStruct<macho::Symbol64TableEntry> Entry;
525     getSymbol64TableEntry(Symb, Entry);
526     uint64_t SymAddr= Entry->Value;
527     Result = (SymAddr >= SectBegin) && (SymAddr < SectEnd);
528   } else {
529     InMemoryStruct<macho::SymbolTableEntry> Entry;
530     getSymbolTableEntry(Symb, Entry);
531     uint64_t SymAddr= Entry->Value;
532     Result = (SymAddr >= SectBegin) && (SymAddr < SectEnd);
533   }
534 
535   return object_error::success;
536 }
537 
538 relocation_iterator MachOObjectFile::getSectionRelBegin(DataRefImpl Sec) const {
539   DataRefImpl ret;
540   ret.d.a = 0;
541   ret.d.b = getSectionIndex(Sec);
542   return relocation_iterator(RelocationRef(ret, this));
543 }
544 relocation_iterator MachOObjectFile::getSectionRelEnd(DataRefImpl Sec) const {
545   uint32_t last_reloc;
546   if (is64BitLoadCommand(MachOObj, Sec)) {
547     InMemoryStruct<macho::Section64> Sect;
548     getSection64(Sec, Sect);
549     last_reloc = Sect->NumRelocationTableEntries;
550   } else {
551     InMemoryStruct<macho::Section> Sect;
552     getSection(Sec, Sect);
553     last_reloc = Sect->NumRelocationTableEntries;
554   }
555   DataRefImpl ret;
556   ret.d.a = last_reloc;
557   ret.d.b = getSectionIndex(Sec);
558   return relocation_iterator(RelocationRef(ret, this));
559 }
560 
561 section_iterator MachOObjectFile::begin_sections() const {
562   DataRefImpl DRI;
563   DRI.d.a = DRI.d.b = 0;
564   moveToNextSection(DRI);
565   return section_iterator(SectionRef(DRI, this));
566 }
567 
568 section_iterator MachOObjectFile::end_sections() const {
569   DataRefImpl DRI;
570   DRI.d.a = MachOObj->getHeader().NumLoadCommands;
571   DRI.d.b = 0;
572   return section_iterator(SectionRef(DRI, this));
573 }
574 
575 /*===-- Relocations -------------------------------------------------------===*/
576 
577 void MachOObjectFile::
578 getRelocation(DataRefImpl Rel,
579               InMemoryStruct<macho::RelocationEntry> &Res) const {
580   uint32_t relOffset;
581   if (MachOObj->is64Bit()) {
582     InMemoryStruct<macho::Section64> Sect;
583     getSection64(Sections[Rel.d.b], Sect);
584     relOffset = Sect->RelocationTableOffset;
585   } else {
586     InMemoryStruct<macho::Section> Sect;
587     getSection(Sections[Rel.d.b], Sect);
588     relOffset = Sect->RelocationTableOffset;
589   }
590   MachOObj->ReadRelocationEntry(relOffset, Rel.d.a, Res);
591 }
592 error_code MachOObjectFile::getRelocationNext(DataRefImpl Rel,
593                                               RelocationRef &Res) const {
594   ++Rel.d.a;
595   Res = RelocationRef(Rel, this);
596   return object_error::success;
597 }
598 error_code MachOObjectFile::getRelocationAddress(DataRefImpl Rel,
599                                                  uint64_t &Res) const {
600   const uint8_t* sectAddress = 0;
601   if (MachOObj->is64Bit()) {
602     InMemoryStruct<macho::Section64> Sect;
603     getSection64(Sections[Rel.d.b], Sect);
604     sectAddress += Sect->Address;
605   } else {
606     InMemoryStruct<macho::Section> Sect;
607     getSection(Sections[Rel.d.b], Sect);
608     sectAddress += Sect->Address;
609   }
610   InMemoryStruct<macho::RelocationEntry> RE;
611   getRelocation(Rel, RE);
612 
613   unsigned Arch = getArch();
614   bool isScattered = (Arch != Triple::x86_64) &&
615                      (RE->Word0 & macho::RF_Scattered);
616   uint64_t RelAddr = 0;
617   if (isScattered)
618     RelAddr = RE->Word0 & 0xFFFFFF;
619   else
620     RelAddr = RE->Word0;
621 
622   Res = reinterpret_cast<uintptr_t>(sectAddress + RelAddr);
623   return object_error::success;
624 }
625 error_code MachOObjectFile::getRelocationSymbol(DataRefImpl Rel,
626                                                 SymbolRef &Res) const {
627   InMemoryStruct<macho::RelocationEntry> RE;
628   getRelocation(Rel, RE);
629   uint32_t SymbolIdx = RE->Word1 & 0xffffff;
630   bool isExtern = (RE->Word1 >> 27) & 1;
631 
632   DataRefImpl Sym;
633   Sym.d.a = Sym.d.b = 0;
634   moveToNextSymbol(Sym);
635   if (isExtern) {
636     for (unsigned i = 0; i < SymbolIdx; i++) {
637       Sym.d.b++;
638       moveToNextSymbol(Sym);
639       assert(Sym.d.a < MachOObj->getHeader().NumLoadCommands &&
640              "Relocation symbol index out of range!");
641     }
642   }
643   Res = SymbolRef(Sym, this);
644   return object_error::success;
645 }
646 error_code MachOObjectFile::getRelocationType(DataRefImpl Rel,
647                                               uint64_t &Res) const {
648   InMemoryStruct<macho::RelocationEntry> RE;
649   getRelocation(Rel, RE);
650   Res = RE->Word0;
651   Res <<= 32;
652   Res |= RE->Word1;
653   return object_error::success;
654 }
655 error_code MachOObjectFile::getRelocationTypeName(DataRefImpl Rel,
656                                           SmallVectorImpl<char> &Result) const {
657   // TODO: Support scattered relocations.
658   StringRef res;
659   InMemoryStruct<macho::RelocationEntry> RE;
660   getRelocation(Rel, RE);
661 
662   unsigned Arch = getArch();
663   bool isScattered = (Arch != Triple::x86_64) &&
664                      (RE->Word0 & macho::RF_Scattered);
665 
666   unsigned r_type;
667   if (isScattered)
668     r_type = (RE->Word0 >> 24) & 0xF;
669   else
670     r_type = (RE->Word1 >> 28) & 0xF;
671 
672   switch (Arch) {
673     case Triple::x86: {
674       const char* Table[] =  {
675         "GENERIC_RELOC_VANILLA",
676         "GENERIC_RELOC_PAIR",
677         "GENERIC_RELOC_SECTDIFF",
678         "GENERIC_RELOC_LOCAL_SECTDIFF",
679         "GENERIC_RELOC_PB_LA_PTR" };
680 
681       if (r_type > 4)
682         res = "Unknown";
683       else
684         res = Table[r_type];
685       break;
686     }
687     case Triple::x86_64: {
688       const char* Table[] =  {
689         "X86_64_RELOC_UNSIGNED",
690         "X86_64_RELOC_SIGNED",
691         "X86_64_RELOC_BRANCH",
692         "X86_64_RELOC_GOT_LOAD",
693         "X86_64_RELOC_GOT",
694         "X86_64_RELOC_SUBTRACTOR",
695         "X86_64_RELOC_SIGNED_1",
696         "X86_64_RELOC_SIGNED_2",
697         "X86_64_RELOC_SIGNED_4",
698         "X86_64_RELOC_TLV" };
699 
700       if (r_type > 9)
701         res = "Unknown";
702       else
703         res = Table[r_type];
704       break;
705     }
706     case Triple::arm: {
707       const char* Table[] =  {
708         "ARM_RELOC_VANILLA",
709         "ARM_RELOC_PAIR",
710         "ARM_RELOC_SECTDIFF",
711         "ARM_RELOC_LOCAL_SECTDIFF",
712         "ARM_RELOC_PB_LA_PTR",
713         "ARM_RELOC_BR24",
714         "ARM_THUMB_RELOC_BR22",
715         "ARM_THUMB_32BIT_BRANCH",
716         "ARM_RELOC_HALF",
717         "ARM_RELOC_HALF_SECTDIFF" };
718 
719       if (r_type > 9)
720         res = "Unknown";
721       else
722         res = Table[r_type];
723       break;
724     }
725     case Triple::ppc: {
726       const char* Table[] =  {
727         "PPC_RELOC_VANILLA",
728         "PPC_RELOC_PAIR",
729         "PPC_RELOC_BR14",
730         "PPC_RELOC_BR24",
731         "PPC_RELOC_HI16",
732         "PPC_RELOC_LO16",
733         "PPC_RELOC_HA16",
734         "PPC_RELOC_LO14",
735         "PPC_RELOC_SECTDIFF",
736         "PPC_RELOC_PB_LA_PTR",
737         "PPC_RELOC_HI16_SECTDIFF",
738         "PPC_RELOC_LO16_SECTDIFF",
739         "PPC_RELOC_HA16_SECTDIFF",
740         "PPC_RELOC_JBSR",
741         "PPC_RELOC_LO14_SECTDIFF",
742         "PPC_RELOC_LOCAL_SECTDIFF" };
743 
744       res = Table[r_type];
745       break;
746     }
747     case Triple::UnknownArch:
748       res = "Unknown";
749       break;
750   }
751   Result.append(res.begin(), res.end());
752   return object_error::success;
753 }
754 error_code MachOObjectFile::getRelocationAdditionalInfo(DataRefImpl Rel,
755                                                         int64_t &Res) const {
756   InMemoryStruct<macho::RelocationEntry> RE;
757   getRelocation(Rel, RE);
758   bool isExtern = (RE->Word1 >> 27) & 1;
759   Res = 0;
760   if (!isExtern) {
761     const uint8_t* sectAddress = base();
762     if (MachOObj->is64Bit()) {
763       InMemoryStruct<macho::Section64> Sect;
764       getSection64(Sections[Rel.d.b], Sect);
765       sectAddress += Sect->Offset;
766     } else {
767       InMemoryStruct<macho::Section> Sect;
768       getSection(Sections[Rel.d.b], Sect);
769       sectAddress += Sect->Offset;
770     }
771     Res = reinterpret_cast<uintptr_t>(sectAddress);
772   }
773   return object_error::success;
774 }
775 
776 // Helper to advance a section or symbol iterator multiple increments at a time.
777 template<class T>
778 error_code advance(T &it, size_t Val) {
779   error_code ec;
780   while (Val--) {
781     it.increment(ec);
782   }
783   return ec;
784 }
785 
786 template<class T>
787 void advanceTo(T &it, size_t Val) {
788   if (error_code ec = advance(it, Val))
789     report_fatal_error(ec.message());
790 }
791 
792 void MachOObjectFile::printRelocationTargetName(
793                                      InMemoryStruct<macho::RelocationEntry>& RE,
794                                      raw_string_ostream &fmt) const {
795   unsigned Arch = getArch();
796   bool isScattered = (Arch != Triple::x86_64) &&
797                      (RE->Word0 & macho::RF_Scattered);
798 
799   // Target of a scattered relocation is an address.  In the interest of
800   // generating pretty output, scan through the symbol table looking for a
801   // symbol that aligns with that address.  If we find one, print it.
802   // Otherwise, we just print the hex address of the target.
803   if (isScattered) {
804     uint32_t Val = RE->Word1;
805 
806     error_code ec;
807     for (symbol_iterator SI = begin_symbols(), SE = end_symbols(); SI != SE;
808         SI.increment(ec)) {
809       if (ec) report_fatal_error(ec.message());
810 
811       uint64_t Addr;
812       StringRef Name;
813 
814       if ((ec = SI->getAddress(Addr)))
815         report_fatal_error(ec.message());
816       if (Addr != Val) continue;
817       if ((ec = SI->getName(Name)))
818         report_fatal_error(ec.message());
819       fmt << Name;
820       return;
821     }
822 
823     fmt << format("0x%x", Val);
824     return;
825   }
826 
827   StringRef S;
828   bool isExtern = (RE->Word1 >> 27) & 1;
829   uint32_t Val = RE->Word1 & 0xFFFFFF;
830 
831   if (isExtern) {
832     symbol_iterator SI = begin_symbols();
833     advanceTo(SI, Val);
834     SI->getName(S);
835   } else {
836     section_iterator SI = begin_sections();
837     advanceTo(SI, Val);
838     SI->getName(S);
839   }
840 
841   fmt << S;
842 }
843 
844 error_code MachOObjectFile::getRelocationValueString(DataRefImpl Rel,
845                                           SmallVectorImpl<char> &Result) const {
846   InMemoryStruct<macho::RelocationEntry> RE;
847   getRelocation(Rel, RE);
848 
849   unsigned Arch = getArch();
850   bool isScattered = (Arch != Triple::x86_64) &&
851                      (RE->Word0 & macho::RF_Scattered);
852 
853   std::string fmtbuf;
854   raw_string_ostream fmt(fmtbuf);
855 
856   unsigned Type;
857   if (isScattered)
858     Type = (RE->Word0 >> 24) & 0xF;
859   else
860     Type = (RE->Word1 >> 28) & 0xF;
861 
862   // Determine any addends that should be displayed with the relocation.
863   // These require decoding the relocation type, which is triple-specific.
864 
865   // X86_64 has entirely custom relocation types.
866   if (Arch == Triple::x86_64) {
867     bool isPCRel = ((RE->Word1 >> 24) & 1);
868 
869     switch (Type) {
870       case macho::RIT_X86_64_GOTLoad:   // X86_64_RELOC_GOT_LOAD
871       case macho::RIT_X86_64_GOT: {     // X86_64_RELOC_GOT
872         printRelocationTargetName(RE, fmt);
873         fmt << "@GOT";
874         if (isPCRel) fmt << "PCREL";
875         break;
876       }
877       case macho::RIT_X86_64_Subtractor: { // X86_64_RELOC_SUBTRACTOR
878         InMemoryStruct<macho::RelocationEntry> RENext;
879         DataRefImpl RelNext = Rel;
880         RelNext.d.a++;
881         getRelocation(RelNext, RENext);
882 
883         // X86_64_SUBTRACTOR must be followed by a relocation of type
884         // X86_64_RELOC_UNSIGNED.
885         // NOTE: Scattered relocations don't exist on x86_64.
886         unsigned RType = (RENext->Word1 >> 28) & 0xF;
887         if (RType != 0)
888           report_fatal_error("Expected X86_64_RELOC_UNSIGNED after "
889                              "X86_64_RELOC_SUBTRACTOR.");
890 
891         // The X86_64_RELOC_UNSIGNED contains the minuend symbol,
892         // X86_64_SUBTRACTOR contains to the subtrahend.
893         printRelocationTargetName(RENext, fmt);
894         fmt << "-";
895         printRelocationTargetName(RE, fmt);
896       }
897       case macho::RIT_X86_64_Signed1: // X86_64_RELOC_SIGNED1
898         printRelocationTargetName(RE, fmt);
899         fmt << "-1";
900         break;
901       case macho::RIT_X86_64_Signed2: // X86_64_RELOC_SIGNED2
902         printRelocationTargetName(RE, fmt);
903         fmt << "-2";
904         break;
905       case macho::RIT_X86_64_Signed4: // X86_64_RELOC_SIGNED4
906         printRelocationTargetName(RE, fmt);
907         fmt << "-4";
908         break;
909       default:
910         printRelocationTargetName(RE, fmt);
911         break;
912     }
913   // X86 and ARM share some relocation types in common.
914   } else if (Arch == Triple::x86 || Arch == Triple::arm) {
915     // Generic relocation types...
916     switch (Type) {
917       case macho::RIT_Pair: // GENERIC_RELOC_PAIR - prints no info
918         return object_error::success;
919       case macho::RIT_Difference:                // GENERIC_RELOC_SECTDIFF
920       case macho::RIT_Generic_LocalDifference: { // GENERIC_RELOC_LOCAL_SECTDIFF
921         InMemoryStruct<macho::RelocationEntry> RENext;
922         DataRefImpl RelNext = Rel;
923         RelNext.d.a++;
924         getRelocation(RelNext, RENext);
925 
926         // X86 sect diff's must be followed by a relocation of type
927         // GENERIC_RELOC_PAIR.
928         bool isNextScattered = (Arch != Triple::x86_64) &&
929                                (RENext->Word0 & macho::RF_Scattered);
930         unsigned RType;
931         if (isNextScattered)
932           RType = (RENext->Word0 >> 24) & 0xF;
933         else
934           RType = (RENext->Word1 >> 28) & 0xF;
935         if (RType != 1)
936           report_fatal_error("Expected GENERIC_RELOC_PAIR after "
937                              "GENERIC_RELOC_SECTDIFF or "
938                              "GENERIC_RELOC_LOCAL_SECTDIFF.");
939 
940         printRelocationTargetName(RE, fmt);
941         fmt << "-";
942         printRelocationTargetName(RENext, fmt);
943         break;
944       }
945     }
946 
947     if (Arch == Triple::x86) {
948       // All X86 relocations that need special printing were already
949       // handled in the generic code.
950       printRelocationTargetName(RE, fmt);
951     } else { // ARM-specific relocations
952       switch (Type) {
953         case macho::RIT_ARM_Half:             // ARM_RELOC_HALF
954         case macho::RIT_ARM_HalfDifference: { // ARM_RELOC_HALF_SECTDIFF
955           // Half relocations steal a bit from the length field to encode
956           // whether this is an upper16 or a lower16 relocation.
957           bool isUpper;
958           if (isScattered)
959             isUpper = (RE->Word0 >> 28) & 1;
960           else
961             isUpper = (RE->Word1 >> 25) & 1;
962 
963           if (isUpper)
964             fmt << ":upper16:(";
965           else
966             fmt << ":lower16:(";
967           printRelocationTargetName(RE, fmt);
968 
969           InMemoryStruct<macho::RelocationEntry> RENext;
970           DataRefImpl RelNext = Rel;
971           RelNext.d.a++;
972           getRelocation(RelNext, RENext);
973 
974           // ARM half relocs must be followed by a relocation of type
975           // ARM_RELOC_PAIR.
976           bool isNextScattered = (Arch != Triple::x86_64) &&
977                                  (RENext->Word0 & macho::RF_Scattered);
978           unsigned RType;
979           if (isNextScattered)
980             RType = (RENext->Word0 >> 24) & 0xF;
981           else
982             RType = (RENext->Word1 >> 28) & 0xF;
983 
984           if (RType != 1)
985             report_fatal_error("Expected ARM_RELOC_PAIR after "
986                                "GENERIC_RELOC_HALF");
987 
988           // NOTE: The half of the target virtual address is stashed in the
989           // address field of the secondary relocation, but we can't reverse
990           // engineer the constant offset from it without decoding the movw/movt
991           // instruction to find the other half in its immediate field.
992 
993           // ARM_RELOC_HALF_SECTDIFF encodes the second section in the
994           // symbol/section pointer of the follow-on relocation.
995           if (Type == macho::RIT_ARM_HalfDifference) {
996             fmt << "-";
997             printRelocationTargetName(RENext, fmt);
998           }
999 
1000           fmt << ")";
1001           break;
1002         }
1003         default: {
1004           printRelocationTargetName(RE, fmt);
1005         }
1006       }
1007     }
1008   } else
1009     printRelocationTargetName(RE, fmt);
1010 
1011   fmt.flush();
1012   Result.append(fmtbuf.begin(), fmtbuf.end());
1013   return object_error::success;
1014 }
1015 
1016 error_code MachOObjectFile::getRelocationHidden(DataRefImpl Rel,
1017                                                 bool &Result) const {
1018   InMemoryStruct<macho::RelocationEntry> RE;
1019   getRelocation(Rel, RE);
1020 
1021   unsigned Arch = getArch();
1022   bool isScattered = (Arch != Triple::x86_64) &&
1023                      (RE->Word0 & macho::RF_Scattered);
1024   unsigned Type;
1025   if (isScattered)
1026     Type = (RE->Word0 >> 24) & 0xF;
1027   else
1028     Type = (RE->Word1 >> 28) & 0xF;
1029 
1030   Result = false;
1031 
1032   // On arches that use the generic relocations, GENERIC_RELOC_PAIR
1033   // is always hidden.
1034   if (Arch == Triple::x86 || Arch == Triple::arm) {
1035     if (Type == macho::RIT_Pair) Result = true;
1036   } else if (Arch == Triple::x86_64) {
1037     // On x86_64, X86_64_RELOC_UNSIGNED is hidden only when it follows
1038     // an X864_64_RELOC_SUBTRACTOR.
1039     if (Type == macho::RIT_X86_64_Unsigned && Rel.d.a > 0) {
1040       DataRefImpl RelPrev = Rel;
1041       RelPrev.d.a--;
1042       InMemoryStruct<macho::RelocationEntry> REPrev;
1043       getRelocation(RelPrev, REPrev);
1044 
1045       unsigned PrevType = (REPrev->Word1 >> 28) & 0xF;
1046 
1047       if (PrevType == macho::RIT_X86_64_Subtractor) Result = true;
1048     }
1049   }
1050 
1051   return object_error::success;
1052 }
1053 
1054 /*===-- Miscellaneous -----------------------------------------------------===*/
1055 
1056 uint8_t MachOObjectFile::getBytesInAddress() const {
1057   return MachOObj->is64Bit() ? 8 : 4;
1058 }
1059 
1060 StringRef MachOObjectFile::getFileFormatName() const {
1061   if (!MachOObj->is64Bit()) {
1062     switch (MachOObj->getHeader().CPUType) {
1063     case llvm::MachO::CPUTypeI386:
1064       return "Mach-O 32-bit i386";
1065     case llvm::MachO::CPUTypeARM:
1066       return "Mach-O arm";
1067     case llvm::MachO::CPUTypePowerPC:
1068       return "Mach-O 32-bit ppc";
1069     default:
1070       assert((MachOObj->getHeader().CPUType & llvm::MachO::CPUArchABI64) == 0 &&
1071              "64-bit object file when we're not 64-bit?");
1072       return "Mach-O 32-bit unknown";
1073     }
1074   }
1075 
1076   switch (MachOObj->getHeader().CPUType) {
1077   case llvm::MachO::CPUTypeX86_64:
1078     return "Mach-O 64-bit x86-64";
1079   case llvm::MachO::CPUTypePowerPC64:
1080     return "Mach-O 64-bit ppc64";
1081   default:
1082     assert((MachOObj->getHeader().CPUType & llvm::MachO::CPUArchABI64) == 1 &&
1083            "32-bit object file when we're 64-bit?");
1084     return "Mach-O 64-bit unknown";
1085   }
1086 }
1087 
1088 unsigned MachOObjectFile::getArch() const {
1089   switch (MachOObj->getHeader().CPUType) {
1090   case llvm::MachO::CPUTypeI386:
1091     return Triple::x86;
1092   case llvm::MachO::CPUTypeX86_64:
1093     return Triple::x86_64;
1094   case llvm::MachO::CPUTypeARM:
1095     return Triple::arm;
1096   case llvm::MachO::CPUTypePowerPC:
1097     return Triple::ppc;
1098   case llvm::MachO::CPUTypePowerPC64:
1099     return Triple::ppc64;
1100   default:
1101     return Triple::UnknownArch;
1102   }
1103 }
1104 
1105 } // end namespace object
1106 } // end namespace llvm
1107