lib/MC/MachObjectWriter.cpp

   1 //===- lib/MC/MachObjectWriter.cpp - Mach-O File Writer -------------------===//
   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 #include "llvm/MC/MCMachObjectWriter.h"
  11 #include "llvm/ADT/OwningPtr.h"
  12 #include "llvm/ADT/StringMap.h"
  13 #include "llvm/ADT/Twine.h"
  14 #include "llvm/MC/MCAssembler.h"
  15 #include "llvm/MC/MCAsmLayout.h"
  16 #include "llvm/MC/MCExpr.h"
  17 #include "llvm/MC/MCObjectWriter.h"
  18 #include "llvm/MC/MCSectionMachO.h"
  19 #include "llvm/MC/MCSymbol.h"
  20 #include "llvm/MC/MCMachOSymbolFlags.h"
  21 #include "llvm/MC/MCValue.h"
  22 #include "llvm/Object/MachOFormat.h"
  23 #include "llvm/Support/ErrorHandling.h"
  24 #include "llvm/Target/TargetAsmBackend.h"
  25
  26 // FIXME: Gross.
  27 #include "../Target/ARM/ARMFixupKinds.h"
  28 #include "../Target/X86/X86FixupKinds.h"
  29
  30 #include <vector>
  31 using namespace llvm;
  32 using namespace llvm::object;
  33
  34 // FIXME: this has been copied from (or to) X86AsmBackend.cpp
  35 static unsigned getFixupKindLog2Size(unsigned Kind) {
  36   switch (Kind) {
  37   default:
  38     llvm_unreachable("invalid fixup kind!");
  39   case FK_PCRel_1:
  40   case FK_Data_1: return 0;
  41   case FK_PCRel_2:
  42   case FK_Data_2: return 1;
  43   case FK_PCRel_4:
  44     // FIXME: Remove these!!!
  45   case X86::reloc_riprel_4byte:
  46   case X86::reloc_riprel_4byte_movq_load:
  47   case X86::reloc_signed_4byte:
  48   case FK_Data_4: return 2;
  49   case FK_Data_8: return 3;
  50   }
  51 }
  52
  53 static bool doesSymbolRequireExternRelocation(MCSymbolData *SD) {
  54   // Undefined symbols are always extern.
  55   if (SD->Symbol->isUndefined())
  56     return true;
  57
  58   // References to weak definitions require external relocation entries; the
  59   // definition may not always be the one in the same object file.
  60   if (SD->getFlags() & SF_WeakDefinition)
  61     return true;
  62
  63   // Otherwise, we can use an internal relocation.
  64   return false;
  65 }
  66
  67 namespace {
  68
  69 class MachObjectWriter : public MCObjectWriter {
  70   /// MachSymbolData - Helper struct for containing some precomputed information
  71   /// on symbols.
  72   struct MachSymbolData {
  73     MCSymbolData *SymbolData;
  74     uint64_t StringIndex;
  75     uint8_t SectionIndex;
  76
  77     // Support lexicographic sorting.
  78     bool operator<(const MachSymbolData &RHS) const {
  79       return SymbolData->getSymbol().getName() <
  80              RHS.SymbolData->getSymbol().getName();
  81     }
  82   };
  83
  84   /// The target specific Mach-O writer instance.
  85   llvm::OwningPtr<MCMachObjectTargetWriter> TargetObjectWriter;
  86
  87   /// @name Relocation Data
  88   /// @{
  89
  90   llvm::DenseMap<const MCSectionData*,
  91                  std::vector<macho::RelocationEntry> > Relocations;
  92   llvm::DenseMap<const MCSectionData*, unsigned> IndirectSymBase;
  93
  94   /// @}
  95   /// @name Symbol Table Data
  96   /// @{
  97
  98   SmallString<256> StringTable;
  99   std::vector<MachSymbolData> LocalSymbolData;
 100   std::vector<MachSymbolData> ExternalSymbolData;
 101   std::vector<MachSymbolData> UndefinedSymbolData;
 102
 103   /// @}
 104
 105 private:
 106   /// @name Utility Methods
 107   /// @{
 108
 109   bool isFixupKindPCRel(const MCAssembler &Asm, unsigned Kind) {
 110     const MCFixupKindInfo &FKI = Asm.getBackend().getFixupKindInfo(
 111       (MCFixupKind) Kind);
 112
 113     return FKI.Flags & MCFixupKindInfo::FKF_IsPCRel;
 114   }
 115
 116   /// @}
 117
 118   SectionAddrMap SectionAddress;
 119   uint64_t getSectionAddress(const MCSectionData* SD) const {
 120     return SectionAddress.lookup(SD);
 121   }
 122   uint64_t getSymbolAddress(const MCSymbolData* SD,
 123                             const MCAsmLayout &Layout) const;
 124
 125   uint64_t getFragmentAddress(const MCFragment *Fragment,
 126                               const MCAsmLayout &Layout) const {
 127     return getSectionAddress(Fragment->getParent()) +
 128       Layout.getFragmentOffset(Fragment);
 129   }
 130
 131   uint64_t getPaddingSize(const MCSectionData *SD,
 132                           const MCAsmLayout &Layout) const;
 133 public:
 134   MachObjectWriter(MCMachObjectTargetWriter *MOTW, raw_ostream &_OS,
 135                    bool _IsLittleEndian)
 136     : MCObjectWriter(_OS, _IsLittleEndian), TargetObjectWriter(MOTW) {
 137   }
 138
 139   /// @name Target Writer Proxy Accessors
 140   /// @{
 141
 142   bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
 143   bool isARM() const {
 144     uint32_t CPUType = TargetObjectWriter->getCPUType() & ~mach::CTFM_ArchMask;
 145     return CPUType == mach::CTM_ARM;
 146   }
 147
 148   /// @}
 149
 150   void WriteHeader(unsigned NumLoadCommands, unsigned LoadCommandsSize,
 151                    bool SubsectionsViaSymbols);
 152
 153   /// WriteSegmentLoadCommand - Write a segment load command.
 154   ///
 155   /// \arg NumSections - The number of sections in this segment.
 156   /// \arg SectionDataSize - The total size of the sections.
 157   void WriteSegmentLoadCommand(unsigned NumSections,
 158                                uint64_t VMSize,
 159                                uint64_t SectionDataStartOffset,
 160                                uint64_t SectionDataSize);
 161
 162   void WriteSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
 163                     const MCSectionData &SD, uint64_t FileOffset,
 164                     uint64_t RelocationsStart, unsigned NumRelocations);
 165
 166   void WriteSymtabLoadCommand(uint32_t SymbolOffset, uint32_t NumSymbols,
 167                               uint32_t StringTableOffset,
 168                               uint32_t StringTableSize);
 169
 170   void WriteDysymtabLoadCommand(uint32_t FirstLocalSymbol,
 171                                 uint32_t NumLocalSymbols,
 172                                 uint32_t FirstExternalSymbol,
 173                                 uint32_t NumExternalSymbols,
 174                                 uint32_t FirstUndefinedSymbol,
 175                                 uint32_t NumUndefinedSymbols,
 176                                 uint32_t IndirectSymbolOffset,
 177                                 uint32_t NumIndirectSymbols);
 178
 179   void WriteNlist(MachSymbolData &MSD, const MCAsmLayout &Layout);
 180
 181   // FIXME: We really need to improve the relocation validation. Basically, we
 182   // want to implement a separate computation which evaluates the relocation
 183   // entry as the linker would, and verifies that the resultant fixup value is
 184   // exactly what the encoder wanted. This will catch several classes of
 185   // problems:
 186   //
 187   //  - Relocation entry bugs, the two algorithms are unlikely to have the same
 188   //    exact bug.
 189   //
 190   //  - Relaxation issues, where we forget to relax something.
 191   //
 192   //  - Input errors, where something cannot be correctly encoded. 'as' allows
 193   //    these through in many cases.
 194
 195   static bool isFixupKindRIPRel(unsigned Kind) {
 196     return Kind == X86::reloc_riprel_4byte ||
 197       Kind == X86::reloc_riprel_4byte_movq_load;
 198   }
 199   void RecordX86_64Relocation(const MCAssembler &Asm, const MCAsmLayout &Layout,
 200                               const MCFragment *Fragment,
 201                               const MCFixup &Fixup, MCValue Target,
 202                               uint64_t &FixedValue);
 203
 204   void RecordScatteredRelocation(const MCAssembler &Asm,
 205                                  const MCAsmLayout &Layout,
 206                                  const MCFragment *Fragment,
 207                                  const MCFixup &Fixup, MCValue Target,
 208                                  unsigned Log2Size,
 209                                  uint64_t &FixedValue);
 210
 211   void RecordARMScatteredRelocation(const MCAssembler &Asm,
 212                                     const MCAsmLayout &Layout,
 213                                     const MCFragment *Fragment,
 214                                     const MCFixup &Fixup, MCValue Target,
 215                                     unsigned Log2Size,
 216                                     uint64_t &FixedValue);
 217
 218   void RecordARMMovwMovtRelocation(const MCAssembler &Asm,
 219                                    const MCAsmLayout &Layout,
 220                                    const MCFragment *Fragment,
 221                                    const MCFixup &Fixup, MCValue Target,
 222                                    uint64_t &FixedValue);
 223
 224   void RecordTLVPRelocation(const MCAssembler &Asm,
 225                             const MCAsmLayout &Layout,
 226                             const MCFragment *Fragment,
 227                             const MCFixup &Fixup, MCValue Target,
 228                             uint64_t &FixedValue);
 229
 230   static bool getARMFixupKindMachOInfo(unsigned Kind, unsigned &RelocType,
 231                                        unsigned &Log2Size);
 232
 233   void RecordARMRelocation(const MCAssembler &Asm, const MCAsmLayout &Layout,
 234                            const MCFragment *Fragment, const MCFixup &Fixup,
 235                            MCValue Target, uint64_t &FixedValue);
 236
 237   void RecordRelocation(const MCAssembler &Asm, const MCAsmLayout &Layout,
 238                         const MCFragment *Fragment, const MCFixup &Fixup,
 239                         MCValue Target, uint64_t &FixedValue);
 240
 241   void BindIndirectSymbols(MCAssembler &Asm);
 242
 243   /// ComputeSymbolTable - Compute the symbol table data
 244   ///
 245   /// \param StringTable [out] - The string table data.
 246   /// \param StringIndexMap [out] - Map from symbol names to offsets in the
 247   /// string table.
 248   void ComputeSymbolTable(MCAssembler &Asm, SmallString<256> &StringTable,
 249                           std::vector<MachSymbolData> &LocalSymbolData,
 250                           std::vector<MachSymbolData> &ExternalSymbolData,
 251                           std::vector<MachSymbolData> &UndefinedSymbolData);
 252
 253   void computeSectionAddresses(const MCAssembler &Asm,
 254                                const MCAsmLayout &Layout);
 255
 256   void ExecutePostLayoutBinding(MCAssembler &Asm, const MCAsmLayout &Layout);
 257
 258   virtual bool IsSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
 259                                                       const MCSymbolData &DataA,
 260                                                       const MCFragment &FB,
 261                                                       bool InSet,
 262                                                       bool IsPCRel) const;
 263
 264   void WriteObject(MCAssembler &Asm, const MCAsmLayout &Layout);
 265 };
 266
 267 } // end anonymous namespace
 268
 269 uint64_t MachObjectWriter::getSymbolAddress(const MCSymbolData* SD,
 270                                             const MCAsmLayout &Layout) const {
 271   const MCSymbol &S = SD->getSymbol();
 272
 273   // If this is a variable, then recursively evaluate now.
 274   if (S.isVariable()) {
 275     MCValue Target;
 276     if (!S.getVariableValue()->EvaluateAsRelocatable(Target, Layout))
 277       report_fatal_error("unable to evaluate offset for variable '" +
 278                          S.getName() + "'");
 279
 280     // Verify that any used symbols are defined.
 281     if (Target.getSymA() && Target.getSymA()->getSymbol().isUndefined())
 282       report_fatal_error("unable to evaluate offset to undefined symbol '" +
 283                          Target.getSymA()->getSymbol().getName() + "'");
 284     if (Target.getSymB() && Target.getSymB()->getSymbol().isUndefined())
 285       report_fatal_error("unable to evaluate offset to undefined symbol '" +
 286                          Target.getSymB()->getSymbol().getName() + "'");
 287
 288     uint64_t Address = Target.getConstant();
 289     if (Target.getSymA())
 290       Address += getSymbolAddress(&Layout.getAssembler().getSymbolData(
 291                                     Target.getSymA()->getSymbol()), Layout);
 292     if (Target.getSymB())
 293       Address += getSymbolAddress(&Layout.getAssembler().getSymbolData(
 294                                     Target.getSymB()->getSymbol()), Layout);
 295     return Address;
 296   }
 297
 298   return getSectionAddress(SD->getFragment()->getParent()) +
 299     Layout.getSymbolOffset(SD);
 300 }
 301
 302 uint64_t MachObjectWriter::getPaddingSize(const MCSectionData *SD,
 303                                           const MCAsmLayout &Layout) const {
 304   uint64_t EndAddr = getSectionAddress(SD) + Layout.getSectionAddressSize(SD);
 305   unsigned Next = SD->getLayoutOrder() + 1;
 306   if (Next >= Layout.getSectionOrder().size())
 307     return 0;
 308
 309   const MCSectionData &NextSD = *Layout.getSectionOrder()[Next];
 310   if (NextSD.getSection().isVirtualSection())
 311     return 0;
 312   return OffsetToAlignment(EndAddr, NextSD.getAlignment());
 313 }
 314
 315 void MachObjectWriter::WriteHeader(unsigned NumLoadCommands,
 316                                    unsigned LoadCommandsSize,
 317                                    bool SubsectionsViaSymbols) {
 318   uint32_t Flags = 0;
 319
 320   if (SubsectionsViaSymbols)
 321     Flags |= macho::HF_SubsectionsViaSymbols;
 322
 323   // struct mach_header (28 bytes) or
 324   // struct mach_header_64 (32 bytes)
 325
 326   uint64_t Start = OS.tell();
 327   (void) Start;
 328
 329   Write32(is64Bit() ? macho::HM_Object64 : macho::HM_Object32);
 330
 331   Write32(TargetObjectWriter->getCPUType());
 332   Write32(TargetObjectWriter->getCPUSubtype());
 333
 334   Write32(macho::HFT_Object);
 335   Write32(NumLoadCommands);
 336   Write32(LoadCommandsSize);
 337   Write32(Flags);
 338   if (is64Bit())
 339     Write32(0); // reserved
 340
 341   assert(OS.tell() - Start ==
 342          (is64Bit() ? macho::Header64Size : macho::Header32Size));
 343 }
 344
 345 /// WriteSegmentLoadCommand - Write a segment load command.
 346 ///
 347 /// \arg NumSections - The number of sections in this segment.
 348 /// \arg SectionDataSize - The total size of the sections.
 349 void MachObjectWriter::WriteSegmentLoadCommand(unsigned NumSections,
 350                                                uint64_t VMSize,
 351                                                uint64_t SectionDataStartOffset,
 352                                                uint64_t SectionDataSize) {
 353   // struct segment_command (56 bytes) or
 354   // struct segment_command_64 (72 bytes)
 355
 356   uint64_t Start = OS.tell();
 357   (void) Start;
 358
 359   unsigned SegmentLoadCommandSize =
 360     is64Bit() ? macho::SegmentLoadCommand64Size:
 361     macho::SegmentLoadCommand32Size;
 362   Write32(is64Bit() ? macho::LCT_Segment64 : macho::LCT_Segment);
 363   Write32(SegmentLoadCommandSize +
 364           NumSections * (is64Bit() ? macho::Section64Size :
 365                          macho::Section32Size));
 366
 367   WriteBytes("", 16);
 368   if (is64Bit()) {
 369     Write64(0); // vmaddr
 370     Write64(VMSize); // vmsize
 371     Write64(SectionDataStartOffset); // file offset
 372     Write64(SectionDataSize); // file size
 373   } else {
 374     Write32(0); // vmaddr
 375     Write32(VMSize); // vmsize
 376     Write32(SectionDataStartOffset); // file offset
 377     Write32(SectionDataSize); // file size
 378   }
 379   Write32(0x7); // maxprot
 380   Write32(0x7); // initprot
 381   Write32(NumSections);
 382   Write32(0); // flags
 383
 384   assert(OS.tell() - Start == SegmentLoadCommandSize);
 385 }
 386
 387 void MachObjectWriter::WriteSection(const MCAssembler &Asm,
 388                                     const MCAsmLayout &Layout,
 389                                     const MCSectionData &SD,
 390                                     uint64_t FileOffset,
 391                                     uint64_t RelocationsStart,
 392                                     unsigned NumRelocations) {
 393   uint64_t SectionSize = Layout.getSectionAddressSize(&SD);
 394
 395   // The offset is unused for virtual sections.
 396   if (SD.getSection().isVirtualSection()) {
 397     assert(Layout.getSectionFileSize(&SD) == 0 && "Invalid file size!");
 398     FileOffset = 0;
 399   }
 400
 401   // struct section (68 bytes) or
 402   // struct section_64 (80 bytes)
 403
 404   uint64_t Start = OS.tell();
 405   (void) Start;
 406
 407   const MCSectionMachO &Section = cast<MCSectionMachO>(SD.getSection());
 408   WriteBytes(Section.getSectionName(), 16);
 409   WriteBytes(Section.getSegmentName(), 16);
 410   if (is64Bit()) {
 411     Write64(getSectionAddress(&SD)); // address
 412     Write64(SectionSize); // size
 413   } else {
 414     Write32(getSectionAddress(&SD)); // address
 415     Write32(SectionSize); // size
 416   }
 417   Write32(FileOffset);
 418
 419   unsigned Flags = Section.getTypeAndAttributes();
 420   if (SD.hasInstructions())
 421     Flags |= MCSectionMachO::S_ATTR_SOME_INSTRUCTIONS;
 422
 423   assert(isPowerOf2_32(SD.getAlignment()) && "Invalid alignment!");
 424   Write32(Log2_32(SD.getAlignment()));
 425   Write32(NumRelocations ? RelocationsStart : 0);
 426   Write32(NumRelocations);
 427   Write32(Flags);
 428   Write32(IndirectSymBase.lookup(&SD)); // reserved1
 429   Write32(Section.getStubSize()); // reserved2
 430   if (is64Bit())
 431     Write32(0); // reserved3
 432
 433   assert(OS.tell() - Start == (is64Bit() ? macho::Section64Size :
 434                                macho::Section32Size));
 435 }
 436
 437 void MachObjectWriter::WriteSymtabLoadCommand(uint32_t SymbolOffset,
 438                                               uint32_t NumSymbols,
 439                                               uint32_t StringTableOffset,
 440                                               uint32_t StringTableSize) {
 441   // struct symtab_command (24 bytes)
 442
 443   uint64_t Start = OS.tell();
 444   (void) Start;
 445
 446   Write32(macho::LCT_Symtab);
 447   Write32(macho::SymtabLoadCommandSize);
 448   Write32(SymbolOffset);
 449   Write32(NumSymbols);
 450   Write32(StringTableOffset);
 451   Write32(StringTableSize);
 452
 453   assert(OS.tell() - Start == macho::SymtabLoadCommandSize);
 454 }
 455
 456 void MachObjectWriter::WriteDysymtabLoadCommand(uint32_t FirstLocalSymbol,
 457                                                 uint32_t NumLocalSymbols,
 458                                                 uint32_t FirstExternalSymbol,
 459                                                 uint32_t NumExternalSymbols,
 460                                                 uint32_t FirstUndefinedSymbol,
 461                                                 uint32_t NumUndefinedSymbols,
 462                                                 uint32_t IndirectSymbolOffset,
 463                                                 uint32_t NumIndirectSymbols) {
 464   // struct dysymtab_command (80 bytes)
 465
 466   uint64_t Start = OS.tell();
 467   (void) Start;
 468
 469   Write32(macho::LCT_Dysymtab);
 470   Write32(macho::DysymtabLoadCommandSize);
 471   Write32(FirstLocalSymbol);
 472   Write32(NumLocalSymbols);
 473   Write32(FirstExternalSymbol);
 474   Write32(NumExternalSymbols);
 475   Write32(FirstUndefinedSymbol);
 476   Write32(NumUndefinedSymbols);
 477   Write32(0); // tocoff
 478   Write32(0); // ntoc
 479   Write32(0); // modtaboff
 480   Write32(0); // nmodtab
 481   Write32(0); // extrefsymoff
 482   Write32(0); // nextrefsyms
 483   Write32(IndirectSymbolOffset);
 484   Write32(NumIndirectSymbols);
 485   Write32(0); // extreloff
 486   Write32(0); // nextrel
 487   Write32(0); // locreloff
 488   Write32(0); // nlocrel
 489
 490   assert(OS.tell() - Start == macho::DysymtabLoadCommandSize);
 491 }
 492
 493 void MachObjectWriter::WriteNlist(MachSymbolData &MSD,
 494                                   const MCAsmLayout &Layout) {
 495   MCSymbolData &Data = *MSD.SymbolData;
 496   const MCSymbol &Symbol = Data.getSymbol();
 497   uint8_t Type = 0;
 498   uint16_t Flags = Data.getFlags();
 499   uint32_t Address = 0;
 500
 501   // Set the N_TYPE bits. See <mach-o/nlist.h>.
 502   //
 503   // FIXME: Are the prebound or indirect fields possible here?
 504   if (Symbol.isUndefined())
 505     Type = macho::STT_Undefined;
 506   else if (Symbol.isAbsolute())
 507     Type = macho::STT_Absolute;
 508   else
 509     Type = macho::STT_Section;
 510
 511   // FIXME: Set STAB bits.
 512
 513   if (Data.isPrivateExtern())
 514     Type |= macho::STF_PrivateExtern;
 515
 516   // Set external bit.
 517   if (Data.isExternal() || Symbol.isUndefined())
 518     Type |= macho::STF_External;
 519
 520   // Compute the symbol address.
 521   if (Symbol.isDefined()) {
 522     if (Symbol.isAbsolute()) {
 523       Address = cast<MCConstantExpr>(Symbol.getVariableValue())->getValue();
 524     } else {
 525       Address = getSymbolAddress(&Data, Layout);
 526     }
 527   } else if (Data.isCommon()) {
 528     // Common symbols are encoded with the size in the address
 529     // field, and their alignment in the flags.
 530     Address = Data.getCommonSize();
 531
 532     // Common alignment is packed into the 'desc' bits.
 533     if (unsigned Align = Data.getCommonAlignment()) {
 534       unsigned Log2Size = Log2_32(Align);
 535       assert((1U << Log2Size) == Align && "Invalid 'common' alignment!");
 536       if (Log2Size > 15)
 537         report_fatal_error("invalid 'common' alignment '" +
 538                            Twine(Align) + "'");
 539       // FIXME: Keep this mask with the SymbolFlags enumeration.
 540       Flags = (Flags & 0xF0FF) | (Log2Size << 8);
 541     }
 542   }
 543
 544   // struct nlist (12 bytes)
 545
 546   Write32(MSD.StringIndex);
 547   Write8(Type);
 548   Write8(MSD.SectionIndex);
 549
 550   // The Mach-O streamer uses the lowest 16-bits of the flags for the 'desc'
 551   // value.
 552   Write16(Flags);
 553   if (is64Bit())
 554     Write64(Address);
 555   else
 556     Write32(Address);
 557 }
 558
 559 void MachObjectWriter::RecordX86_64Relocation(const MCAssembler &Asm,
 560                                               const MCAsmLayout &Layout,
 561                                               const MCFragment *Fragment,
 562                                               const MCFixup &Fixup,
 563                                               MCValue Target,
 564                                               uint64_t &FixedValue) {
 565   unsigned IsPCRel = isFixupKindPCRel(Asm, Fixup.getKind());
 566   unsigned IsRIPRel = isFixupKindRIPRel(Fixup.getKind());
 567   unsigned Log2Size = getFixupKindLog2Size(Fixup.getKind());
 568
 569   // See <reloc.h>.
 570   uint32_t FixupOffset =
 571     Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
 572   uint32_t FixupAddress =
 573     getFragmentAddress(Fragment, Layout) + Fixup.getOffset();
 574   int64_t Value = 0;
 575   unsigned Index = 0;
 576   unsigned IsExtern = 0;
 577   unsigned Type = 0;
 578
 579   Value = Target.getConstant();
 580
 581   if (IsPCRel) {
 582     // Compensate for the relocation offset, Darwin x86_64 relocations only have
 583     // the addend and appear to have attempted to define it to be the actual
 584     // expression addend without the PCrel bias. However, instructions with data
 585     // following the relocation are not accommodated for (see comment below
 586     // regarding SIGNED{1,2,4}), so it isn't exactly that either.
 587     Value += 1LL << Log2Size;
 588   }
 589
 590   if (Target.isAbsolute()) { // constant
 591     // SymbolNum of 0 indicates the absolute section.
 592     Type = macho::RIT_X86_64_Unsigned;
 593     Index = 0;
 594
 595     // FIXME: I believe this is broken, I don't think the linker can understand
 596     // it. I think it would require a local relocation, but I'm not sure if that
 597     // would work either. The official way to get an absolute PCrel relocation
 598     // is to use an absolute symbol (which we don't support yet).
 599     if (IsPCRel) {
 600       IsExtern = 1;
 601       Type = macho::RIT_X86_64_Branch;
 602     }
 603   } else if (Target.getSymB()) { // A - B + constant
 604     const MCSymbol *A = &Target.getSymA()->getSymbol();
 605     MCSymbolData &A_SD = Asm.getSymbolData(*A);
 606     const MCSymbolData *A_Base = Asm.getAtom(&A_SD);
 607
 608     const MCSymbol *B = &Target.getSymB()->getSymbol();
 609     MCSymbolData &B_SD = Asm.getSymbolData(*B);
 610     const MCSymbolData *B_Base = Asm.getAtom(&B_SD);
 611
 612     // Neither symbol can be modified.
 613     if (Target.getSymA()->getKind() != MCSymbolRefExpr::VK_None ||
 614         Target.getSymB()->getKind() != MCSymbolRefExpr::VK_None)
 615       report_fatal_error("unsupported relocation of modified symbol");
 616
 617     // We don't support PCrel relocations of differences. Darwin 'as' doesn't
 618     // implement most of these correctly.
 619     if (IsPCRel)
 620       report_fatal_error("unsupported pc-relative relocation of difference");
 621
 622     // The support for the situation where one or both of the symbols would
 623     // require a local relocation is handled just like if the symbols were
 624     // external.  This is certainly used in the case of debug sections where the
 625     // section has only temporary symbols and thus the symbols don't have base
 626     // symbols.  This is encoded using the section ordinal and non-extern
 627     // relocation entries.
 628
 629     // Darwin 'as' doesn't emit correct relocations for this (it ends up with a
 630     // single SIGNED relocation); reject it for now.  Except the case where both
 631     // symbols don't have a base, equal but both NULL.
 632     if (A_Base == B_Base && A_Base)
 633       report_fatal_error("unsupported relocation with identical base");
 634
 635     Value += getSymbolAddress(&A_SD, Layout) -
 636       (A_Base == NULL ? 0 : getSymbolAddress(A_Base, Layout));
 637     Value -= getSymbolAddress(&B_SD, Layout) -
 638       (B_Base == NULL ? 0 : getSymbolAddress(B_Base, Layout));
 639
 640     if (A_Base) {
 641       Index = A_Base->getIndex();
 642       IsExtern = 1;
 643     }
 644     else {
 645       Index = A_SD.getFragment()->getParent()->getOrdinal() + 1;
 646       IsExtern = 0;
 647     }
 648     Type = macho::RIT_X86_64_Unsigned;
 649
 650     macho::RelocationEntry MRE;
 651     MRE.Word0 = FixupOffset;
 652     MRE.Word1 = ((Index     <<  0) |
 653                  (IsPCRel   << 24) |
 654                  (Log2Size  << 25) |
 655                  (IsExtern  << 27) |
 656                  (Type      << 28));
 657     Relocations[Fragment->getParent()].push_back(MRE);
 658
 659     if (B_Base) {
 660       Index = B_Base->getIndex();
 661       IsExtern = 1;
 662     }
 663     else {
 664       Index = B_SD.getFragment()->getParent()->getOrdinal() + 1;
 665       IsExtern = 0;
 666     }
 667     Type = macho::RIT_X86_64_Subtractor;
 668   } else {
 669     const MCSymbol *Symbol = &Target.getSymA()->getSymbol();
 670     MCSymbolData &SD = Asm.getSymbolData(*Symbol);
 671     const MCSymbolData *Base = Asm.getAtom(&SD);
 672
 673     // Relocations inside debug sections always use local relocations when
 674     // possible. This seems to be done because the debugger doesn't fully
 675     // understand x86_64 relocation entries, and expects to find values that
 676     // have already been fixed up.
 677     if (Symbol->isInSection()) {
 678       const MCSectionMachO &Section = static_cast<const MCSectionMachO&>(
 679         Fragment->getParent()->getSection());
 680       if (Section.hasAttribute(MCSectionMachO::S_ATTR_DEBUG))
 681         Base = 0;
 682     }
 683
 684     // x86_64 almost always uses external relocations, except when there is no
 685     // symbol to use as a base address (a local symbol with no preceding
 686     // non-local symbol).
 687     if (Base) {
 688       Index = Base->getIndex();
 689       IsExtern = 1;
 690
 691       // Add the local offset, if needed.
 692       if (Base != &SD)
 693         Value += Layout.getSymbolOffset(&SD) - Layout.getSymbolOffset(Base);
 694     } else if (Symbol->isInSection() && !Symbol->isVariable()) {
 695       // The index is the section ordinal (1-based).
 696       Index = SD.getFragment()->getParent()->getOrdinal() + 1;
 697       IsExtern = 0;
 698       Value += getSymbolAddress(&SD, Layout);
 699
 700       if (IsPCRel)
 701         Value -= FixupAddress + (1 << Log2Size);
 702     } else if (Symbol->isVariable()) {
 703       const MCExpr *Value = Symbol->getVariableValue();
 704       int64_t Res;
 705       bool isAbs = Value->EvaluateAsAbsolute(Res, Layout, SectionAddress);
 706       if (isAbs) {
 707         FixedValue = Res;
 708         return;
 709       } else {
 710         report_fatal_error("unsupported relocation of variable '" +
 711                            Symbol->getName() + "'");
 712       }
 713     } else {
 714       report_fatal_error("unsupported relocation of undefined symbol '" +
 715                          Symbol->getName() + "'");
 716     }
 717
 718     MCSymbolRefExpr::VariantKind Modifier = Target.getSymA()->getKind();
 719     if (IsPCRel) {
 720       if (IsRIPRel) {
 721         if (Modifier == MCSymbolRefExpr::VK_GOTPCREL) {
 722           // x86_64 distinguishes movq foo@GOTPCREL so that the linker can
 723           // rewrite the movq to an leaq at link time if the symbol ends up in
 724           // the same linkage unit.
 725           if (unsigned(Fixup.getKind()) == X86::reloc_riprel_4byte_movq_load)
 726             Type = macho::RIT_X86_64_GOTLoad;
 727           else
 728             Type = macho::RIT_X86_64_GOT;
 729         }  else if (Modifier == MCSymbolRefExpr::VK_TLVP) {
 730           Type = macho::RIT_X86_64_TLV;
 731         }  else if (Modifier != MCSymbolRefExpr::VK_None) {
 732           report_fatal_error("unsupported symbol modifier in relocation");
 733         } else {
 734           Type = macho::RIT_X86_64_Signed;
 735
 736           // The Darwin x86_64 relocation format has a problem where it cannot
 737           // encode an address (L<foo> + <constant>) which is outside the atom
 738           // containing L<foo>. Generally, this shouldn't occur but it does
 739           // happen when we have a RIPrel instruction with data following the
 740           // relocation entry (e.g., movb $012, L0(%rip)). Even with the PCrel
 741           // adjustment Darwin x86_64 uses, the offset is still negative and the
 742           // linker has no way to recognize this.
 743           //
 744           // To work around this, Darwin uses several special relocation types
 745           // to indicate the offsets. However, the specification or
 746           // implementation of these seems to also be incomplete; they should
 747           // adjust the addend as well based on the actual encoded instruction
 748           // (the additional bias), but instead appear to just look at the final
 749           // offset.
 750           switch (-(Target.getConstant() + (1LL << Log2Size))) {
 751           case 1: Type = macho::RIT_X86_64_Signed1; break;
 752           case 2: Type = macho::RIT_X86_64_Signed2; break;
 753           case 4: Type = macho::RIT_X86_64_Signed4; break;
 754           }
 755         }
 756       } else {
 757         if (Modifier != MCSymbolRefExpr::VK_None)
 758           report_fatal_error("unsupported symbol modifier in branch "
 759                              "relocation");
 760
 761         Type = macho::RIT_X86_64_Branch;
 762       }
 763     } else {
 764       if (Modifier == MCSymbolRefExpr::VK_GOT) {
 765         Type = macho::RIT_X86_64_GOT;
 766       } else if (Modifier == MCSymbolRefExpr::VK_GOTPCREL) {
 767         // GOTPCREL is allowed as a modifier on non-PCrel instructions, in which
 768         // case all we do is set the PCrel bit in the relocation entry; this is
 769         // used with exception handling, for example. The source is required to
 770         // include any necessary offset directly.
 771         Type = macho::RIT_X86_64_GOT;
 772         IsPCRel = 1;
 773       } else if (Modifier == MCSymbolRefExpr::VK_TLVP) {
 774         report_fatal_error("TLVP symbol modifier should have been rip-rel");
 775       } else if (Modifier != MCSymbolRefExpr::VK_None)
 776         report_fatal_error("unsupported symbol modifier in relocation");
 777       else
 778         Type = macho::RIT_X86_64_Unsigned;
 779     }
 780   }
 781
 782   // x86_64 always writes custom values into the fixups.
 783   FixedValue = Value;
 784
 785   // struct relocation_info (8 bytes)
 786   macho::RelocationEntry MRE;
 787   MRE.Word0 = FixupOffset;
 788   MRE.Word1 = ((Index     <<  0) |
 789                (IsPCRel   << 24) |
 790                (Log2Size  << 25) |
 791                (IsExtern  << 27) |
 792                (Type      << 28));
 793   Relocations[Fragment->getParent()].push_back(MRE);
 794 }
 795
 796 void MachObjectWriter::RecordScatteredRelocation(const MCAssembler &Asm,
 797                                                  const MCAsmLayout &Layout,
 798                                                  const MCFragment *Fragment,
 799                                                  const MCFixup &Fixup,
 800                                                  MCValue Target,
 801                                                  unsigned Log2Size,
 802                                                  uint64_t &FixedValue) {
 803   uint32_t FixupOffset = Layout.getFragmentOffset(Fragment)+Fixup.getOffset();
 804   unsigned IsPCRel = isFixupKindPCRel(Asm, Fixup.getKind());
 805   unsigned Type = macho::RIT_Vanilla;
 806
 807   // See <reloc.h>.
 808   const MCSymbol *A = &Target.getSymA()->getSymbol();
 809   MCSymbolData *A_SD = &Asm.getSymbolData(*A);
 810
 811   if (!A_SD->getFragment())
 812     report_fatal_error("symbol '" + A->getName() +
 813                        "' can not be undefined in a subtraction expression");
 814
 815   uint32_t Value = getSymbolAddress(A_SD, Layout);
 816   uint64_t SecAddr = getSectionAddress(A_SD->getFragment()->getParent());
 817   FixedValue += SecAddr;
 818   uint32_t Value2 = 0;
 819
 820   if (const MCSymbolRefExpr *B = Target.getSymB()) {
 821     MCSymbolData *B_SD = &Asm.getSymbolData(B->getSymbol());
 822
 823     if (!B_SD->getFragment())
 824       report_fatal_error("symbol '" + B->getSymbol().getName() +
 825                          "' can not be undefined in a subtraction expression");
 826
 827     // Select the appropriate difference relocation type.
 828     //
 829     // Note that there is no longer any semantic difference between these two
 830     // relocation types from the linkers point of view, this is done solely for
 831     // pedantic compatibility with 'as'.
 832     Type = A_SD->isExternal() ? (unsigned)macho::RIT_Difference :
 833       (unsigned)macho::RIT_Generic_LocalDifference;
 834     Value2 = getSymbolAddress(B_SD, Layout);
 835     FixedValue -= getSectionAddress(B_SD->getFragment()->getParent());
 836   }
 837
 838   // Relocations are written out in reverse order, so the PAIR comes first.
 839   if (Type == macho::RIT_Difference ||
 840       Type == macho::RIT_Generic_LocalDifference) {
 841     macho::RelocationEntry MRE;
 842     MRE.Word0 = ((0         <<  0) |
 843                  (macho::RIT_Pair  << 24) |
 844                  (Log2Size  << 28) |
 845                  (IsPCRel   << 30) |
 846                  macho::RF_Scattered);
 847     MRE.Word1 = Value2;
 848     Relocations[Fragment->getParent()].push_back(MRE);
 849   }
 850
 851   macho::RelocationEntry MRE;
 852   MRE.Word0 = ((FixupOffset <<  0) |
 853                (Type        << 24) |
 854                (Log2Size    << 28) |
 855                (IsPCRel     << 30) |
 856                macho::RF_Scattered);
 857   MRE.Word1 = Value;
 858   Relocations[Fragment->getParent()].push_back(MRE);
 859 }
 860
 861 void MachObjectWriter::RecordARMScatteredRelocation(const MCAssembler &Asm,
 862                                                     const MCAsmLayout &Layout,
 863                                                     const MCFragment *Fragment,
 864                                                     const MCFixup &Fixup,
 865                                                     MCValue Target,
 866                                                     unsigned Log2Size,
 867                                                     uint64_t &FixedValue) {
 868   uint32_t FixupOffset = Layout.getFragmentOffset(Fragment)+Fixup.getOffset();
 869   unsigned IsPCRel = isFixupKindPCRel(Asm, Fixup.getKind());
 870   unsigned Type = macho::RIT_Vanilla;
 871
 872   // See <reloc.h>.
 873   const MCSymbol *A = &Target.getSymA()->getSymbol();
 874   MCSymbolData *A_SD = &Asm.getSymbolData(*A);
 875
 876   if (!A_SD->getFragment())
 877     report_fatal_error("symbol '" + A->getName() +
 878                        "' can not be undefined in a subtraction expression");
 879
 880   uint32_t Value = getSymbolAddress(A_SD, Layout);
 881   uint64_t SecAddr = getSectionAddress(A_SD->getFragment()->getParent());
 882   FixedValue += SecAddr;
 883   uint32_t Value2 = 0;
 884
 885   if (const MCSymbolRefExpr *B = Target.getSymB()) {
 886     MCSymbolData *B_SD = &Asm.getSymbolData(B->getSymbol());
 887
 888     if (!B_SD->getFragment())
 889       report_fatal_error("symbol '" + B->getSymbol().getName() +
 890                          "' can not be undefined in a subtraction expression");
 891
 892     // Select the appropriate difference relocation type.
 893     Type = macho::RIT_Difference;
 894     Value2 = getSymbolAddress(B_SD, Layout);
 895     FixedValue -= getSectionAddress(B_SD->getFragment()->getParent());
 896   }
 897
 898   // Relocations are written out in reverse order, so the PAIR comes first.
 899   if (Type == macho::RIT_Difference ||
 900       Type == macho::RIT_Generic_LocalDifference) {
 901     macho::RelocationEntry MRE;
 902     MRE.Word0 = ((0         <<  0) |
 903                  (macho::RIT_Pair  << 24) |
 904                  (Log2Size  << 28) |
 905                  (IsPCRel   << 30) |
 906                  macho::RF_Scattered);
 907     MRE.Word1 = Value2;
 908     Relocations[Fragment->getParent()].push_back(MRE);
 909   }
 910
 911   macho::RelocationEntry MRE;
 912   MRE.Word0 = ((FixupOffset <<  0) |
 913                (Type        << 24) |
 914                (Log2Size    << 28) |
 915                (IsPCRel     << 30) |
 916                macho::RF_Scattered);
 917   MRE.Word1 = Value;
 918   Relocations[Fragment->getParent()].push_back(MRE);
 919 }
 920
 921 void MachObjectWriter::RecordARMMovwMovtRelocation(const MCAssembler &Asm,
 922                                                    const MCAsmLayout &Layout,
 923                                                    const MCFragment *Fragment,
 924                                                    const MCFixup &Fixup,
 925                                                    MCValue Target,
 926                                                    uint64_t &FixedValue) {
 927   uint32_t FixupOffset = Layout.getFragmentOffset(Fragment)+Fixup.getOffset();
 928   unsigned IsPCRel = isFixupKindPCRel(Asm, Fixup.getKind());
 929   unsigned Type = macho::RIT_ARM_Half;
 930
 931   // See <reloc.h>.
 932   const MCSymbol *A = &Target.getSymA()->getSymbol();
 933   MCSymbolData *A_SD = &Asm.getSymbolData(*A);
 934
 935   if (!A_SD->getFragment())
 936     report_fatal_error("symbol '" + A->getName() +
 937                        "' can not be undefined in a subtraction expression");
 938
 939   uint32_t Value = getSymbolAddress(A_SD, Layout);
 940   uint32_t Value2 = 0;
 941   uint64_t SecAddr = getSectionAddress(A_SD->getFragment()->getParent());
 942   FixedValue += SecAddr;
 943
 944   if (const MCSymbolRefExpr *B = Target.getSymB()) {
 945     MCSymbolData *B_SD = &Asm.getSymbolData(B->getSymbol());
 946
 947     if (!B_SD->getFragment())
 948       report_fatal_error("symbol '" + B->getSymbol().getName() +
 949                          "' can not be undefined in a subtraction expression");
 950
 951     // Select the appropriate difference relocation type.
 952     Type = macho::RIT_ARM_HalfDifference;
 953     Value2 = getSymbolAddress(B_SD, Layout);
 954     FixedValue -= getSectionAddress(B_SD->getFragment()->getParent());
 955   }
 956
 957   // Relocations are written out in reverse order, so the PAIR comes first.
 958   // ARM_RELOC_HALF and ARM_RELOC_HALF_SECTDIFF abuse the r_length field:
 959   //
 960   // For these two r_type relocations they always have a pair following them and
 961   // the r_length bits are used differently.  The encoding of the r_length is as
 962   // follows:
 963   //   low bit of r_length:
 964   //      0 - :lower16: for movw instructions
 965   //      1 - :upper16: for movt instructions
 966   //   high bit of r_length:
 967   //      0 - arm instructions
 968   //      1 - thumb instructions
 969   // the other half of the relocated expression is in the following pair
 970   // relocation entry in the the low 16 bits of r_address field.
 971   unsigned ThumbBit = 0;
 972   unsigned MovtBit = 0;
 973   switch ((unsigned)Fixup.getKind()) {
 974   default: break;
 975   case ARM::fixup_arm_movt_hi16:
 976   case ARM::fixup_arm_movt_hi16_pcrel:
 977     MovtBit = 1;
 978     break;
 979   case ARM::fixup_t2_movt_hi16:
 980   case ARM::fixup_t2_movt_hi16_pcrel:
 981     MovtBit = 1;
 982     // Fallthrough
 983   case ARM::fixup_t2_movw_lo16:
 984   case ARM::fixup_t2_movw_lo16_pcrel:
 985     ThumbBit = 1;
 986     break;
 987   }
 988
 989
 990   if (Type == macho::RIT_ARM_HalfDifference) {
 991     uint32_t OtherHalf = MovtBit
 992       ? (FixedValue & 0xffff) : ((FixedValue & 0xffff0000) >> 16);
 993
 994     macho::RelocationEntry MRE;
 995     MRE.Word0 = ((OtherHalf       <<  0) |
 996                  (macho::RIT_Pair << 24) |
 997                  (MovtBit         << 28) |
 998                  (ThumbBit        << 29) |
 999                  (IsPCRel         << 30) |
1000                  macho::RF_Scattered);
1001     MRE.Word1 = Value2;
1002     Relocations[Fragment->getParent()].push_back(MRE);
1003   }
1004
1005   macho::RelocationEntry MRE;
1006   MRE.Word0 = ((FixupOffset <<  0) |
1007                (Type        << 24) |
1008                (MovtBit     << 28) |
1009                (ThumbBit    << 29) |
1010                (IsPCRel     << 30) |
1011                macho::RF_Scattered);
1012   MRE.Word1 = Value;
1013   Relocations[Fragment->getParent()].push_back(MRE);
1014 }
1015
1016 void MachObjectWriter::RecordTLVPRelocation(const MCAssembler &Asm,
1017                                             const MCAsmLayout &Layout,
1018                                             const MCFragment *Fragment,
1019                                             const MCFixup &Fixup,
1020                                             MCValue Target,
1021                                             uint64_t &FixedValue) {
1022   assert(Target.getSymA()->getKind() == MCSymbolRefExpr::VK_TLVP &&
1023          !is64Bit() &&
1024          "Should only be called with a 32-bit TLVP relocation!");
1025
1026   unsigned Log2Size = getFixupKindLog2Size(Fixup.getKind());
1027   uint32_t Value = Layout.getFragmentOffset(Fragment)+Fixup.getOffset();
1028   unsigned IsPCRel = 0;
1029
1030   // Get the symbol data.
1031   MCSymbolData *SD_A = &Asm.getSymbolData(Target.getSymA()->getSymbol());
1032   unsigned Index = SD_A->getIndex();
1033
1034   // We're only going to have a second symbol in pic mode and it'll be a
1035   // subtraction from the picbase. For 32-bit pic the addend is the difference
1036   // between the picbase and the next address.  For 32-bit static the addend is
1037   // zero.
1038   if (Target.getSymB()) {
1039     // If this is a subtraction then we're pcrel.
1040     uint32_t FixupAddress =
1041       getFragmentAddress(Fragment, Layout) + Fixup.getOffset();
1042     MCSymbolData *SD_B = &Asm.getSymbolData(Target.getSymB()->getSymbol());
1043     IsPCRel = 1;
1044     FixedValue = (FixupAddress - getSymbolAddress(SD_B, Layout) +
1045                   Target.getConstant());
1046     FixedValue += 1ULL << Log2Size;
1047   } else {
1048     FixedValue = 0;
1049   }
1050
1051   // struct relocation_info (8 bytes)
1052   macho::RelocationEntry MRE;
1053   MRE.Word0 = Value;
1054   MRE.Word1 = ((Index                  <<  0) |
1055                (IsPCRel                << 24) |
1056                (Log2Size               << 25) |
1057                (1                      << 27) | // Extern
1058                (macho::RIT_Generic_TLV << 28)); // Type
1059   Relocations[Fragment->getParent()].push_back(MRE);
1060 }
1061
1062 bool MachObjectWriter::getARMFixupKindMachOInfo(unsigned Kind,
1063                                                 unsigned &RelocType,
1064                                                 unsigned &Log2Size) {
1065   RelocType = unsigned(macho::RIT_Vanilla);
1066   Log2Size = ~0U;
1067
1068   switch (Kind) {
1069   default:
1070     return false;
1071
1072   case FK_Data_1:
1073     Log2Size = llvm::Log2_32(1);
1074     return true;
1075   case FK_Data_2:
1076     Log2Size = llvm::Log2_32(2);
1077     return true;
1078   case FK_Data_4:
1079     Log2Size = llvm::Log2_32(4);
1080     return true;
1081   case FK_Data_8:
1082     Log2Size = llvm::Log2_32(8);
1083     return true;
1084
1085     // Handle 24-bit branch kinds.
1086   case ARM::fixup_arm_ldst_pcrel_12:
1087   case ARM::fixup_arm_pcrel_10:
1088   case ARM::fixup_arm_adr_pcrel_12:
1089   case ARM::fixup_arm_condbranch:
1090   case ARM::fixup_arm_uncondbranch:
1091     RelocType = unsigned(macho::RIT_ARM_Branch24Bit);
1092     // Report as 'long', even though that is not quite accurate.
1093     Log2Size = llvm::Log2_32(4);
1094     return true;
1095
1096     // Handle Thumb branches.
1097   case ARM::fixup_arm_thumb_br:
1098     RelocType = unsigned(macho::RIT_ARM_ThumbBranch22Bit);
1099     Log2Size = llvm::Log2_32(2);
1100     return true;
1101
1102   case ARM::fixup_arm_thumb_bl:
1103   case ARM::fixup_arm_thumb_blx:
1104     RelocType = unsigned(macho::RIT_ARM_ThumbBranch22Bit);
1105     Log2Size = llvm::Log2_32(4);
1106     return true;
1107
1108   case ARM::fixup_arm_movt_hi16:
1109   case ARM::fixup_arm_movt_hi16_pcrel:
1110   case ARM::fixup_t2_movt_hi16:
1111   case ARM::fixup_t2_movt_hi16_pcrel:
1112     RelocType = unsigned(macho::RIT_ARM_HalfDifference);
1113     // Report as 'long', even though that is not quite accurate.
1114     Log2Size = llvm::Log2_32(4);
1115     return true;
1116
1117   case ARM::fixup_arm_movw_lo16:
1118   case ARM::fixup_arm_movw_lo16_pcrel:
1119   case ARM::fixup_t2_movw_lo16:
1120   case ARM::fixup_t2_movw_lo16_pcrel:
1121     RelocType = unsigned(macho::RIT_ARM_Half);
1122     // Report as 'long', even though that is not quite accurate.
1123     Log2Size = llvm::Log2_32(4);
1124     return true;
1125   }
1126 }
1127 void MachObjectWriter::RecordARMRelocation(const MCAssembler &Asm,
1128                                            const MCAsmLayout &Layout,
1129                                            const MCFragment *Fragment,
1130                                            const MCFixup &Fixup,
1131                                            MCValue Target,
1132                                            uint64_t &FixedValue) {
1133   unsigned IsPCRel = isFixupKindPCRel(Asm, Fixup.getKind());
1134   unsigned Log2Size;
1135   unsigned RelocType = macho::RIT_Vanilla;
1136   if (!getARMFixupKindMachOInfo(Fixup.getKind(), RelocType, Log2Size)) {
1137     report_fatal_error("unknown ARM fixup kind!");
1138     return;
1139   }
1140
1141   // If this is a difference or a defined symbol plus an offset, then we need a
1142   // scattered relocation entry.  Differences always require scattered
1143   // relocations.
1144   if (Target.getSymB()) {
1145     if (RelocType == macho::RIT_ARM_Half ||
1146         RelocType == macho::RIT_ARM_HalfDifference)
1147       return RecordARMMovwMovtRelocation(Asm, Layout, Fragment, Fixup,
1148                                          Target, FixedValue);
1149     return RecordARMScatteredRelocation(Asm, Layout, Fragment, Fixup,
1150                                         Target, Log2Size, FixedValue);
1151   }
1152
1153   // Get the symbol data, if any.
1154   MCSymbolData *SD = 0;
1155   if (Target.getSymA())
1156     SD = &Asm.getSymbolData(Target.getSymA()->getSymbol());
1157
1158   // FIXME: For other platforms, we need to use scattered relocations for
1159   // internal relocations with offsets.  If this is an internal relocation with
1160   // an offset, it also needs a scattered relocation entry.
1161   //
1162   // Is this right for ARM?
1163   uint32_t Offset = Target.getConstant();
1164   if (IsPCRel && RelocType == macho::RIT_Vanilla)
1165     Offset += 1 << Log2Size;
1166   if (Offset && SD && !doesSymbolRequireExternRelocation(SD))
1167     return RecordARMScatteredRelocation(Asm, Layout, Fragment, Fixup, Target,
1168                                         Log2Size, FixedValue);
1169
1170   // See <reloc.h>.
1171   uint32_t FixupOffset = Layout.getFragmentOffset(Fragment)+Fixup.getOffset();
1172   unsigned Index = 0;
1173   unsigned IsExtern = 0;
1174   unsigned Type = 0;
1175
1176   if (Target.isAbsolute()) { // constant
1177     // FIXME!
1178     report_fatal_error("FIXME: relocations to absolute targets "
1179                        "not yet implemented");
1180   } else {
1181     // Resolve constant variables.
1182     if (SD->getSymbol().isVariable()) {
1183       int64_t Res;
1184       if (SD->getSymbol().getVariableValue()->EvaluateAsAbsolute(
1185             Res, Layout, SectionAddress)) {
1186         FixedValue = Res;
1187         return;
1188       }
1189     }
1190
1191     // Check whether we need an external or internal relocation.
1192     if (doesSymbolRequireExternRelocation(SD)) {
1193       IsExtern = 1;
1194       Index = SD->getIndex();
1195
1196       // For external relocations, make sure to offset the fixup value to
1197       // compensate for the addend of the symbol address, if it was
1198       // undefined. This occurs with weak definitions, for example.
1199       if (!SD->Symbol->isUndefined())
1200         FixedValue -= Layout.getSymbolOffset(SD);
1201     } else {
1202       // The index is the section ordinal (1-based).
1203       const MCSectionData &SymSD = Asm.getSectionData(
1204         SD->getSymbol().getSection());
1205       Index = SymSD.getOrdinal() + 1;
1206       FixedValue += getSectionAddress(&SymSD);
1207     }
1208     if (IsPCRel)
1209       FixedValue -= getSectionAddress(Fragment->getParent());
1210
1211     // The type is determined by the fixup kind.
1212     Type = RelocType;
1213   }
1214
1215   // struct relocation_info (8 bytes)
1216   macho::RelocationEntry MRE;
1217   MRE.Word0 = FixupOffset;
1218   MRE.Word1 = ((Index     <<  0) |
1219                (IsPCRel   << 24) |
1220                (Log2Size  << 25) |
1221                (IsExtern  << 27) |
1222                (Type      << 28));
1223   Relocations[Fragment->getParent()].push_back(MRE);
1224 }
1225
1226 void MachObjectWriter::RecordRelocation(const MCAssembler &Asm,
1227                                         const MCAsmLayout &Layout,
1228                                         const MCFragment *Fragment,
1229                                         const MCFixup &Fixup,
1230                                         MCValue Target,
1231                                         uint64_t &FixedValue) {
1232   // FIXME: These needs to be factored into the target Mach-O writer.
1233   if (isARM()) {
1234     RecordARMRelocation(Asm, Layout, Fragment, Fixup, Target, FixedValue);
1235     return;
1236   }
1237   if (is64Bit()) {
1238     RecordX86_64Relocation(Asm, Layout, Fragment, Fixup, Target, FixedValue);
1239     return;
1240   }
1241
1242   unsigned IsPCRel = isFixupKindPCRel(Asm, Fixup.getKind());
1243   unsigned Log2Size = getFixupKindLog2Size(Fixup.getKind());
1244
1245   // If this is a 32-bit TLVP reloc it's handled a bit differently.
1246   if (Target.getSymA() &&
1247       Target.getSymA()->getKind() == MCSymbolRefExpr::VK_TLVP) {
1248     RecordTLVPRelocation(Asm, Layout, Fragment, Fixup, Target, FixedValue);
1249     return;
1250   }
1251
1252   // If this is a difference or a defined symbol plus an offset, then we need a
1253   // scattered relocation entry. Differences always require scattered
1254   // relocations.
1255   if (Target.getSymB())
1256     return RecordScatteredRelocation(Asm, Layout, Fragment, Fixup,
1257                                      Target, Log2Size, FixedValue);
1258
1259   // Get the symbol data, if any.
1260   MCSymbolData *SD = 0;
1261   if (Target.getSymA())
1262     SD = &Asm.getSymbolData(Target.getSymA()->getSymbol());
1263
1264   // If this is an internal relocation with an offset, it also needs a scattered
1265   // relocation entry.
1266   uint32_t Offset = Target.getConstant();
1267   if (IsPCRel)
1268     Offset += 1 << Log2Size;
1269   if (Offset && SD && !doesSymbolRequireExternRelocation(SD))
1270     return RecordScatteredRelocation(Asm, Layout, Fragment, Fixup,
1271                                      Target, Log2Size, FixedValue);
1272
1273   // See <reloc.h>.
1274   uint32_t FixupOffset = Layout.getFragmentOffset(Fragment)+Fixup.getOffset();
1275   unsigned Index = 0;
1276   unsigned IsExtern = 0;
1277   unsigned Type = 0;
1278
1279   if (Target.isAbsolute()) { // constant
1280     // SymbolNum of 0 indicates the absolute section.
1281     //
1282     // FIXME: Currently, these are never generated (see code below). I cannot
1283     // find a case where they are actually emitted.
1284     Type = macho::RIT_Vanilla;
1285   } else {
1286     // Resolve constant variables.
1287     if (SD->getSymbol().isVariable()) {
1288       int64_t Res;
1289       if (SD->getSymbol().getVariableValue()->EvaluateAsAbsolute(
1290             Res, Layout, SectionAddress)) {
1291         FixedValue = Res;
1292         return;
1293       }
1294     }
1295
1296     // Check whether we need an external or internal relocation.
1297     if (doesSymbolRequireExternRelocation(SD)) {
1298       IsExtern = 1;
1299       Index = SD->getIndex();
1300       // For external relocations, make sure to offset the fixup value to
1301       // compensate for the addend of the symbol address, if it was
1302       // undefined. This occurs with weak definitions, for example.
1303       if (!SD->Symbol->isUndefined())
1304         FixedValue -= Layout.getSymbolOffset(SD);
1305     } else {
1306       // The index is the section ordinal (1-based).
1307       const MCSectionData &SymSD = Asm.getSectionData(
1308         SD->getSymbol().getSection());
1309       Index = SymSD.getOrdinal() + 1;
1310       FixedValue += getSectionAddress(&SymSD);
1311     }
1312     if (IsPCRel)
1313       FixedValue -= getSectionAddress(Fragment->getParent());
1314
1315     Type = macho::RIT_Vanilla;
1316   }
1317
1318   // struct relocation_info (8 bytes)
1319   macho::RelocationEntry MRE;
1320   MRE.Word0 = FixupOffset;
1321   MRE.Word1 = ((Index     <<  0) |
1322                (IsPCRel   << 24) |
1323                (Log2Size  << 25) |
1324                (IsExtern  << 27) |
1325                (Type      << 28));
1326   Relocations[Fragment->getParent()].push_back(MRE);
1327 }
1328
1329 void MachObjectWriter::BindIndirectSymbols(MCAssembler &Asm) {
1330   // This is the point where 'as' creates actual symbols for indirect symbols
1331   // (in the following two passes). It would be easier for us to do this sooner
1332   // when we see the attribute, but that makes getting the order in the symbol
1333   // table much more complicated than it is worth.
1334   //
1335   // FIXME: Revisit this when the dust settles.
1336
1337   // Bind non lazy symbol pointers first.
1338   unsigned IndirectIndex = 0;
1339   for (MCAssembler::indirect_symbol_iterator it = Asm.indirect_symbol_begin(),
1340          ie = Asm.indirect_symbol_end(); it != ie; ++it, ++IndirectIndex) {
1341     const MCSectionMachO &Section =
1342       cast<MCSectionMachO>(it->SectionData->getSection());
1343
1344     if (Section.getType() != MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS)
1345       continue;
1346
1347     // Initialize the section indirect symbol base, if necessary.
1348     if (!IndirectSymBase.count(it->SectionData))
1349       IndirectSymBase[it->SectionData] = IndirectIndex;
1350
1351     Asm.getOrCreateSymbolData(*it->Symbol);
1352   }
1353
1354   // Then lazy symbol pointers and symbol stubs.
1355   IndirectIndex = 0;
1356   for (MCAssembler::indirect_symbol_iterator it = Asm.indirect_symbol_begin(),
1357          ie = Asm.indirect_symbol_end(); it != ie; ++it, ++IndirectIndex) {
1358     const MCSectionMachO &Section =
1359       cast<MCSectionMachO>(it->SectionData->getSection());
1360
1361     if (Section.getType() != MCSectionMachO::S_LAZY_SYMBOL_POINTERS &&
1362         Section.getType() != MCSectionMachO::S_SYMBOL_STUBS)
1363       continue;
1364
1365     // Initialize the section indirect symbol base, if necessary.
1366     if (!IndirectSymBase.count(it->SectionData))
1367       IndirectSymBase[it->SectionData] = IndirectIndex;
1368
1369     // Set the symbol type to undefined lazy, but only on construction.
1370     //
1371     // FIXME: Do not hardcode.
1372     bool Created;
1373     MCSymbolData &Entry = Asm.getOrCreateSymbolData(*it->Symbol, &Created);
1374     if (Created)
1375       Entry.setFlags(Entry.getFlags() | 0x0001);
1376   }
1377 }
1378
1379 /// ComputeSymbolTable - Compute the symbol table data
1380 ///
1381 /// \param StringTable [out] - The string table data.
1382 /// \param StringIndexMap [out] - Map from symbol names to offsets in the
1383 /// string table.
1384 void MachObjectWriter::
1385 ComputeSymbolTable(MCAssembler &Asm, SmallString<256> &StringTable,
1386                    std::vector<MachSymbolData> &LocalSymbolData,
1387                    std::vector<MachSymbolData> &ExternalSymbolData,
1388                    std::vector<MachSymbolData> &UndefinedSymbolData) {
1389   // Build section lookup table.
1390   DenseMap<const MCSection*, uint8_t> SectionIndexMap;
1391   unsigned Index = 1;
1392   for (MCAssembler::iterator it = Asm.begin(),
1393          ie = Asm.end(); it != ie; ++it, ++Index)
1394     SectionIndexMap[&it->getSection()] = Index;
1395   assert(Index <= 256 && "Too many sections!");
1396
1397   // Index 0 is always the empty string.
1398   StringMap<uint64_t> StringIndexMap;
1399   StringTable += '\x00';
1400
1401   // Build the symbol arrays and the string table, but only for non-local
1402   // symbols.
1403   //
1404   // The particular order that we collect the symbols and create the string
1405   // table, then sort the symbols is chosen to match 'as'. Even though it
1406   // doesn't matter for correctness, this is important for letting us diff .o
1407   // files.
1408   for (MCAssembler::symbol_iterator it = Asm.symbol_begin(),
1409          ie = Asm.symbol_end(); it != ie; ++it) {
1410     const MCSymbol &Symbol = it->getSymbol();
1411
1412     // Ignore non-linker visible symbols.
1413     if (!Asm.isSymbolLinkerVisible(it->getSymbol()))
1414       continue;
1415
1416     if (!it->isExternal() && !Symbol.isUndefined())
1417       continue;
1418
1419     uint64_t &Entry = StringIndexMap[Symbol.getName()];
1420     if (!Entry) {
1421       Entry = StringTable.size();
1422       StringTable += Symbol.getName();
1423       StringTable += '\x00';
1424     }
1425
1426     MachSymbolData MSD;
1427     MSD.SymbolData = it;
1428     MSD.StringIndex = Entry;
1429
1430     if (Symbol.isUndefined()) {
1431       MSD.SectionIndex = 0;
1432       UndefinedSymbolData.push_back(MSD);
1433     } else if (Symbol.isAbsolute()) {
1434       MSD.SectionIndex = 0;
1435       ExternalSymbolData.push_back(MSD);
1436     } else {
1437       MSD.SectionIndex = SectionIndexMap.lookup(&Symbol.getSection());
1438       assert(MSD.SectionIndex && "Invalid section index!");
1439       ExternalSymbolData.push_back(MSD);
1440     }
1441   }
1442
1443   // Now add the data for local symbols.
1444   for (MCAssembler::symbol_iterator it = Asm.symbol_begin(),
1445          ie = Asm.symbol_end(); it != ie; ++it) {
1446     const MCSymbol &Symbol = it->getSymbol();
1447
1448     // Ignore non-linker visible symbols.
1449     if (!Asm.isSymbolLinkerVisible(it->getSymbol()))
1450       continue;
1451
1452     if (it->isExternal() || Symbol.isUndefined())
1453       continue;
1454
1455     uint64_t &Entry = StringIndexMap[Symbol.getName()];
1456     if (!Entry) {
1457       Entry = StringTable.size();
1458       StringTable += Symbol.getName();
1459       StringTable += '\x00';
1460     }
1461
1462     MachSymbolData MSD;
1463     MSD.SymbolData = it;
1464     MSD.StringIndex = Entry;
1465
1466     if (Symbol.isAbsolute()) {
1467       MSD.SectionIndex = 0;
1468       LocalSymbolData.push_back(MSD);
1469     } else {
1470       MSD.SectionIndex = SectionIndexMap.lookup(&Symbol.getSection());
1471       assert(MSD.SectionIndex && "Invalid section index!");
1472       LocalSymbolData.push_back(MSD);
1473     }
1474   }
1475
1476   // External and undefined symbols are required to be in lexicographic order.
1477   std::sort(ExternalSymbolData.begin(), ExternalSymbolData.end());
1478   std::sort(UndefinedSymbolData.begin(), UndefinedSymbolData.end());
1479
1480   // Set the symbol indices.
1481   Index = 0;
1482   for (unsigned i = 0, e = LocalSymbolData.size(); i != e; ++i)
1483     LocalSymbolData[i].SymbolData->setIndex(Index++);
1484   for (unsigned i = 0, e = ExternalSymbolData.size(); i != e; ++i)
1485     ExternalSymbolData[i].SymbolData->setIndex(Index++);
1486   for (unsigned i = 0, e = UndefinedSymbolData.size(); i != e; ++i)
1487     UndefinedSymbolData[i].SymbolData->setIndex(Index++);
1488
1489   // The string table is padded to a multiple of 4.
1490   while (StringTable.size() % 4)
1491     StringTable += '\x00';
1492 }
1493
1494 void MachObjectWriter::computeSectionAddresses(const MCAssembler &Asm,
1495                                                const MCAsmLayout &Layout) {
1496   uint64_t StartAddress = 0;
1497   const SmallVectorImpl<MCSectionData*> &Order = Layout.getSectionOrder();
1498   for (int i = 0, n = Order.size(); i != n ; ++i) {
1499     const MCSectionData *SD = Order[i];
1500     StartAddress = RoundUpToAlignment(StartAddress, SD->getAlignment());
1501     SectionAddress[SD] = StartAddress;
1502     StartAddress += Layout.getSectionAddressSize(SD);
1503
1504     // Explicitly pad the section to match the alignment requirements of the
1505     // following one. This is for 'gas' compatibility, it shouldn't
1506     /// strictly be necessary.
1507     StartAddress += getPaddingSize(SD, Layout);
1508   }
1509 }
1510
1511 void MachObjectWriter::ExecutePostLayoutBinding(MCAssembler &Asm,
1512                                                 const MCAsmLayout &Layout) {
1513   computeSectionAddresses(Asm, Layout);
1514
1515   // Create symbol data for any indirect symbols.
1516   BindIndirectSymbols(Asm);
1517
1518   // Compute symbol table information and bind symbol indices.
1519   ComputeSymbolTable(Asm, StringTable, LocalSymbolData, ExternalSymbolData,
1520                      UndefinedSymbolData);
1521 }
1522
1523 bool MachObjectWriter::
1524 IsSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
1525                                        const MCSymbolData &DataA,
1526                                        const MCFragment &FB,
1527                                        bool InSet,
1528                                        bool IsPCRel) const {
1529   if (InSet)
1530     return true;
1531
1532   // The effective address is
1533   //     addr(atom(A)) + offset(A)
1534   //   - addr(atom(B)) - offset(B)
1535   // and the offsets are not relocatable, so the fixup is fully resolved when
1536   //  addr(atom(A)) - addr(atom(B)) == 0.
1537   const MCSymbolData *A_Base = 0, *B_Base = 0;
1538
1539   const MCSymbol &SA = DataA.getSymbol().AliasedSymbol();
1540   const MCSection &SecA = SA.getSection();
1541   const MCSection &SecB = FB.getParent()->getSection();
1542
1543   if (IsPCRel) {
1544     // The simple (Darwin, except on x86_64) way of dealing with this was to
1545     // assume that any reference to a temporary symbol *must* be a temporary
1546     // symbol in the same atom, unless the sections differ. Therefore, any PCrel
1547     // relocation to a temporary symbol (in the same section) is fully
1548     // resolved. This also works in conjunction with absolutized .set, which
1549     // requires the compiler to use .set to absolutize the differences between
1550     // symbols which the compiler knows to be assembly time constants, so we
1551     // don't need to worry about considering symbol differences fully resolved.
1552
1553     if (!Asm.getBackend().hasReliableSymbolDifference()) {
1554       if (!SA.isTemporary() || !SA.isInSection() || &SecA != &SecB)
1555         return false;
1556       return true;
1557     }
1558   } else {
1559     if (!TargetObjectWriter->useAggressiveSymbolFolding())
1560       return false;
1561   }
1562
1563   const MCFragment &FA = *Asm.getSymbolData(SA).getFragment();
1564
1565   A_Base = FA.getAtom();
1566   if (!A_Base)
1567     return false;
1568
1569   B_Base = FB.getAtom();
1570   if (!B_Base)
1571     return false;
1572
1573   // If the atoms are the same, they are guaranteed to have the same address.
1574   if (A_Base == B_Base)
1575     return true;
1576
1577   // Otherwise, we can't prove this is fully resolved.
1578   return false;
1579 }
1580
1581 void MachObjectWriter::WriteObject(MCAssembler &Asm, const MCAsmLayout &Layout) {
1582   unsigned NumSections = Asm.size();
1583
1584   // The section data starts after the header, the segment load command (and
1585   // section headers) and the symbol table.
1586   unsigned NumLoadCommands = 1;
1587   uint64_t LoadCommandsSize = is64Bit() ?
1588     macho::SegmentLoadCommand64Size + NumSections * macho::Section64Size :
1589     macho::SegmentLoadCommand32Size + NumSections * macho::Section32Size;
1590
1591   // Add the symbol table load command sizes, if used.
1592   unsigned NumSymbols = LocalSymbolData.size() + ExternalSymbolData.size() +
1593     UndefinedSymbolData.size();
1594   if (NumSymbols) {
1595     NumLoadCommands += 2;
1596     LoadCommandsSize += (macho::SymtabLoadCommandSize +
1597                          macho::DysymtabLoadCommandSize);
1598   }
1599
1600   // Compute the total size of the section data, as well as its file size and vm
1601   // size.
1602   uint64_t SectionDataStart = (is64Bit() ? macho::Header64Size :
1603                                macho::Header32Size) + LoadCommandsSize;
1604   uint64_t SectionDataSize = 0;
1605   uint64_t SectionDataFileSize = 0;
1606   uint64_t VMSize = 0;
1607   for (MCAssembler::const_iterator it = Asm.begin(),
1608          ie = Asm.end(); it != ie; ++it) {
1609     const MCSectionData &SD = *it;
1610     uint64_t Address = getSectionAddress(&SD);
1611     uint64_t Size = Layout.getSectionAddressSize(&SD);
1612     uint64_t FileSize = Layout.getSectionFileSize(&SD);
1613     FileSize += getPaddingSize(&SD, Layout);
1614
1615     VMSize = std::max(VMSize, Address + Size);
1616
1617     if (SD.getSection().isVirtualSection())
1618       continue;
1619
1620     SectionDataSize = std::max(SectionDataSize, Address + Size);
1621     SectionDataFileSize = std::max(SectionDataFileSize, Address + FileSize);
1622   }
1623
1624   // The section data is padded to 4 bytes.
1625   //
1626   // FIXME: Is this machine dependent?
1627   unsigned SectionDataPadding = OffsetToAlignment(SectionDataFileSize, 4);
1628   SectionDataFileSize += SectionDataPadding;
1629
1630   // Write the prolog, starting with the header and load command...
1631   WriteHeader(NumLoadCommands, LoadCommandsSize,
1632               Asm.getSubsectionsViaSymbols());
1633   WriteSegmentLoadCommand(NumSections, VMSize,
1634                           SectionDataStart, SectionDataSize);
1635
1636   // ... and then the section headers.
1637   uint64_t RelocTableEnd = SectionDataStart + SectionDataFileSize;
1638   for (MCAssembler::const_iterator it = Asm.begin(),
1639          ie = Asm.end(); it != ie; ++it) {
1640     std::vector<macho::RelocationEntry> &Relocs = Relocations[it];
1641     unsigned NumRelocs = Relocs.size();
1642     uint64_t SectionStart = SectionDataStart + getSectionAddress(it);
1643     WriteSection(Asm, Layout, *it, SectionStart, RelocTableEnd, NumRelocs);
1644     RelocTableEnd += NumRelocs * macho::RelocationInfoSize;
1645   }
1646
1647   // Write the symbol table load command, if used.
1648   if (NumSymbols) {
1649     unsigned FirstLocalSymbol = 0;
1650     unsigned NumLocalSymbols = LocalSymbolData.size();
1651     unsigned FirstExternalSymbol = FirstLocalSymbol + NumLocalSymbols;
1652     unsigned NumExternalSymbols = ExternalSymbolData.size();
1653     unsigned FirstUndefinedSymbol = FirstExternalSymbol + NumExternalSymbols;
1654     unsigned NumUndefinedSymbols = UndefinedSymbolData.size();
1655     unsigned NumIndirectSymbols = Asm.indirect_symbol_size();
1656     unsigned NumSymTabSymbols =
1657       NumLocalSymbols + NumExternalSymbols + NumUndefinedSymbols;
1658     uint64_t IndirectSymbolSize = NumIndirectSymbols * 4;
1659     uint64_t IndirectSymbolOffset = 0;
1660
1661     // If used, the indirect symbols are written after the section data.
1662     if (NumIndirectSymbols)
1663       IndirectSymbolOffset = RelocTableEnd;
1664
1665     // The symbol table is written after the indirect symbol data.
1666     uint64_t SymbolTableOffset = RelocTableEnd + IndirectSymbolSize;
1667
1668     // The string table is written after symbol table.
1669     uint64_t StringTableOffset =
1670       SymbolTableOffset + NumSymTabSymbols * (is64Bit() ? macho::Nlist64Size :
1671                                               macho::Nlist32Size);
1672     WriteSymtabLoadCommand(SymbolTableOffset, NumSymTabSymbols,
1673                            StringTableOffset, StringTable.size());
1674
1675     WriteDysymtabLoadCommand(FirstLocalSymbol, NumLocalSymbols,
1676                              FirstExternalSymbol, NumExternalSymbols,
1677                              FirstUndefinedSymbol, NumUndefinedSymbols,
1678                              IndirectSymbolOffset, NumIndirectSymbols);
1679   }
1680
1681   // Write the actual section data.
1682   for (MCAssembler::const_iterator it = Asm.begin(),
1683          ie = Asm.end(); it != ie; ++it) {
1684     Asm.WriteSectionData(it, Layout);
1685
1686     uint64_t Pad = getPaddingSize(it, Layout);
1687     for (unsigned int i = 0; i < Pad; ++i)
1688       Write8(0);
1689   }
1690
1691   // Write the extra padding.
1692   WriteZeros(SectionDataPadding);
1693
1694   // Write the relocation entries.
1695   for (MCAssembler::const_iterator it = Asm.begin(),
1696          ie = Asm.end(); it != ie; ++it) {
1697     // Write the section relocation entries, in reverse order to match 'as'
1698     // (approximately, the exact algorithm is more complicated than this).
1699     std::vector<macho::RelocationEntry> &Relocs = Relocations[it];
1700     for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
1701       Write32(Relocs[e - i - 1].Word0);
1702       Write32(Relocs[e - i - 1].Word1);
1703     }
1704   }
1705
1706   // Write the symbol table data, if used.
1707   if (NumSymbols) {
1708     // Write the indirect symbol entries.
1709     for (MCAssembler::const_indirect_symbol_iterator
1710            it = Asm.indirect_symbol_begin(),
1711            ie = Asm.indirect_symbol_end(); it != ie; ++it) {
1712       // Indirect symbols in the non lazy symbol pointer section have some
1713       // special handling.
1714       const MCSectionMachO &Section =
1715         static_cast<const MCSectionMachO&>(it->SectionData->getSection());
1716       if (Section.getType() == MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS) {
1717         // If this symbol is defined and internal, mark it as such.
1718         if (it->Symbol->isDefined() &&
1719             !Asm.getSymbolData(*it->Symbol).isExternal()) {
1720           uint32_t Flags = macho::ISF_Local;
1721           if (it->Symbol->isAbsolute())
1722             Flags |= macho::ISF_Absolute;
1723           Write32(Flags);
1724           continue;
1725         }
1726       }
1727
1728       Write32(Asm.getSymbolData(*it->Symbol).getIndex());
1729     }
1730
1731     // FIXME: Check that offsets match computed ones.
1732
1733     // Write the symbol table entries.
1734     for (unsigned i = 0, e = LocalSymbolData.size(); i != e; ++i)
1735       WriteNlist(LocalSymbolData[i], Layout);
1736     for (unsigned i = 0, e = ExternalSymbolData.size(); i != e; ++i)
1737       WriteNlist(ExternalSymbolData[i], Layout);
1738     for (unsigned i = 0, e = UndefinedSymbolData.size(); i != e; ++i)
1739       WriteNlist(UndefinedSymbolData[i], Layout);
1740
1741     // Write the string table.
1742     OS << StringTable.str();
1743   }
1744 }
1745
1746 MCObjectWriter *llvm::createMachObjectWriter(MCMachObjectTargetWriter *MOTW,
1747                                              raw_ostream &OS,
1748                                              bool IsLittleEndian) {
1749   return new MachObjectWriter(MOTW, OS, IsLittleEndian);
1750 }