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