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