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