Home | History | Annotate | Download | only in Object 
      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::isSymbolAbsolute(DataRefImpl Symb, bool &Res) const{
    246   uint8_t n_type;
    247   if (MachOObj->is64Bit()) {
    248     InMemoryStruct<macho::Symbol64TableEntry> Entry;
    249     getSymbol64TableEntry(Symb, Entry);
    250     n_type = Entry->Type;
    251   } else {
    252     InMemoryStruct<macho::SymbolTableEntry> Entry;
    253     getSymbolTableEntry(Symb, Entry);
    254     n_type = Entry->Type;
    255   }
    256 
    257   Res = (n_type & MachO::NlistMaskType) == MachO::NListTypeAbsolute;
    258   return object_error::success;
    259 }
    260 
    261 error_code MachOObjectFile::getSymbolSection(DataRefImpl Symb,
    262                                              section_iterator &Res) const {
    263   uint8_t index;
    264   if (MachOObj->is64Bit()) {
    265     InMemoryStruct<macho::Symbol64TableEntry> Entry;
    266     getSymbol64TableEntry(Symb, Entry);
    267     index = Entry->SectionIndex;
    268   } else {
    269     InMemoryStruct<macho::SymbolTableEntry> Entry;
    270     getSymbolTableEntry(Symb, Entry);
    271     index = Entry->SectionIndex;
    272   }
    273 
    274   if (index == 0)
    275     Res = end_sections();
    276   else
    277     Res = section_iterator(SectionRef(Sections[index], this));
    278 
    279   return object_error::success;
    280 }
    281 
    282 error_code MachOObjectFile::getSymbolType(DataRefImpl Symb,
    283                                           SymbolRef::Type &Res) const {
    284   uint8_t n_type;
    285   if (MachOObj->is64Bit()) {
    286     InMemoryStruct<macho::Symbol64TableEntry> Entry;
    287     getSymbol64TableEntry(Symb, Entry);
    288     n_type = Entry->Type;
    289   } else {
    290     InMemoryStruct<macho::SymbolTableEntry> Entry;
    291     getSymbolTableEntry(Symb, Entry);
    292     n_type = Entry->Type;
    293   }
    294   Res = SymbolRef::ST_Other;
    295 
    296   // If this is a STAB debugging symbol, we can do nothing more.
    297   if (n_type & MachO::NlistMaskStab)
    298     return object_error::success;
    299 
    300   switch (n_type & MachO::NlistMaskType) {
    301     case MachO::NListTypeUndefined :
    302       Res = SymbolRef::ST_External;
    303       break;
    304     case MachO::NListTypeSection :
    305       Res = SymbolRef::ST_Function;
    306       break;
    307   }
    308   return object_error::success;
    309 }
    310 
    311 
    312 symbol_iterator MachOObjectFile::begin_symbols() const {
    313   // DRI.d.a = segment number; DRI.d.b = symbol index.
    314   DataRefImpl DRI;
    315   DRI.d.a = DRI.d.b = 0;
    316   moveToNextSymbol(DRI);
    317   return symbol_iterator(SymbolRef(DRI, this));
    318 }
    319 
    320 symbol_iterator MachOObjectFile::end_symbols() const {
    321   DataRefImpl DRI;
    322   DRI.d.a = MachOObj->getHeader().NumLoadCommands;
    323   DRI.d.b = 0;
    324   return symbol_iterator(SymbolRef(DRI, this));
    325 }
    326 
    327 
    328 /*===-- Sections ----------------------------------------------------------===*/
    329 
    330 void MachOObjectFile::moveToNextSection(DataRefImpl &DRI) const {
    331   uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands;
    332   while (DRI.d.a < LoadCommandCount) {
    333     LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
    334     if (LCI.Command.Type == macho::LCT_Segment) {
    335       InMemoryStruct<macho::SegmentLoadCommand> SegmentLoadCmd;
    336       MachOObj->ReadSegmentLoadCommand(LCI, SegmentLoadCmd);
    337       if (DRI.d.b < SegmentLoadCmd->NumSections)
    338         return;
    339     } else if (LCI.Command.Type == macho::LCT_Segment64) {
    340       InMemoryStruct<macho::Segment64LoadCommand> Segment64LoadCmd;
    341       MachOObj->ReadSegment64LoadCommand(LCI, Segment64LoadCmd);
    342       if (DRI.d.b < Segment64LoadCmd->NumSections)
    343         return;
    344     }
    345 
    346     DRI.d.a++;
    347     DRI.d.b = 0;
    348   }
    349 }
    350 
    351 error_code MachOObjectFile::getSectionNext(DataRefImpl DRI,
    352                                            SectionRef &Result) const {
    353   DRI.d.b++;
    354   moveToNextSection(DRI);
    355   Result = SectionRef(DRI, this);
    356   return object_error::success;
    357 }
    358 
    359 void
    360 MachOObjectFile::getSection(DataRefImpl DRI,
    361                             InMemoryStruct<macho::Section> &Res) const {
    362   InMemoryStruct<macho::SegmentLoadCommand> SLC;
    363   LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
    364   MachOObj->ReadSegmentLoadCommand(LCI, SLC);
    365   MachOObj->ReadSection(LCI, DRI.d.b, Res);
    366 }
    367 
    368 std::size_t MachOObjectFile::getSectionIndex(DataRefImpl Sec) const {
    369   SectionList::const_iterator loc =
    370     std::find(Sections.begin(), Sections.end(), Sec);
    371   assert(loc != Sections.end() && "Sec is not a valid section!");
    372   return std::distance(Sections.begin(), loc);
    373 }
    374 
    375 void
    376 MachOObjectFile::getSection64(DataRefImpl DRI,
    377                             InMemoryStruct<macho::Section64> &Res) const {
    378   InMemoryStruct<macho::Segment64LoadCommand> SLC;
    379   LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
    380   MachOObj->ReadSegment64LoadCommand(LCI, SLC);
    381   MachOObj->ReadSection64(LCI, DRI.d.b, Res);
    382 }
    383 
    384 static bool is64BitLoadCommand(const MachOObject *MachOObj, DataRefImpl DRI) {
    385   LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
    386   if (LCI.Command.Type == macho::LCT_Segment64)
    387     return true;
    388   assert(LCI.Command.Type == macho::LCT_Segment && "Unexpected Type.");
    389   return false;
    390 }
    391 
    392 error_code MachOObjectFile::getSectionName(DataRefImpl DRI,
    393                                            StringRef &Result) const {
    394   // FIXME: thread safety.
    395   static char result[34];
    396   if (is64BitLoadCommand(MachOObj, DRI)) {
    397     InMemoryStruct<macho::Segment64LoadCommand> SLC;
    398     LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
    399     MachOObj->ReadSegment64LoadCommand(LCI, SLC);
    400     InMemoryStruct<macho::Section64> Sect;
    401     MachOObj->ReadSection64(LCI, DRI.d.b, Sect);
    402 
    403     strcpy(result, Sect->SegmentName);
    404     strcat(result, ",");
    405     strcat(result, Sect->Name);
    406   } else {
    407     InMemoryStruct<macho::SegmentLoadCommand> SLC;
    408     LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
    409     MachOObj->ReadSegmentLoadCommand(LCI, SLC);
    410     InMemoryStruct<macho::Section> Sect;
    411     MachOObj->ReadSection(LCI, DRI.d.b, Sect);
    412 
    413     strcpy(result, Sect->SegmentName);
    414     strcat(result, ",");
    415     strcat(result, Sect->Name);
    416   }
    417   Result = StringRef(result);
    418   return object_error::success;
    419 }
    420 
    421 error_code MachOObjectFile::getSectionAddress(DataRefImpl DRI,
    422                                               uint64_t &Result) const {
    423   if (is64BitLoadCommand(MachOObj, DRI)) {
    424     InMemoryStruct<macho::Section64> Sect;
    425     getSection64(DRI, Sect);
    426     Result = Sect->Address;
    427   } else {
    428     InMemoryStruct<macho::Section> Sect;
    429     getSection(DRI, Sect);
    430     Result = Sect->Address;
    431   }
    432   return object_error::success;
    433 }
    434 
    435 error_code MachOObjectFile::getSectionSize(DataRefImpl DRI,
    436                                            uint64_t &Result) const {
    437   if (is64BitLoadCommand(MachOObj, DRI)) {
    438     InMemoryStruct<macho::Section64> Sect;
    439     getSection64(DRI, Sect);
    440     Result = Sect->Size;
    441   } else {
    442     InMemoryStruct<macho::Section> Sect;
    443     getSection(DRI, Sect);
    444     Result = Sect->Size;
    445   }
    446   return object_error::success;
    447 }
    448 
    449 error_code MachOObjectFile::getSectionContents(DataRefImpl DRI,
    450                                                StringRef &Result) const {
    451   if (is64BitLoadCommand(MachOObj, DRI)) {
    452     InMemoryStruct<macho::Section64> Sect;
    453     getSection64(DRI, Sect);
    454     Result = MachOObj->getData(Sect->Offset, Sect->Size);
    455   } else {
    456     InMemoryStruct<macho::Section> Sect;
    457     getSection(DRI, Sect);
    458     Result = MachOObj->getData(Sect->Offset, Sect->Size);
    459   }
    460   return object_error::success;
    461 }
    462 
    463 error_code MachOObjectFile::getSectionAlignment(DataRefImpl DRI,
    464                                                 uint64_t &Result) const {
    465   if (is64BitLoadCommand(MachOObj, DRI)) {
    466     InMemoryStruct<macho::Section64> Sect;
    467     getSection64(DRI, Sect);
    468     Result = uint64_t(1) << Sect->Align;
    469   } else {
    470     InMemoryStruct<macho::Section> Sect;
    471     getSection(DRI, Sect);
    472     Result = uint64_t(1) << Sect->Align;
    473   }
    474   return object_error::success;
    475 }
    476 
    477 error_code MachOObjectFile::isSectionText(DataRefImpl DRI,
    478                                           bool &Result) const {
    479   if (is64BitLoadCommand(MachOObj, DRI)) {
    480     InMemoryStruct<macho::Section64> Sect;
    481     getSection64(DRI, Sect);
    482     Result = !strcmp(Sect->Name, "__text");
    483   } else {
    484     InMemoryStruct<macho::Section> Sect;
    485     getSection(DRI, Sect);
    486     Result = !strcmp(Sect->Name, "__text");
    487   }
    488   return object_error::success;
    489 }
    490 
    491 error_code MachOObjectFile::isSectionData(DataRefImpl DRI,
    492                                           bool &Result) const {
    493   // FIXME: Unimplemented.
    494   Result = false;
    495   return object_error::success;
    496 }
    497 
    498 error_code MachOObjectFile::isSectionBSS(DataRefImpl DRI,
    499                                          bool &Result) const {
    500   // FIXME: Unimplemented.
    501   Result = false;
    502   return object_error::success;
    503 }
    504 
    505 error_code MachOObjectFile::sectionContainsSymbol(DataRefImpl Sec,
    506                                                   DataRefImpl Symb,
    507                                                   bool &Result) const {
    508   SymbolRef::Type ST;
    509   getSymbolType(Symb, ST);
    510   if (ST == SymbolRef::ST_External) {
    511     Result = false;
    512     return object_error::success;
    513   }
    514 
    515   uint64_t SectBegin, SectEnd;
    516   getSectionAddress(Sec, SectBegin);
    517   getSectionSize(Sec, SectEnd);
    518   SectEnd += SectBegin;
    519 
    520   if (MachOObj->is64Bit()) {
    521     InMemoryStruct<macho::Symbol64TableEntry> Entry;
    522     getSymbol64TableEntry(Symb, Entry);
    523     uint64_t SymAddr= Entry->Value;
    524     Result = (SymAddr >= SectBegin) && (SymAddr < SectEnd);
    525   } else {
    526     InMemoryStruct<macho::SymbolTableEntry> Entry;
    527     getSymbolTableEntry(Symb, Entry);
    528     uint64_t SymAddr= Entry->Value;
    529     Result = (SymAddr >= SectBegin) && (SymAddr < SectEnd);
    530   }
    531 
    532   return object_error::success;
    533 }
    534 
    535 relocation_iterator MachOObjectFile::getSectionRelBegin(DataRefImpl Sec) const {
    536   DataRefImpl ret;
    537   ret.d.a = 0;
    538   ret.d.b = getSectionIndex(Sec);
    539   return relocation_iterator(RelocationRef(ret, this));
    540 }
    541 relocation_iterator MachOObjectFile::getSectionRelEnd(DataRefImpl Sec) const {
    542   uint32_t last_reloc;
    543   if (is64BitLoadCommand(MachOObj, Sec)) {
    544     InMemoryStruct<macho::Section64> Sect;
    545     getSection64(Sec, Sect);
    546     last_reloc = Sect->NumRelocationTableEntries;
    547   } else {
    548     InMemoryStruct<macho::Section> Sect;
    549     getSection(Sec, Sect);
    550     last_reloc = Sect->NumRelocationTableEntries;
    551   }
    552   DataRefImpl ret;
    553   ret.d.a = last_reloc;
    554   ret.d.b = getSectionIndex(Sec);
    555   return relocation_iterator(RelocationRef(ret, this));
    556 }
    557 
    558 section_iterator MachOObjectFile::begin_sections() const {
    559   DataRefImpl DRI;
    560   DRI.d.a = DRI.d.b = 0;
    561   moveToNextSection(DRI);
    562   return section_iterator(SectionRef(DRI, this));
    563 }
    564 
    565 section_iterator MachOObjectFile::end_sections() const {
    566   DataRefImpl DRI;
    567   DRI.d.a = MachOObj->getHeader().NumLoadCommands;
    568   DRI.d.b = 0;
    569   return section_iterator(SectionRef(DRI, this));
    570 }
    571 
    572 /*===-- Relocations -------------------------------------------------------===*/
    573 
    574 void MachOObjectFile::
    575 getRelocation(DataRefImpl Rel,
    576               InMemoryStruct<macho::RelocationEntry> &Res) const {
    577   uint32_t relOffset;
    578   if (MachOObj->is64Bit()) {
    579     InMemoryStruct<macho::Section64> Sect;
    580     getSection64(Sections[Rel.d.b], Sect);
    581     relOffset = Sect->RelocationTableOffset;
    582   } else {
    583     InMemoryStruct<macho::Section> Sect;
    584     getSection(Sections[Rel.d.b], Sect);
    585     relOffset = Sect->RelocationTableOffset;
    586   }
    587   MachOObj->ReadRelocationEntry(relOffset, Rel.d.a, Res);
    588 }
    589 error_code MachOObjectFile::getRelocationNext(DataRefImpl Rel,
    590                                               RelocationRef &Res) const {
    591   ++Rel.d.a;
    592   Res = RelocationRef(Rel, this);
    593   return object_error::success;
    594 }
    595 error_code MachOObjectFile::getRelocationAddress(DataRefImpl Rel,
    596                                                  uint64_t &Res) const {
    597   const uint8_t* sectAddress = base();
    598   if (MachOObj->is64Bit()) {
    599     InMemoryStruct<macho::Section64> Sect;
    600     getSection64(Sections[Rel.d.b], Sect);
    601     sectAddress += Sect->Offset;
    602   } else {
    603     InMemoryStruct<macho::Section> Sect;
    604     getSection(Sections[Rel.d.b], Sect);
    605     sectAddress += Sect->Offset;
    606   }
    607   InMemoryStruct<macho::RelocationEntry> RE;
    608   getRelocation(Rel, RE);
    609   Res = reinterpret_cast<uintptr_t>(sectAddress + RE->Word0);
    610   return object_error::success;
    611 }
    612 error_code MachOObjectFile::getRelocationSymbol(DataRefImpl Rel,
    613                                                 SymbolRef &Res) const {
    614   InMemoryStruct<macho::RelocationEntry> RE;
    615   getRelocation(Rel, RE);
    616   uint32_t SymbolIdx = RE->Word1 & 0xffffff;
    617   bool isExtern = (RE->Word1 >> 27) & 1;
    618 
    619   DataRefImpl Sym;
    620   Sym.d.a = Sym.d.b = 0;
    621   moveToNextSymbol(Sym);
    622   if (isExtern) {
    623     for (unsigned i = 0; i < SymbolIdx; i++) {
    624       Sym.d.b++;
    625       moveToNextSymbol(Sym);
    626       assert(Sym.d.a < MachOObj->getHeader().NumLoadCommands &&
    627              "Relocation symbol index out of range!");
    628     }
    629   }
    630   Res = SymbolRef(Sym, this);
    631   return object_error::success;
    632 }
    633 error_code MachOObjectFile::getRelocationType(DataRefImpl Rel,
    634                                               uint32_t &Res) const {
    635   InMemoryStruct<macho::RelocationEntry> RE;
    636   getRelocation(Rel, RE);
    637   Res = RE->Word1;
    638   return object_error::success;
    639 }
    640 error_code MachOObjectFile::getRelocationTypeName(DataRefImpl Rel,
    641                                           SmallVectorImpl<char> &Result) const {
    642   return object_error::success;
    643 }
    644 error_code MachOObjectFile::getRelocationAdditionalInfo(DataRefImpl Rel,
    645                                                         int64_t &Res) const {
    646   InMemoryStruct<macho::RelocationEntry> RE;
    647   getRelocation(Rel, RE);
    648   bool isExtern = (RE->Word1 >> 27) & 1;
    649   Res = 0;
    650   if (!isExtern) {
    651     const uint8_t* sectAddress = base();
    652     if (MachOObj->is64Bit()) {
    653       InMemoryStruct<macho::Section64> Sect;
    654       getSection64(Sections[Rel.d.b], Sect);
    655       sectAddress += Sect->Offset;
    656     } else {
    657       InMemoryStruct<macho::Section> Sect;
    658       getSection(Sections[Rel.d.b], Sect);
    659       sectAddress += Sect->Offset;
    660     }
    661     Res = reinterpret_cast<uintptr_t>(sectAddress);
    662   }
    663   return object_error::success;
    664 }
    665 error_code MachOObjectFile::getRelocationValueString(DataRefImpl Rel,
    666                                           SmallVectorImpl<char> &Result) const {
    667   return object_error::success;
    668 }
    669 
    670 /*===-- Miscellaneous -----------------------------------------------------===*/
    671 
    672 uint8_t MachOObjectFile::getBytesInAddress() const {
    673   return MachOObj->is64Bit() ? 8 : 4;
    674 }
    675 
    676 StringRef MachOObjectFile::getFileFormatName() const {
    677   if (!MachOObj->is64Bit()) {
    678     switch (MachOObj->getHeader().CPUType) {
    679     case llvm::MachO::CPUTypeI386:
    680       return "Mach-O 32-bit i386";
    681     case llvm::MachO::CPUTypeARM:
    682       return "Mach-O arm";
    683     case llvm::MachO::CPUTypePowerPC:
    684       return "Mach-O 32-bit ppc";
    685     default:
    686       assert((MachOObj->getHeader().CPUType & llvm::MachO::CPUArchABI64) == 0 &&
    687              "64-bit object file when we're not 64-bit?");
    688       return "Mach-O 32-bit unknown";
    689     }
    690   }
    691 
    692   switch (MachOObj->getHeader().CPUType) {
    693   case llvm::MachO::CPUTypeX86_64:
    694     return "Mach-O 64-bit x86-64";
    695   case llvm::MachO::CPUTypePowerPC64:
    696     return "Mach-O 64-bit ppc64";
    697   default:
    698     assert((MachOObj->getHeader().CPUType & llvm::MachO::CPUArchABI64) == 1 &&
    699            "32-bit object file when we're 64-bit?");
    700     return "Mach-O 64-bit unknown";
    701   }
    702 }
    703 
    704 unsigned MachOObjectFile::getArch() const {
    705   switch (MachOObj->getHeader().CPUType) {
    706   case llvm::MachO::CPUTypeI386:
    707     return Triple::x86;
    708   case llvm::MachO::CPUTypeX86_64:
    709     return Triple::x86_64;
    710   case llvm::MachO::CPUTypeARM:
    711     return Triple::arm;
    712   case llvm::MachO::CPUTypePowerPC:
    713     return Triple::ppc;
    714   case llvm::MachO::CPUTypePowerPC64:
    715     return Triple::ppc64;
    716   default:
    717     return Triple::UnknownArch;
    718   }
    719 }
    720 
    721 } // end namespace object
    722 } // end namespace llvm
    723