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