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