lib/Object/MachOObjectFile.cpp

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