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