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