xref: /llvm-project/llvm/lib/Object/MachOObjectFile.cpp (revision 75d1cf339110b14c4ddf1253b687044a200caf13) 
1 //===- MachOObjectFile.cpp - Mach-O object file binding ---------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the MachOObjectFile class, which binds the MachOObject
11 // class to the generic ObjectFile wrapper.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/ADT/Triple.h"
16 #include "llvm/Object/MachOFormat.h"
17 #include "llvm/Object/MachOObject.h"
18 #include "llvm/Object/ObjectFile.h"
19 #include "llvm/Support/MemoryBuffer.h"
20 #include "llvm/Support/MachO.h"
21 #include "llvm/ADT/SmallVector.h"
22 
23 #include <cctype>
24 #include <cstring>
25 #include <limits>
26 
27 using namespace llvm;
28 using namespace object;
29 
30 namespace llvm {
31 
32 typedef MachOObject::LoadCommandInfo LoadCommandInfo;
33 
34 class MachOObjectFile : public ObjectFile {
35 public:
36   MachOObjectFile(MemoryBuffer *Object, MachOObject *MOO, error_code &ec);
37 
38   virtual symbol_iterator begin_symbols() const;
39   virtual symbol_iterator end_symbols() const;
40   virtual section_iterator begin_sections() const;
41   virtual section_iterator end_sections() const;
42   virtual relocation_iterator begin_relocations() const;
43   virtual relocation_iterator end_relocations() const;
44 
45   virtual uint8_t getBytesInAddress() const;
46   virtual StringRef getFileFormatName() const;
47   virtual unsigned getArch() const;
48 
49 protected:
50   virtual error_code getSymbolNext(DataRefImpl Symb, SymbolRef &Res) const;
51   virtual error_code getSymbolName(DataRefImpl Symb, StringRef &Res) const;
52   virtual error_code getSymbolOffset(DataRefImpl Symb, uint64_t &Res) const;
53   virtual error_code getSymbolAddress(DataRefImpl Symb, uint64_t &Res) const;
54   virtual error_code getSymbolSize(DataRefImpl Symb, uint64_t &Res) const;
55   virtual error_code getSymbolNMTypeChar(DataRefImpl Symb, char &Res) const;
56   virtual error_code isSymbolInternal(DataRefImpl Symb, bool &Res) const;
57   virtual error_code isSymbolGlobal(DataRefImpl Symb, bool &Res) const;
58   virtual error_code getSymbolType(DataRefImpl Symb, SymbolRef::SymbolType &Res) const;
59 
60   virtual error_code getSectionNext(DataRefImpl Sec, SectionRef &Res) const;
61   virtual error_code getSectionName(DataRefImpl Sec, StringRef &Res) const;
62   virtual error_code getSectionAddress(DataRefImpl Sec, uint64_t &Res) const;
63   virtual error_code getSectionSize(DataRefImpl Sec, uint64_t &Res) const;
64   virtual error_code getSectionContents(DataRefImpl Sec, StringRef &Res) const;
65   virtual error_code isSectionText(DataRefImpl Sec, bool &Res) const;
66   virtual error_code sectionContainsSymbol(DataRefImpl DRI, DataRefImpl S,
67                                            bool &Result) const;
68 
69   virtual error_code getRelocationNext(DataRefImpl Rel,
70                                        RelocationRef &Res) const;
71   virtual error_code getRelocationAddress(DataRefImpl Rel,
72                                           uint64_t &Res) const;
73   virtual error_code getRelocationSymbol(DataRefImpl Rel,
74                                          SymbolRef &Res) const;
75   virtual error_code getRelocationType(DataRefImpl Rel,
76                                        uint32_t &Res) const;
77   virtual error_code getRelocationAdditionalInfo(DataRefImpl Rel,
78                                                  int64_t &Res) const;
79 private:
80   MachOObject *MachOObj;
81   mutable uint32_t RegisteredStringTable;
82   typedef SmallVector<DataRefImpl, 1> SectionList;
83   SectionList Sections;
84 
85 
86   void moveToNextSection(DataRefImpl &DRI) const;
87   void getSymbolTableEntry(DataRefImpl DRI,
88                            InMemoryStruct<macho::SymbolTableEntry> &Res) const;
89   void getSymbol64TableEntry(DataRefImpl DRI,
90                           InMemoryStruct<macho::Symbol64TableEntry> &Res) const;
91   void moveToNextSymbol(DataRefImpl &DRI) const;
92   void getSection(DataRefImpl DRI, InMemoryStruct<macho::Section> &Res) const;
93   void getSection64(DataRefImpl DRI,
94                     InMemoryStruct<macho::Section64> &Res) const;
95   void getRelocation(DataRefImpl Rel,
96                      InMemoryStruct<macho::RelocationEntry> &Res) const;
97 };
98 
99 MachOObjectFile::MachOObjectFile(MemoryBuffer *Object, MachOObject *MOO,
100                                  error_code &ec)
101     : ObjectFile(Binary::isMachO, Object, ec),
102       MachOObj(MOO),
103       RegisteredStringTable(std::numeric_limits<uint32_t>::max()) {
104   DataRefImpl DRI;
105   DRI.d.a = DRI.d.b = 0;
106   moveToNextSection(DRI);
107   uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands;
108   while (DRI.d.a < LoadCommandCount) {
109     Sections.push_back(DRI);
110     DRI.d.b++;
111     moveToNextSection(DRI);
112   }
113 }
114 
115 
116 ObjectFile *ObjectFile::createMachOObjectFile(MemoryBuffer *Buffer) {
117   error_code ec;
118   std::string Err;
119   MachOObject *MachOObj = MachOObject::LoadFromBuffer(Buffer, &Err);
120   if (!MachOObj)
121     return NULL;
122   return new MachOObjectFile(Buffer, MachOObj, ec);
123 }
124 
125 /*===-- Symbols -----------------------------------------------------------===*/
126 
127 void MachOObjectFile::moveToNextSymbol(DataRefImpl &DRI) const {
128   uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands;
129   while (DRI.d.a < LoadCommandCount) {
130     LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
131     if (LCI.Command.Type == macho::LCT_Symtab) {
132       InMemoryStruct<macho::SymtabLoadCommand> SymtabLoadCmd;
133       MachOObj->ReadSymtabLoadCommand(LCI, SymtabLoadCmd);
134       if (DRI.d.b < SymtabLoadCmd->NumSymbolTableEntries)
135         return;
136     }
137 
138     DRI.d.a++;
139     DRI.d.b = 0;
140   }
141 }
142 
143 void MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI,
144     InMemoryStruct<macho::SymbolTableEntry> &Res) const {
145   InMemoryStruct<macho::SymtabLoadCommand> SymtabLoadCmd;
146   LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
147   MachOObj->ReadSymtabLoadCommand(LCI, SymtabLoadCmd);
148 
149   if (RegisteredStringTable != DRI.d.a) {
150     MachOObj->RegisterStringTable(*SymtabLoadCmd);
151     RegisteredStringTable = DRI.d.a;
152   }
153 
154   MachOObj->ReadSymbolTableEntry(SymtabLoadCmd->SymbolTableOffset, DRI.d.b,
155                                  Res);
156 }
157 
158 void MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI,
159     InMemoryStruct<macho::Symbol64TableEntry> &Res) const {
160   InMemoryStruct<macho::SymtabLoadCommand> SymtabLoadCmd;
161   LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
162   MachOObj->ReadSymtabLoadCommand(LCI, SymtabLoadCmd);
163 
164   if (RegisteredStringTable != DRI.d.a) {
165     MachOObj->RegisterStringTable(*SymtabLoadCmd);
166     RegisteredStringTable = DRI.d.a;
167   }
168 
169   MachOObj->ReadSymbol64TableEntry(SymtabLoadCmd->SymbolTableOffset, DRI.d.b,
170                                    Res);
171 }
172 
173 
174 error_code MachOObjectFile::getSymbolNext(DataRefImpl DRI,
175                                           SymbolRef &Result) const {
176   DRI.d.b++;
177   moveToNextSymbol(DRI);
178   Result = SymbolRef(DRI, this);
179   return object_error::success;
180 }
181 
182 error_code MachOObjectFile::getSymbolName(DataRefImpl DRI,
183                                           StringRef &Result) const {
184   if (MachOObj->is64Bit()) {
185     InMemoryStruct<macho::Symbol64TableEntry> Entry;
186     getSymbol64TableEntry(DRI, Entry);
187     Result = MachOObj->getStringAtIndex(Entry->StringIndex);
188   } else {
189     InMemoryStruct<macho::SymbolTableEntry> Entry;
190     getSymbolTableEntry(DRI, Entry);
191     Result = MachOObj->getStringAtIndex(Entry->StringIndex);
192   }
193   return object_error::success;
194 }
195 
196 error_code MachOObjectFile::getSymbolOffset(DataRefImpl DRI,
197                                              uint64_t &Result) const {
198   if (MachOObj->is64Bit()) {
199     InMemoryStruct<macho::Symbol64TableEntry> Entry;
200     getSymbol64TableEntry(DRI, Entry);
201     Result = Entry->Value;
202   } else {
203     InMemoryStruct<macho::SymbolTableEntry> Entry;
204     getSymbolTableEntry(DRI, Entry);
205     Result = Entry->Value;
206   }
207   return object_error::success;
208 }
209 
210 error_code MachOObjectFile::getSymbolAddress(DataRefImpl DRI,
211                                              uint64_t &Result) const {
212   uint64_t SymbolOffset;
213   uint8_t SectionIndex;
214   if (MachOObj->is64Bit()) {
215     InMemoryStruct<macho::Symbol64TableEntry> Entry;
216     getSymbol64TableEntry(DRI, Entry);
217     SymbolOffset = Entry->Value;
218     SectionIndex = Entry->SectionIndex;
219   } else {
220     InMemoryStruct<macho::SymbolTableEntry> Entry;
221     getSymbolTableEntry(DRI, Entry);
222     SymbolOffset = Entry->Value;
223     SectionIndex = Entry->SectionIndex;
224   }
225   getSectionAddress(Sections[SectionIndex], Result);
226   Result += SymbolOffset;
227 
228   return object_error::success;
229 }
230 
231 error_code MachOObjectFile::getSymbolSize(DataRefImpl DRI,
232                                           uint64_t &Result) const {
233   Result = UnknownAddressOrSize;
234   return object_error::success;
235 }
236 
237 error_code MachOObjectFile::getSymbolNMTypeChar(DataRefImpl DRI,
238                                                 char &Result) const {
239   uint8_t Type, Flags;
240   if (MachOObj->is64Bit()) {
241     InMemoryStruct<macho::Symbol64TableEntry> Entry;
242     getSymbol64TableEntry(DRI, Entry);
243     Type = Entry->Type;
244     Flags = Entry->Flags;
245   } else {
246     InMemoryStruct<macho::SymbolTableEntry> Entry;
247     getSymbolTableEntry(DRI, Entry);
248     Type = Entry->Type;
249     Flags = Entry->Flags;
250   }
251 
252   char Char;
253   switch (Type & macho::STF_TypeMask) {
254     case macho::STT_Undefined:
255       Char = 'u';
256       break;
257     case macho::STT_Absolute:
258     case macho::STT_Section:
259       Char = 's';
260       break;
261     default:
262       Char = '?';
263       break;
264   }
265 
266   if (Flags & (macho::STF_External | macho::STF_PrivateExtern))
267     Char = toupper(Char);
268   Result = Char;
269   return object_error::success;
270 }
271 
272 error_code MachOObjectFile::isSymbolInternal(DataRefImpl DRI,
273                                              bool &Result) const {
274   if (MachOObj->is64Bit()) {
275     InMemoryStruct<macho::Symbol64TableEntry> Entry;
276     getSymbol64TableEntry(DRI, Entry);
277     Result = Entry->Flags & macho::STF_StabsEntryMask;
278   } else {
279     InMemoryStruct<macho::SymbolTableEntry> Entry;
280     getSymbolTableEntry(DRI, Entry);
281     Result = Entry->Flags & macho::STF_StabsEntryMask;
282   }
283   return object_error::success;
284 }
285 
286 error_code MachOObjectFile::isSymbolGlobal(DataRefImpl Symb, bool &Res) const {
287 
288   if (MachOObj->is64Bit()) {
289     InMemoryStruct<macho::Symbol64TableEntry> Entry;
290     getSymbol64TableEntry(Symb, Entry);
291     Res = Entry->Type & MachO::NlistMaskExternal;
292   } else {
293     InMemoryStruct<macho::SymbolTableEntry> Entry;
294     getSymbolTableEntry(Symb, Entry);
295     Res = Entry->Type & MachO::NlistMaskExternal;
296   }
297   return object_error::success;
298 }
299 
300 error_code MachOObjectFile::getSymbolType(DataRefImpl Symb,
301                                           SymbolRef::SymbolType &Res) const {
302   uint8_t n_type;
303   if (MachOObj->is64Bit()) {
304     InMemoryStruct<macho::Symbol64TableEntry> Entry;
305     getSymbol64TableEntry(Symb, Entry);
306     n_type = Entry->Type;
307   } else {
308     InMemoryStruct<macho::SymbolTableEntry> Entry;
309     getSymbolTableEntry(Symb, Entry);
310     n_type = Entry->Type;
311   }
312   Res = SymbolRef::ST_Other;
313   switch (n_type & MachO::NlistMaskType) {
314     case MachO::NListTypeUndefined :
315       Res = SymbolRef::ST_External;
316       break;
317     case MachO::NListTypeSection :
318       Res = SymbolRef::ST_Function;
319       break;
320   }
321   return object_error::success;
322 }
323 
324 
325 ObjectFile::symbol_iterator MachOObjectFile::begin_symbols() const {
326   // DRI.d.a = segment number; DRI.d.b = symbol index.
327   DataRefImpl DRI;
328   DRI.d.a = DRI.d.b = 0;
329   moveToNextSymbol(DRI);
330   return symbol_iterator(SymbolRef(DRI, this));
331 }
332 
333 ObjectFile::symbol_iterator MachOObjectFile::end_symbols() const {
334   DataRefImpl DRI;
335   DRI.d.a = MachOObj->getHeader().NumLoadCommands;
336   DRI.d.b = 0;
337   return symbol_iterator(SymbolRef(DRI, this));
338 }
339 
340 
341 /*===-- Sections ----------------------------------------------------------===*/
342 
343 void MachOObjectFile::moveToNextSection(DataRefImpl &DRI) const {
344   uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands;
345   while (DRI.d.a < LoadCommandCount) {
346     LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
347     if (LCI.Command.Type == macho::LCT_Segment) {
348       InMemoryStruct<macho::SegmentLoadCommand> SegmentLoadCmd;
349       MachOObj->ReadSegmentLoadCommand(LCI, SegmentLoadCmd);
350       if (DRI.d.b < SegmentLoadCmd->NumSections)
351         return;
352     } else if (LCI.Command.Type == macho::LCT_Segment64) {
353       InMemoryStruct<macho::Segment64LoadCommand> Segment64LoadCmd;
354       MachOObj->ReadSegment64LoadCommand(LCI, Segment64LoadCmd);
355       if (DRI.d.b < Segment64LoadCmd->NumSections)
356         return;
357     }
358 
359     DRI.d.a++;
360     DRI.d.b = 0;
361   }
362 }
363 
364 error_code MachOObjectFile::getSectionNext(DataRefImpl DRI,
365                                            SectionRef &Result) const {
366   DRI.d.b++;
367   moveToNextSection(DRI);
368   Result = SectionRef(DRI, this);
369   return object_error::success;
370 }
371 
372 void
373 MachOObjectFile::getSection(DataRefImpl DRI,
374                             InMemoryStruct<macho::Section> &Res) const {
375   InMemoryStruct<macho::SegmentLoadCommand> SLC;
376   LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
377   MachOObj->ReadSegmentLoadCommand(LCI, SLC);
378   MachOObj->ReadSection(LCI, DRI.d.b, Res);
379 }
380 
381 void
382 MachOObjectFile::getSection64(DataRefImpl DRI,
383                             InMemoryStruct<macho::Section64> &Res) const {
384   InMemoryStruct<macho::Segment64LoadCommand> SLC;
385   LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
386   MachOObj->ReadSegment64LoadCommand(LCI, SLC);
387   MachOObj->ReadSection64(LCI, DRI.d.b, Res);
388 }
389 
390 static bool is64BitLoadCommand(const MachOObject *MachOObj, DataRefImpl DRI) {
391   LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
392   if (LCI.Command.Type == macho::LCT_Segment64)
393     return true;
394   assert(LCI.Command.Type == macho::LCT_Segment && "Unexpected Type.");
395   return false;
396 }
397 
398 error_code MachOObjectFile::getSectionName(DataRefImpl DRI,
399                                            StringRef &Result) const {
400   // FIXME: thread safety.
401   static char result[34];
402   if (is64BitLoadCommand(MachOObj, DRI)) {
403     InMemoryStruct<macho::Segment64LoadCommand> SLC;
404     LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
405     MachOObj->ReadSegment64LoadCommand(LCI, SLC);
406     InMemoryStruct<macho::Section64> Sect;
407     MachOObj->ReadSection64(LCI, DRI.d.b, Sect);
408 
409     strcpy(result, Sect->SegmentName);
410     strcat(result, ",");
411     strcat(result, Sect->Name);
412   } else {
413     InMemoryStruct<macho::SegmentLoadCommand> SLC;
414     LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
415     MachOObj->ReadSegmentLoadCommand(LCI, SLC);
416     InMemoryStruct<macho::Section> Sect;
417     MachOObj->ReadSection(LCI, DRI.d.b, Sect);
418 
419     strcpy(result, Sect->SegmentName);
420     strcat(result, ",");
421     strcat(result, Sect->Name);
422   }
423   Result = StringRef(result);
424   return object_error::success;
425 }
426 
427 error_code MachOObjectFile::getSectionAddress(DataRefImpl DRI,
428                                               uint64_t &Result) const {
429   if (is64BitLoadCommand(MachOObj, DRI)) {
430     InMemoryStruct<macho::Section64> Sect;
431     getSection64(DRI, Sect);
432     Result = Sect->Address;
433   } else {
434     InMemoryStruct<macho::Section> Sect;
435     getSection(DRI, Sect);
436     Result = Sect->Address;
437   }
438   return object_error::success;
439 }
440 
441 error_code MachOObjectFile::getSectionSize(DataRefImpl DRI,
442                                            uint64_t &Result) const {
443   if (is64BitLoadCommand(MachOObj, DRI)) {
444     InMemoryStruct<macho::Section64> Sect;
445     getSection64(DRI, Sect);
446     Result = Sect->Size;
447   } else {
448     InMemoryStruct<macho::Section> Sect;
449     getSection(DRI, Sect);
450     Result = Sect->Size;
451   }
452   return object_error::success;
453 }
454 
455 error_code MachOObjectFile::getSectionContents(DataRefImpl DRI,
456                                                StringRef &Result) const {
457   if (is64BitLoadCommand(MachOObj, DRI)) {
458     InMemoryStruct<macho::Section64> Sect;
459     getSection64(DRI, Sect);
460     Result = MachOObj->getData(Sect->Offset, Sect->Size);
461   } else {
462     InMemoryStruct<macho::Section> Sect;
463     getSection(DRI, Sect);
464     Result = MachOObj->getData(Sect->Offset, Sect->Size);
465   }
466   return object_error::success;
467 }
468 
469 error_code MachOObjectFile::isSectionText(DataRefImpl DRI,
470                                           bool &Result) const {
471   if (is64BitLoadCommand(MachOObj, DRI)) {
472     InMemoryStruct<macho::Section64> Sect;
473     getSection64(DRI, Sect);
474     Result = !strcmp(Sect->Name, "__text");
475   } else {
476     InMemoryStruct<macho::Section> Sect;
477     getSection(DRI, Sect);
478     Result = !strcmp(Sect->Name, "__text");
479   }
480   return object_error::success;
481 }
482 
483 error_code MachOObjectFile::sectionContainsSymbol(DataRefImpl Sec,
484                                                   DataRefImpl Symb,
485                                                   bool &Result) const {
486   if (MachOObj->is64Bit()) {
487     InMemoryStruct<macho::Symbol64TableEntry> Entry;
488     getSymbol64TableEntry(Symb, Entry);
489     Result = Entry->SectionIndex == 1 + Sec.d.a + Sec.d.b;
490   } else {
491     InMemoryStruct<macho::SymbolTableEntry> Entry;
492     getSymbolTableEntry(Symb, Entry);
493     Result = Entry->SectionIndex == 1 + Sec.d.a + Sec.d.b;
494   }
495   return object_error::success;
496 }
497 
498 ObjectFile::section_iterator MachOObjectFile::begin_sections() const {
499   DataRefImpl DRI;
500   DRI.d.a = DRI.d.b = 0;
501   moveToNextSection(DRI);
502   return section_iterator(SectionRef(DRI, this));
503 }
504 
505 ObjectFile::section_iterator MachOObjectFile::end_sections() const {
506   DataRefImpl DRI;
507   DRI.d.a = MachOObj->getHeader().NumLoadCommands;
508   DRI.d.b = 0;
509   return section_iterator(SectionRef(DRI, this));
510 }
511 
512 /*===-- Relocations -------------------------------------------------------===*/
513 
514 void MachOObjectFile::
515 getRelocation(DataRefImpl Rel,
516               InMemoryStruct<macho::RelocationEntry> &Res) const {
517   uint32_t relOffset;
518   if (MachOObj->is64Bit()) {
519     InMemoryStruct<macho::Section64> Sect;
520     getSection64(Sections[Rel.d.b], Sect);
521     relOffset = Sect->RelocationTableOffset;
522   } else {
523     InMemoryStruct<macho::Section> Sect;
524     getSection(Sections[Rel.d.b], Sect);
525     relOffset = Sect->RelocationTableOffset;
526   }
527   MachOObj->ReadRelocationEntry(relOffset, Rel.d.a, Res);
528 }
529 error_code MachOObjectFile::getRelocationNext(DataRefImpl Rel,
530                                               RelocationRef &Res) const {
531   ++Rel.d.a;
532   while (Rel.d.b < Sections.size()) {
533     unsigned relocationCount;
534     if (MachOObj->is64Bit()) {
535       InMemoryStruct<macho::Section64> Sect;
536       getSection64(Sections[Rel.d.b], Sect);
537       relocationCount = Sect->NumRelocationTableEntries;
538     } else {
539       InMemoryStruct<macho::Section> Sect;
540       getSection(Sections[Rel.d.b], Sect);
541       relocationCount = Sect->NumRelocationTableEntries;
542     }
543     if (Rel.d.a < relocationCount)
544       break;
545 
546     Rel.d.a = 0;
547     ++Rel.d.b;
548   }
549   Res = RelocationRef(Rel, this);
550   return object_error::success;
551 }
552 error_code MachOObjectFile::getRelocationAddress(DataRefImpl Rel,
553                                                  uint64_t &Res) const {
554   const uint8_t* sectAddress = base();
555   if (MachOObj->is64Bit()) {
556     InMemoryStruct<macho::Section64> Sect;
557     getSection64(Sections[Rel.d.b], Sect);
558     sectAddress += Sect->Offset;
559   } else {
560     InMemoryStruct<macho::Section> Sect;
561     getSection(Sections[Rel.d.b], Sect);
562     sectAddress += Sect->Offset;
563   }
564   InMemoryStruct<macho::RelocationEntry> RE;
565   getRelocation(Rel, RE);
566   Res = reinterpret_cast<uintptr_t>(sectAddress + RE->Word0);
567   return object_error::success;
568 }
569 error_code MachOObjectFile::getRelocationSymbol(DataRefImpl Rel,
570                                                 SymbolRef &Res) const {
571   InMemoryStruct<macho::RelocationEntry> RE;
572   getRelocation(Rel, RE);
573   uint32_t SymbolIdx = RE->Word1 & 0xffffff;
574   bool isExtern = (RE->Word1 >> 27) & 1;
575 
576   DataRefImpl Sym;
577   Sym.d.a = Sym.d.b = 0;
578   moveToNextSymbol(Sym);
579   if (isExtern) {
580     for (unsigned i = 0; i < SymbolIdx; i++) {
581       Sym.d.b++;
582       moveToNextSymbol(Sym);
583       assert(Sym.d.a < MachOObj->getHeader().NumLoadCommands &&
584              "Relocation symbol index out of range!");
585     }
586   }
587   Res = SymbolRef(Sym, this);
588   return object_error::success;
589 }
590 error_code MachOObjectFile::getRelocationType(DataRefImpl Rel,
591                                               uint32_t &Res) const {
592   InMemoryStruct<macho::RelocationEntry> RE;
593   getRelocation(Rel, RE);
594   Res = RE->Word1;
595   return object_error::success;
596 }
597 error_code MachOObjectFile::getRelocationAdditionalInfo(DataRefImpl Rel,
598                                                         int64_t &Res) const {
599   InMemoryStruct<macho::RelocationEntry> RE;
600   getRelocation(Rel, RE);
601   bool isExtern = (RE->Word1 >> 27) & 1;
602   Res = 0;
603   if (!isExtern) {
604     const uint8_t* sectAddress = base();
605     if (MachOObj->is64Bit()) {
606       InMemoryStruct<macho::Section64> Sect;
607       getSection64(Sections[Rel.d.b], Sect);
608       sectAddress += Sect->Offset;
609     } else {
610       InMemoryStruct<macho::Section> Sect;
611       getSection(Sections[Rel.d.b], Sect);
612       sectAddress += Sect->Offset;
613     }
614     Res = reinterpret_cast<uintptr_t>(sectAddress);
615   }
616   return object_error::success;
617 }
618 ObjectFile::relocation_iterator MachOObjectFile::begin_relocations() const {
619   DataRefImpl ret;
620   ret.d.a = ret.d.b = 0;
621   return relocation_iterator(RelocationRef(ret, this));
622 }
623 ObjectFile::relocation_iterator MachOObjectFile::end_relocations() const {
624   DataRefImpl ret;
625   ret.d.a = 0;
626   ret.d.b = Sections.size();
627   return relocation_iterator(RelocationRef(ret, this));
628 }
629 
630 /*===-- Miscellaneous -----------------------------------------------------===*/
631 
632 uint8_t MachOObjectFile::getBytesInAddress() const {
633   return MachOObj->is64Bit() ? 8 : 4;
634 }
635 
636 StringRef MachOObjectFile::getFileFormatName() const {
637   if (!MachOObj->is64Bit()) {
638     switch (MachOObj->getHeader().CPUType) {
639     case llvm::MachO::CPUTypeI386:
640       return "Mach-O 32-bit i386";
641     case llvm::MachO::CPUTypeARM:
642       return "Mach-O arm";
643     case llvm::MachO::CPUTypePowerPC:
644       return "Mach-O 32-bit ppc";
645     default:
646       assert((MachOObj->getHeader().CPUType & llvm::MachO::CPUArchABI64) == 0 &&
647              "64-bit object file when we're not 64-bit?");
648       return "Mach-O 32-bit unknown";
649     }
650   }
651 
652   switch (MachOObj->getHeader().CPUType) {
653   case llvm::MachO::CPUTypeX86_64:
654     return "Mach-O 64-bit x86-64";
655   case llvm::MachO::CPUTypePowerPC64:
656     return "Mach-O 64-bit ppc64";
657   default:
658     assert((MachOObj->getHeader().CPUType & llvm::MachO::CPUArchABI64) == 1 &&
659            "32-bit object file when we're 64-bit?");
660     return "Mach-O 64-bit unknown";
661   }
662 }
663 
664 unsigned MachOObjectFile::getArch() const {
665   switch (MachOObj->getHeader().CPUType) {
666   case llvm::MachO::CPUTypeI386:
667     return Triple::x86;
668   case llvm::MachO::CPUTypeX86_64:
669     return Triple::x86_64;
670   case llvm::MachO::CPUTypeARM:
671     return Triple::arm;
672   case llvm::MachO::CPUTypePowerPC:
673     return Triple::ppc;
674   case llvm::MachO::CPUTypePowerPC64:
675     return Triple::ppc64;
676   default:
677     return Triple::UnknownArch;
678   }
679 }
680 
681 } // end namespace llvm
682