xref: /llvm-project/llvm/lib/Object/MachOObjectFile.cpp (revision 90c49c037e3334c9a1545e13377ca228a9d80bbb) 
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/MemoryBuffer.h"
19 #include "llvm/Support/raw_ostream.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   Res = reinterpret_cast<uintptr_t>(sectAddress + RE->Word0);
613   return object_error::success;
614 }
615 error_code MachOObjectFile::getRelocationSymbol(DataRefImpl Rel,
616                                                 SymbolRef &Res) const {
617   InMemoryStruct<macho::RelocationEntry> RE;
618   getRelocation(Rel, RE);
619   uint32_t SymbolIdx = RE->Word1 & 0xffffff;
620   bool isExtern = (RE->Word1 >> 27) & 1;
621 
622   DataRefImpl Sym;
623   Sym.d.a = Sym.d.b = 0;
624   moveToNextSymbol(Sym);
625   if (isExtern) {
626     for (unsigned i = 0; i < SymbolIdx; i++) {
627       Sym.d.b++;
628       moveToNextSymbol(Sym);
629       assert(Sym.d.a < MachOObj->getHeader().NumLoadCommands &&
630              "Relocation symbol index out of range!");
631     }
632   }
633   Res = SymbolRef(Sym, this);
634   return object_error::success;
635 }
636 error_code MachOObjectFile::getRelocationType(DataRefImpl Rel,
637                                               uint64_t &Res) const {
638   InMemoryStruct<macho::RelocationEntry> RE;
639   getRelocation(Rel, RE);
640   Res = RE->Word0;
641   Res <<= 32;
642   Res |= RE->Word1;
643   return object_error::success;
644 }
645 error_code MachOObjectFile::getRelocationTypeName(DataRefImpl Rel,
646                                           SmallVectorImpl<char> &Result) const {
647   // TODO: Support scattered relocations.
648   StringRef res;
649   InMemoryStruct<macho::RelocationEntry> RE;
650   getRelocation(Rel, RE);
651   unsigned r_type = (RE->Word1 >> 28) & 0xF;
652 
653   unsigned Arch = getArch();
654   switch (Arch) {
655     case Triple::x86: {
656       const char* Table[] =  {
657         "GENERIC_RELOC_VANILLA",
658         "GENERIC_RELOC_PAIR",
659         "GENERIC_RELOC_SECTDIFF",
660         "GENERIC_RELOC_LOCAL_SECTDIFF",
661         "GENERIC_RELOC_PB_LA_PTR" };
662 
663       if (r_type > 4)
664         res = "Unknown";
665       else
666         res = Table[r_type];
667       break;
668     }
669     case Triple::x86_64: {
670       const char* Table[] =  {
671         "X86_64_RELOC_UNSIGNED",
672         "X86_64_RELOC_SIGNED",
673         "X86_64_RELOC_BRANCH",
674         "X86_64_RELOC_GOT_LOAD",
675         "X86_64_RELOC_GOT",
676         "X86_64_RELOC_SUBTRACTOR",
677         "X86_64_RELOC_SIGNED_1",
678         "X86_64_RELOC_SIGNED_2",
679         "X86_64_RELOC_SIGNED_4",
680         "X86_64_RELOC_TLV" };
681 
682       if (r_type > 9)
683         res = "Unknown";
684       else
685         res = Table[r_type];
686       break;
687     }
688     case Triple::arm: {
689       const char* Table[] =  {
690         "ARM_RELOC_VANILLA",
691         "ARM_RELOC_PAIR",
692         "ARM_RELOC_SECTDIFF",
693         "ARM_RELOC_LOCAL_SECTDIFF",
694         "ARM_RELOC_PB_LA_PTR",
695         "ARM_RELOC_BR24",
696         "ARM_THUMB_RELOC_BR22",
697         "ARM_THUMB_32BIT_BRANCH",
698         "ARM_RELOC_HALF",
699         "ARM_RELOC_HALF_SECTDIFF" };
700 
701       if (r_type > 9)
702         res = "Unknown";
703       else
704         res = Table[r_type];
705       break;
706     }
707     case Triple::ppc: {
708       const char* Table[] =  {
709         "PPC_RELOC_VANILLA",
710         "PPC_RELOC_PAIR",
711         "PPC_RELOC_BR14",
712         "PPC_RELOC_BR24",
713         "PPC_RELOC_HI16",
714         "PPC_RELOC_LO16",
715         "PPC_RELOC_HA16",
716         "PPC_RELOC_LO14",
717         "PPC_RELOC_SECTDIFF",
718         "PPC_RELOC_PB_LA_PTR",
719         "PPC_RELOC_HI16_SECTDIFF",
720         "PPC_RELOC_LO16_SECTDIFF",
721         "PPC_RELOC_HA16_SECTDIFF",
722         "PPC_RELOC_JBSR",
723         "PPC_RELOC_LO14_SECTDIFF",
724         "PPC_RELOC_LOCAL_SECTDIFF" };
725 
726       res = Table[r_type];
727       break;
728     }
729     case Triple::UnknownArch:
730       res = "Unknown";
731       break;
732   }
733   Result.append(res.begin(), res.end());
734   return object_error::success;
735 }
736 error_code MachOObjectFile::getRelocationAdditionalInfo(DataRefImpl Rel,
737                                                         int64_t &Res) const {
738   InMemoryStruct<macho::RelocationEntry> RE;
739   getRelocation(Rel, RE);
740   bool isExtern = (RE->Word1 >> 27) & 1;
741   Res = 0;
742   if (!isExtern) {
743     const uint8_t* sectAddress = base();
744     if (MachOObj->is64Bit()) {
745       InMemoryStruct<macho::Section64> Sect;
746       getSection64(Sections[Rel.d.b], Sect);
747       sectAddress += Sect->Offset;
748     } else {
749       InMemoryStruct<macho::Section> Sect;
750       getSection(Sections[Rel.d.b], Sect);
751       sectAddress += Sect->Offset;
752     }
753     Res = reinterpret_cast<uintptr_t>(sectAddress);
754   }
755   return object_error::success;
756 }
757 
758 // Helper to advance a section or symbol iterator multiple increments at a time.
759 template<class T>
760 error_code advance(T &it, size_t Val) {
761   error_code ec;
762   while (Val--) {
763     it.increment(ec);
764   }
765   return ec;
766 }
767 
768 template<class T>
769 void advanceTo(T &it, size_t Val) {
770   if (error_code ec = advance(it, Val))
771     report_fatal_error(ec.message());
772 }
773 
774 error_code
775 MachOObjectFile::getRelocationTargetName(uint32_t Idx, StringRef &S) const {
776   bool isExtern = (Idx >> 27) & 1;
777   uint32_t Val = Idx & 0xFFFFFF;
778   error_code ec;
779 
780   if (isExtern) {
781     symbol_iterator SI = begin_symbols();
782     advanceTo(SI, Val);
783     ec = SI->getName(S);
784   } else {
785     section_iterator SI = begin_sections();
786     advanceTo(SI, Val);
787     ec = SI->getName(S);
788   }
789 
790   return ec;
791 }
792 
793 error_code MachOObjectFile::getRelocationValueString(DataRefImpl Rel,
794                                           SmallVectorImpl<char> &Result) const {
795   InMemoryStruct<macho::RelocationEntry> RE;
796   getRelocation(Rel, RE);
797 
798   unsigned Type = (RE->Word1 >> 28) & 0xF;
799 
800   std::string fmtbuf;
801   raw_string_ostream fmt(fmtbuf);
802 
803   // Determine any addends that should be displayed with the relocation.
804   // These require decoding the relocation type, which is triple-specific.
805   unsigned Arch = getArch();
806 
807   // X86_64 has entirely custom relocation types.
808   if (Arch == Triple::x86_64) {
809     StringRef Name;
810     if (error_code ec = getRelocationTargetName(RE->Word1, Name))
811       report_fatal_error(ec.message());
812     bool isPCRel = ((RE->Word1 >> 24) & 1);
813 
814     switch (Type) {
815       case 3:   // X86_64_RELOC_GOT_LOAD
816       case 4: { // X86_64_RELOC_GOT
817         fmt << Name << "@GOT";
818         if (isPCRel) fmt << "PCREL";
819         break;
820       }
821       case 5: { // X86_64_RELOC_SUBTRACTOR
822         InMemoryStruct<macho::RelocationEntry> RENext;
823         DataRefImpl RelNext = Rel;
824         RelNext.d.a++;
825         getRelocation(RelNext, RENext);
826 
827         // X86_64_SUBTRACTOR must be followed by a relocation of type
828         // X86_64_RELOC_UNSIGNED.
829         unsigned RType = (RENext->Word1 >> 28) & 0xF;
830         if (RType != 0)
831           report_fatal_error("Expected X86_64_RELOC_UNSIGNED after "
832                              "X86_64_RELOC_SUBTRACTOR.");
833 
834         StringRef SucName;
835         if (error_code ec = getRelocationTargetName(RENext->Word1, SucName))
836           report_fatal_error(ec.message());
837 
838         // The X86_64_RELOC_UNSIGNED contains the minuend symbol,
839         // X86_64_SUBTRACTOR contains to the subtrahend.
840         fmt << SucName << "-" << Name;
841       }
842       case 6: // X86_64_RELOC_SIGNED1
843         fmt << Name << "-1";
844         break;
845       case 7: // X86_64_RELOC_SIGNED2
846         fmt << Name << "-2";
847         break;
848       case 8: // X86_64_RELOC_SIGNED4
849         fmt << Name << "-4";
850         break;
851       default:
852         fmt << Name;
853         break;
854     }
855   // X86 and ARM share some relocation types in common.
856   } else if (Arch == Triple::x86 || Arch == Triple::arm) {
857     // Generic relocation types...
858     switch (Type) {
859       case 1: // GENERIC_RELOC_PAIR - prints no info
860         return object_error::success;
861       case 2:   // GENERIC_RELOC_SECTDIFF
862       case 4: { // GENERIC_RELOC_LOCAL_SECTDIFF
863         InMemoryStruct<macho::RelocationEntry> RENext;
864         DataRefImpl RelNext = Rel;
865         RelNext.d.a++;
866         getRelocation(RelNext, RENext);
867 
868         // X86 sect diff's must be followed by a relocation of type
869         // GENERIC_RELOC_PAIR.
870         unsigned RType = (RENext->Word1 >> 28) & 0xF;
871         if (RType != 1)
872           report_fatal_error("Expected GENERIC_RELOC_PAIR after "
873                              "GENERIC_RELOC_SECTDIFF or "
874                              "GENERIC_RELOC_LOCAL_SECTDIFF.");
875 
876         StringRef SucName;
877         if (error_code ec = getRelocationTargetName(RENext->Word1, SucName))
878           report_fatal_error(ec.message());
879 
880         StringRef Name;
881         if (error_code ec = getRelocationTargetName(RE->Word1, Name))
882           report_fatal_error(ec.message());
883 
884         fmt << Name << "-" << SucName;
885         break;
886       }
887     }
888 
889     if (Arch == Triple::x86 && Type != 1) {
890       // All X86 relocations that need special printing were already
891       // handled in the generic code.
892       StringRef Name;
893       if (error_code ec = getRelocationTargetName(RE->Word1, Name))
894         report_fatal_error(ec.message());
895       fmt << Name;
896     } else { // ARM-specific relocations
897       switch (Type) {
898         case 8:   // ARM_RELOC_HALF
899         case 9: { // ARM_RELOC_HALF_SECTDIFF
900           StringRef Name;
901           if (error_code ec = getRelocationTargetName(RE->Word1, Name))
902             report_fatal_error(ec.message());
903 
904           // Half relocations steal a bit from the length field to encode
905           // whether this is an upper16 or a lower16 relocation.
906           bool isUpper = (RE->Word1 >> 25) & 1;
907           if (isUpper)
908             fmt << ":upper16:(" << Name;
909           else
910             fmt << ":lower16:(" << Name;
911 
912           InMemoryStruct<macho::RelocationEntry> RENext;
913           DataRefImpl RelNext = Rel;
914           RelNext.d.a++;
915           getRelocation(RelNext, RENext);
916 
917           // ARM half relocs must be followed by a relocation of type
918           // ARM_RELOC_PAIR.
919           unsigned RType = (RENext->Word1 >> 28) & 0xF;
920           if (RType != 1)
921             report_fatal_error("Expected ARM_RELOC_PAIR after "
922                                "GENERIC_RELOC_HALF");
923 
924           // A constant addend for the relocation is stored in the address
925           // field of the follow-on relocation.  If this is a lower16 relocation
926           // we need to shift it left by 16 before using it.
927           int32_t Addend = RENext->Word0;
928           if (!isUpper) Addend <<= 16;
929 
930           // ARM_RELOC_HALF_SECTDIFF encodes the second section in the
931           // symbol/section pointer of the follow-on relocation.
932           StringRef SucName;
933           if (Type == 9) { // ARM_RELOC_HALF_SECTDIFF
934             if (error_code ec = getRelocationTargetName(RENext->Word1, SucName))
935               report_fatal_error(ec.message());
936           }
937 
938           if (SucName.size()) fmt << "-" << SucName;
939           if (Addend > 0) fmt << "+" << Addend;
940           else if (Addend < 0) fmt << Addend;
941           fmt << ")";
942           break;
943         }
944         default: {
945           StringRef Name;
946           if (error_code ec = getRelocationTargetName(RE->Word1, Name))
947             report_fatal_error(ec.message());
948           fmt << Name;
949         }
950       }
951     }
952   } else {
953     StringRef Name;
954     if (error_code ec = getRelocationTargetName(RE->Word1, Name))
955       report_fatal_error(ec.message());
956     fmt << Name;
957   }
958 
959   fmt.flush();
960   Result.append(fmtbuf.begin(), fmtbuf.end());
961   return object_error::success;
962 }
963 
964 error_code MachOObjectFile::getRelocationHidden(DataRefImpl Rel,
965                                                 bool &Result) const {
966   InMemoryStruct<macho::RelocationEntry> RE;
967   getRelocation(Rel, RE);
968 
969   unsigned Type = (RE->Word1 >> 28) & 0xF;
970   unsigned Arch = getArch();
971 
972   Result = false;
973 
974   // On arches that use the generic relocations, GENERIC_RELOC_PAIR
975   // is always hidden.
976   if (Arch == Triple::x86 || Arch == Triple::arm) {
977     if (Type == 1) Result = true;
978   } else if (Arch == Triple::x86_64) {
979     // On x86_64, X86_64_RELOC_UNSIGNED is hidden only when it follows
980     // an X864_64_RELOC_SUBTRACTOR.
981     if (Type == 0 && Rel.d.a > 0) {
982       DataRefImpl RelPrev = Rel;
983       RelPrev.d.a--;
984       InMemoryStruct<macho::RelocationEntry> REPrev;
985       getRelocation(RelPrev, REPrev);
986 
987       unsigned PrevType = (REPrev->Word1 >> 28) & 0xF;
988 
989       if (PrevType == 5) Result = true;
990     }
991   }
992 
993   return object_error::success;
994 }
995 
996 /*===-- Miscellaneous -----------------------------------------------------===*/
997 
998 uint8_t MachOObjectFile::getBytesInAddress() const {
999   return MachOObj->is64Bit() ? 8 : 4;
1000 }
1001 
1002 StringRef MachOObjectFile::getFileFormatName() const {
1003   if (!MachOObj->is64Bit()) {
1004     switch (MachOObj->getHeader().CPUType) {
1005     case llvm::MachO::CPUTypeI386:
1006       return "Mach-O 32-bit i386";
1007     case llvm::MachO::CPUTypeARM:
1008       return "Mach-O arm";
1009     case llvm::MachO::CPUTypePowerPC:
1010       return "Mach-O 32-bit ppc";
1011     default:
1012       assert((MachOObj->getHeader().CPUType & llvm::MachO::CPUArchABI64) == 0 &&
1013              "64-bit object file when we're not 64-bit?");
1014       return "Mach-O 32-bit unknown";
1015     }
1016   }
1017 
1018   switch (MachOObj->getHeader().CPUType) {
1019   case llvm::MachO::CPUTypeX86_64:
1020     return "Mach-O 64-bit x86-64";
1021   case llvm::MachO::CPUTypePowerPC64:
1022     return "Mach-O 64-bit ppc64";
1023   default:
1024     assert((MachOObj->getHeader().CPUType & llvm::MachO::CPUArchABI64) == 1 &&
1025            "32-bit object file when we're 64-bit?");
1026     return "Mach-O 64-bit unknown";
1027   }
1028 }
1029 
1030 unsigned MachOObjectFile::getArch() const {
1031   switch (MachOObj->getHeader().CPUType) {
1032   case llvm::MachO::CPUTypeI386:
1033     return Triple::x86;
1034   case llvm::MachO::CPUTypeX86_64:
1035     return Triple::x86_64;
1036   case llvm::MachO::CPUTypeARM:
1037     return Triple::arm;
1038   case llvm::MachO::CPUTypePowerPC:
1039     return Triple::ppc;
1040   case llvm::MachO::CPUTypePowerPC64:
1041     return Triple::ppc64;
1042   default:
1043     return Triple::UnknownArch;
1044   }
1045 }
1046 
1047 } // end namespace object
1048 } // end namespace llvm
1049