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/MCAsmBackend.h"
  16 #include "llvm/MC/MCAsmLayout.h"
  17 #include "llvm/MC/MCExpr.h"
  18 #include "llvm/MC/MCObjectWriter.h"
  19 #include "llvm/MC/MCSectionMachO.h"
  20 #include "llvm/MC/MCSymbol.h"
  21 #include "llvm/MC/MCMachOSymbolFlags.h"
  22 #include "llvm/MC/MCValue.h"
  23 #include "llvm/Object/MachOFormat.h"
  24 #include "llvm/Support/ErrorHandling.h"
  25
  26 #include <vector>
  27 using namespace llvm;
  28 using namespace llvm::object;
  29
  30 bool MachObjectWriter::
  31 doesSymbolRequireExternRelocation(const MCSymbolData *SD) {
  32   // Undefined symbols are always extern.
  33   if (SD->Symbol->isUndefined())
  34     return true;
  35
  36   // References to weak definitions require external relocation entries; the
  37   // definition may not always be the one in the same object file.
  38   if (SD->getFlags() & SF_WeakDefinition)
  39     return true;
  40
  41   // Otherwise, we can use an internal relocation.
  42   return false;
  43 }
  44
  45 bool MachObjectWriter::
  46 MachSymbolData::operator<(const MachSymbolData &RHS) const {
  47   return SymbolData->getSymbol().getName() <
  48     RHS.SymbolData->getSymbol().getName();
  49 }
  50
  51 bool MachObjectWriter::isFixupKindPCRel(const MCAssembler &Asm, unsigned Kind) {
  52   const MCFixupKindInfo &FKI = Asm.getBackend().getFixupKindInfo(
  53     (MCFixupKind) Kind);
  54
  55   return FKI.Flags & MCFixupKindInfo::FKF_IsPCRel;
  56 }
  57
  58 uint64_t MachObjectWriter::getFragmentAddress(const MCFragment *Fragment,
  59                                               const MCAsmLayout &Layout) const {
  60   return getSectionAddress(Fragment->getParent()) +
  61     Layout.getFragmentOffset(Fragment);
  62 }
  63
  64 uint64_t MachObjectWriter::getSymbolAddress(const MCSymbolData* SD,
  65                                             const MCAsmLayout &Layout) const {
  66   const MCSymbol &S = SD->getSymbol();
  67
  68   // If this is a variable, then recursively evaluate now.
  69   if (S.isVariable()) {
  70     MCValue Target;
  71     if (!S.getVariableValue()->EvaluateAsRelocatable(Target, Layout))
  72       report_fatal_error("unable to evaluate offset for variable '" +
  73                          S.getName() + "'");
  74
  75     // Verify that any used symbols are defined.
  76     if (Target.getSymA() && Target.getSymA()->getSymbol().isUndefined())
  77       report_fatal_error("unable to evaluate offset to undefined symbol '" +
  78                          Target.getSymA()->getSymbol().getName() + "'");
  79     if (Target.getSymB() && Target.getSymB()->getSymbol().isUndefined())
  80       report_fatal_error("unable to evaluate offset to undefined symbol '" +
  81                          Target.getSymB()->getSymbol().getName() + "'");
  82
  83     uint64_t Address = Target.getConstant();
  84     if (Target.getSymA())
  85       Address += getSymbolAddress(&Layout.getAssembler().getSymbolData(
  86                                     Target.getSymA()->getSymbol()), Layout);
  87     if (Target.getSymB())
  88       Address += getSymbolAddress(&Layout.getAssembler().getSymbolData(
  89                                     Target.getSymB()->getSymbol()), Layout);
  90     return Address;
  91   }
  92
  93   return getSectionAddress(SD->getFragment()->getParent()) +
  94     Layout.getSymbolOffset(SD);
  95 }
  96
  97 uint64_t MachObjectWriter::getPaddingSize(const MCSectionData *SD,
  98                                           const MCAsmLayout &Layout) const {
  99   uint64_t EndAddr = getSectionAddress(SD) + Layout.getSectionAddressSize(SD);
 100   unsigned Next = SD->getLayoutOrder() + 1;
 101   if (Next >= Layout.getSectionOrder().size())
 102     return 0;
 103
 104   const MCSectionData &NextSD = *Layout.getSectionOrder()[Next];
 105   if (NextSD.getSection().isVirtualSection())
 106     return 0;
 107   return OffsetToAlignment(EndAddr, NextSD.getAlignment());
 108 }
 109
 110 void MachObjectWriter::WriteHeader(unsigned NumLoadCommands,
 111                                    unsigned LoadCommandsSize,
 112                                    bool SubsectionsViaSymbols) {
 113   uint32_t Flags = 0;
 114
 115   if (SubsectionsViaSymbols)
 116     Flags |= macho::HF_SubsectionsViaSymbols;
 117
 118   // struct mach_header (28 bytes) or
 119   // struct mach_header_64 (32 bytes)
 120
 121   uint64_t Start = OS.tell();
 122   (void) Start;
 123
 124   Write32(is64Bit() ? macho::HM_Object64 : macho::HM_Object32);
 125
 126   Write32(TargetObjectWriter->getCPUType());
 127   Write32(TargetObjectWriter->getCPUSubtype());
 128
 129   Write32(macho::HFT_Object);
 130   Write32(NumLoadCommands);
 131   Write32(LoadCommandsSize);
 132   Write32(Flags);
 133   if (is64Bit())
 134     Write32(0); // reserved
 135
 136   assert(OS.tell() - Start ==
 137          (is64Bit() ? macho::Header64Size : macho::Header32Size));
 138 }
 139
 140 /// WriteSegmentLoadCommand - Write a segment load command.
 141 ///
 142 /// \arg NumSections - The number of sections in this segment.
 143 /// \arg SectionDataSize - The total size of the sections.
 144 void MachObjectWriter::WriteSegmentLoadCommand(unsigned NumSections,
 145                                                uint64_t VMSize,
 146                                                uint64_t SectionDataStartOffset,
 147                                                uint64_t SectionDataSize) {
 148   // struct segment_command (56 bytes) or
 149   // struct segment_command_64 (72 bytes)
 150
 151   uint64_t Start = OS.tell();
 152   (void) Start;
 153
 154   unsigned SegmentLoadCommandSize =
 155     is64Bit() ? macho::SegmentLoadCommand64Size:
 156     macho::SegmentLoadCommand32Size;
 157   Write32(is64Bit() ? macho::LCT_Segment64 : macho::LCT_Segment);
 158   Write32(SegmentLoadCommandSize +
 159           NumSections * (is64Bit() ? macho::Section64Size :
 160                          macho::Section32Size));
 161
 162   WriteBytes("", 16);
 163   if (is64Bit()) {
 164     Write64(0); // vmaddr
 165     Write64(VMSize); // vmsize
 166     Write64(SectionDataStartOffset); // file offset
 167     Write64(SectionDataSize); // file size
 168   } else {
 169     Write32(0); // vmaddr
 170     Write32(VMSize); // vmsize
 171     Write32(SectionDataStartOffset); // file offset
 172     Write32(SectionDataSize); // file size
 173   }
 174   Write32(0x7); // maxprot
 175   Write32(0x7); // initprot
 176   Write32(NumSections);
 177   Write32(0); // flags
 178
 179   assert(OS.tell() - Start == SegmentLoadCommandSize);
 180 }
 181
 182 void MachObjectWriter::WriteSection(const MCAssembler &Asm,
 183                                     const MCAsmLayout &Layout,
 184                                     const MCSectionData &SD,
 185                                     uint64_t FileOffset,
 186                                     uint64_t RelocationsStart,
 187                                     unsigned NumRelocations) {
 188   uint64_t SectionSize = Layout.getSectionAddressSize(&SD);
 189
 190   // The offset is unused for virtual sections.
 191   if (SD.getSection().isVirtualSection()) {
 192     assert(Layout.getSectionFileSize(&SD) == 0 && "Invalid file size!");
 193     FileOffset = 0;
 194   }
 195
 196   // struct section (68 bytes) or
 197   // struct section_64 (80 bytes)
 198
 199   uint64_t Start = OS.tell();
 200   (void) Start;
 201
 202   const MCSectionMachO &Section = cast<MCSectionMachO>(SD.getSection());
 203   WriteBytes(Section.getSectionName(), 16);
 204   WriteBytes(Section.getSegmentName(), 16);
 205   if (is64Bit()) {
 206     Write64(getSectionAddress(&SD)); // address
 207     Write64(SectionSize); // size
 208   } else {
 209     Write32(getSectionAddress(&SD)); // address
 210     Write32(SectionSize); // size
 211   }
 212   Write32(FileOffset);
 213
 214   unsigned Flags = Section.getTypeAndAttributes();
 215   if (SD.hasInstructions())
 216     Flags |= MCSectionMachO::S_ATTR_SOME_INSTRUCTIONS;
 217
 218   assert(isPowerOf2_32(SD.getAlignment()) && "Invalid alignment!");
 219   Write32(Log2_32(SD.getAlignment()));
 220   Write32(NumRelocations ? RelocationsStart : 0);
 221   Write32(NumRelocations);
 222   Write32(Flags);
 223   Write32(IndirectSymBase.lookup(&SD)); // reserved1
 224   Write32(Section.getStubSize()); // reserved2
 225   if (is64Bit())
 226     Write32(0); // reserved3
 227
 228   assert(OS.tell() - Start == (is64Bit() ? macho::Section64Size :
 229                                macho::Section32Size));
 230 }
 231
 232 void MachObjectWriter::WriteSymtabLoadCommand(uint32_t SymbolOffset,
 233                                               uint32_t NumSymbols,
 234                                               uint32_t StringTableOffset,
 235                                               uint32_t StringTableSize) {
 236   // struct symtab_command (24 bytes)
 237
 238   uint64_t Start = OS.tell();
 239   (void) Start;
 240
 241   Write32(macho::LCT_Symtab);
 242   Write32(macho::SymtabLoadCommandSize);
 243   Write32(SymbolOffset);
 244   Write32(NumSymbols);
 245   Write32(StringTableOffset);
 246   Write32(StringTableSize);
 247
 248   assert(OS.tell() - Start == macho::SymtabLoadCommandSize);
 249 }
 250
 251 void MachObjectWriter::WriteDysymtabLoadCommand(uint32_t FirstLocalSymbol,
 252                                                 uint32_t NumLocalSymbols,
 253                                                 uint32_t FirstExternalSymbol,
 254                                                 uint32_t NumExternalSymbols,
 255                                                 uint32_t FirstUndefinedSymbol,
 256                                                 uint32_t NumUndefinedSymbols,
 257                                                 uint32_t IndirectSymbolOffset,
 258                                                 uint32_t NumIndirectSymbols) {
 259   // struct dysymtab_command (80 bytes)
 260
 261   uint64_t Start = OS.tell();
 262   (void) Start;
 263
 264   Write32(macho::LCT_Dysymtab);
 265   Write32(macho::DysymtabLoadCommandSize);
 266   Write32(FirstLocalSymbol);
 267   Write32(NumLocalSymbols);
 268   Write32(FirstExternalSymbol);
 269   Write32(NumExternalSymbols);
 270   Write32(FirstUndefinedSymbol);
 271   Write32(NumUndefinedSymbols);
 272   Write32(0); // tocoff
 273   Write32(0); // ntoc
 274   Write32(0); // modtaboff
 275   Write32(0); // nmodtab
 276   Write32(0); // extrefsymoff
 277   Write32(0); // nextrefsyms
 278   Write32(IndirectSymbolOffset);
 279   Write32(NumIndirectSymbols);
 280   Write32(0); // extreloff
 281   Write32(0); // nextrel
 282   Write32(0); // locreloff
 283   Write32(0); // nlocrel
 284
 285   assert(OS.tell() - Start == macho::DysymtabLoadCommandSize);
 286 }
 287
 288 void MachObjectWriter::WriteNlist(MachSymbolData &MSD,
 289                                   const MCAsmLayout &Layout) {
 290   MCSymbolData &Data = *MSD.SymbolData;
 291   const MCSymbol &Symbol = Data.getSymbol();
 292   uint8_t Type = 0;
 293   uint16_t Flags = Data.getFlags();
 294   uint64_t Address = 0;
 295
 296   // Set the N_TYPE bits. See <mach-o/nlist.h>.
 297   //
 298   // FIXME: Are the prebound or indirect fields possible here?
 299   if (Symbol.isUndefined())
 300     Type = macho::STT_Undefined;
 301   else if (Symbol.isAbsolute())
 302     Type = macho::STT_Absolute;
 303   else
 304     Type = macho::STT_Section;
 305
 306   // FIXME: Set STAB bits.
 307
 308   if (Data.isPrivateExtern())
 309     Type |= macho::STF_PrivateExtern;
 310
 311   // Set external bit.
 312   if (Data.isExternal() || Symbol.isUndefined())
 313     Type |= macho::STF_External;
 314
 315   // Compute the symbol address.
 316   if (Symbol.isDefined()) {
 317     if (Symbol.isAbsolute()) {
 318       Address = cast<MCConstantExpr>(Symbol.getVariableValue())->getValue();
 319     } else {
 320       Address = getSymbolAddress(&Data, Layout);
 321     }
 322   } else if (Data.isCommon()) {
 323     // Common symbols are encoded with the size in the address
 324     // field, and their alignment in the flags.
 325     Address = Data.getCommonSize();
 326
 327     // Common alignment is packed into the 'desc' bits.
 328     if (unsigned Align = Data.getCommonAlignment()) {
 329       unsigned Log2Size = Log2_32(Align);
 330       assert((1U << Log2Size) == Align && "Invalid 'common' alignment!");
 331       if (Log2Size > 15)
 332         report_fatal_error("invalid 'common' alignment '" +
 333                            Twine(Align) + "'");
 334       // FIXME: Keep this mask with the SymbolFlags enumeration.
 335       Flags = (Flags & 0xF0FF) | (Log2Size << 8);
 336     }
 337   }
 338
 339   // struct nlist (12 bytes)
 340
 341   Write32(MSD.StringIndex);
 342   Write8(Type);
 343   Write8(MSD.SectionIndex);
 344
 345   // The Mach-O streamer uses the lowest 16-bits of the flags for the 'desc'
 346   // value.
 347   Write16(Flags);
 348   if (is64Bit())
 349     Write64(Address);
 350   else
 351     Write32(Address);
 352 }
 353
 354 void MachObjectWriter::RecordRelocation(const MCAssembler &Asm,
 355                                         const MCAsmLayout &Layout,
 356                                         const MCFragment *Fragment,
 357                                         const MCFixup &Fixup,
 358                                         MCValue Target,
 359                                         uint64_t &FixedValue) {
 360   TargetObjectWriter->RecordRelocation(this, Asm, Layout, Fragment, Fixup,
 361                                        Target, FixedValue);
 362 }
 363
 364 void MachObjectWriter::BindIndirectSymbols(MCAssembler &Asm) {
 365   // This is the point where 'as' creates actual symbols for indirect symbols
 366   // (in the following two passes). It would be easier for us to do this sooner
 367   // when we see the attribute, but that makes getting the order in the symbol
 368   // table much more complicated than it is worth.
 369   //
 370   // FIXME: Revisit this when the dust settles.
 371
 372   // Bind non lazy symbol pointers first.
 373   unsigned IndirectIndex = 0;
 374   for (MCAssembler::indirect_symbol_iterator it = Asm.indirect_symbol_begin(),
 375          ie = Asm.indirect_symbol_end(); it != ie; ++it, ++IndirectIndex) {
 376     const MCSectionMachO &Section =
 377       cast<MCSectionMachO>(it->SectionData->getSection());
 378
 379     if (Section.getType() != MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS)
 380       continue;
 381
 382     // Initialize the section indirect symbol base, if necessary.
 383     if (!IndirectSymBase.count(it->SectionData))
 384       IndirectSymBase[it->SectionData] = IndirectIndex;
 385
 386     Asm.getOrCreateSymbolData(*it->Symbol);
 387   }
 388
 389   // Then lazy symbol pointers and symbol stubs.
 390   IndirectIndex = 0;
 391   for (MCAssembler::indirect_symbol_iterator it = Asm.indirect_symbol_begin(),
 392          ie = Asm.indirect_symbol_end(); it != ie; ++it, ++IndirectIndex) {
 393     const MCSectionMachO &Section =
 394       cast<MCSectionMachO>(it->SectionData->getSection());
 395
 396     if (Section.getType() != MCSectionMachO::S_LAZY_SYMBOL_POINTERS &&
 397         Section.getType() != MCSectionMachO::S_SYMBOL_STUBS)
 398       continue;
 399
 400     // Initialize the section indirect symbol base, if necessary.
 401     if (!IndirectSymBase.count(it->SectionData))
 402       IndirectSymBase[it->SectionData] = IndirectIndex;
 403
 404     // Set the symbol type to undefined lazy, but only on construction.
 405     //
 406     // FIXME: Do not hardcode.
 407     bool Created;
 408     MCSymbolData &Entry = Asm.getOrCreateSymbolData(*it->Symbol, &Created);
 409     if (Created)
 410       Entry.setFlags(Entry.getFlags() | 0x0001);
 411   }
 412 }
 413
 414 /// ComputeSymbolTable - Compute the symbol table data
 415 ///
 416 /// \param StringTable [out] - The string table data.
 417 /// \param StringIndexMap [out] - Map from symbol names to offsets in the
 418 /// string table.
 419 void MachObjectWriter::
 420 ComputeSymbolTable(MCAssembler &Asm, SmallString<256> &StringTable,
 421                    std::vector<MachSymbolData> &LocalSymbolData,
 422                    std::vector<MachSymbolData> &ExternalSymbolData,
 423                    std::vector<MachSymbolData> &UndefinedSymbolData) {
 424   // Build section lookup table.
 425   DenseMap<const MCSection*, uint8_t> SectionIndexMap;
 426   unsigned Index = 1;
 427   for (MCAssembler::iterator it = Asm.begin(),
 428          ie = Asm.end(); it != ie; ++it, ++Index)
 429     SectionIndexMap[&it->getSection()] = Index;
 430   assert(Index <= 256 && "Too many sections!");
 431
 432   // Index 0 is always the empty string.
 433   StringMap<uint64_t> StringIndexMap;
 434   StringTable += '\x00';
 435
 436   // Build the symbol arrays and the string table, but only for non-local
 437   // symbols.
 438   //
 439   // The particular order that we collect the symbols and create the string
 440   // table, then sort the symbols is chosen to match 'as'. Even though it
 441   // doesn't matter for correctness, this is important for letting us diff .o
 442   // files.
 443   for (MCAssembler::symbol_iterator it = Asm.symbol_begin(),
 444          ie = Asm.symbol_end(); it != ie; ++it) {
 445     const MCSymbol &Symbol = it->getSymbol();
 446
 447     // Ignore non-linker visible symbols.
 448     if (!Asm.isSymbolLinkerVisible(it->getSymbol()))
 449       continue;
 450
 451     if (!it->isExternal() && !Symbol.isUndefined())
 452       continue;
 453
 454     uint64_t &Entry = StringIndexMap[Symbol.getName()];
 455     if (!Entry) {
 456       Entry = StringTable.size();
 457       StringTable += Symbol.getName();
 458       StringTable += '\x00';
 459     }
 460
 461     MachSymbolData MSD;
 462     MSD.SymbolData = it;
 463     MSD.StringIndex = Entry;
 464
 465     if (Symbol.isUndefined()) {
 466       MSD.SectionIndex = 0;
 467       UndefinedSymbolData.push_back(MSD);
 468     } else if (Symbol.isAbsolute()) {
 469       MSD.SectionIndex = 0;
 470       ExternalSymbolData.push_back(MSD);
 471     } else {
 472       MSD.SectionIndex = SectionIndexMap.lookup(&Symbol.getSection());
 473       assert(MSD.SectionIndex && "Invalid section index!");
 474       ExternalSymbolData.push_back(MSD);
 475     }
 476   }
 477
 478   // Now add the data for local symbols.
 479   for (MCAssembler::symbol_iterator it = Asm.symbol_begin(),
 480          ie = Asm.symbol_end(); it != ie; ++it) {
 481     const MCSymbol &Symbol = it->getSymbol();
 482
 483     // Ignore non-linker visible symbols.
 484     if (!Asm.isSymbolLinkerVisible(it->getSymbol()))
 485       continue;
 486
 487     if (it->isExternal() || Symbol.isUndefined())
 488       continue;
 489
 490     uint64_t &Entry = StringIndexMap[Symbol.getName()];
 491     if (!Entry) {
 492       Entry = StringTable.size();
 493       StringTable += Symbol.getName();
 494       StringTable += '\x00';
 495     }
 496
 497     MachSymbolData MSD;
 498     MSD.SymbolData = it;
 499     MSD.StringIndex = Entry;
 500
 501     if (Symbol.isAbsolute()) {
 502       MSD.SectionIndex = 0;
 503       LocalSymbolData.push_back(MSD);
 504     } else {
 505       MSD.SectionIndex = SectionIndexMap.lookup(&Symbol.getSection());
 506       assert(MSD.SectionIndex && "Invalid section index!");
 507       LocalSymbolData.push_back(MSD);
 508     }
 509   }
 510
 511   // External and undefined symbols are required to be in lexicographic order.
 512   std::sort(ExternalSymbolData.begin(), ExternalSymbolData.end());
 513   std::sort(UndefinedSymbolData.begin(), UndefinedSymbolData.end());
 514
 515   // Set the symbol indices.
 516   Index = 0;
 517   for (unsigned i = 0, e = LocalSymbolData.size(); i != e; ++i)
 518     LocalSymbolData[i].SymbolData->setIndex(Index++);
 519   for (unsigned i = 0, e = ExternalSymbolData.size(); i != e; ++i)
 520     ExternalSymbolData[i].SymbolData->setIndex(Index++);
 521   for (unsigned i = 0, e = UndefinedSymbolData.size(); i != e; ++i)
 522     UndefinedSymbolData[i].SymbolData->setIndex(Index++);
 523
 524   // The string table is padded to a multiple of 4.
 525   while (StringTable.size() % 4)
 526     StringTable += '\x00';
 527 }
 528
 529 void MachObjectWriter::computeSectionAddresses(const MCAssembler &Asm,
 530                                                const MCAsmLayout &Layout) {
 531   uint64_t StartAddress = 0;
 532   const SmallVectorImpl<MCSectionData*> &Order = Layout.getSectionOrder();
 533   for (int i = 0, n = Order.size(); i != n ; ++i) {
 534     const MCSectionData *SD = Order[i];
 535     StartAddress = RoundUpToAlignment(StartAddress, SD->getAlignment());
 536     SectionAddress[SD] = StartAddress;
 537     StartAddress += Layout.getSectionAddressSize(SD);
 538
 539     // Explicitly pad the section to match the alignment requirements of the
 540     // following one. This is for 'gas' compatibility, it shouldn't
 541     /// strictly be necessary.
 542     StartAddress += getPaddingSize(SD, Layout);
 543   }
 544 }
 545
 546 void MachObjectWriter::ExecutePostLayoutBinding(MCAssembler &Asm,
 547                                                 const MCAsmLayout &Layout) {
 548   computeSectionAddresses(Asm, Layout);
 549
 550   // Create symbol data for any indirect symbols.
 551   BindIndirectSymbols(Asm);
 552
 553   // Compute symbol table information and bind symbol indices.
 554   ComputeSymbolTable(Asm, StringTable, LocalSymbolData, ExternalSymbolData,
 555                      UndefinedSymbolData);
 556 }
 557
 558 bool MachObjectWriter::
 559 IsSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
 560                                        const MCSymbolData &DataA,
 561                                        const MCFragment &FB,
 562                                        bool InSet,
 563                                        bool IsPCRel) const {
 564   if (InSet)
 565     return true;
 566
 567   // The effective address is
 568   //     addr(atom(A)) + offset(A)
 569   //   - addr(atom(B)) - offset(B)
 570   // and the offsets are not relocatable, so the fixup is fully resolved when
 571   //  addr(atom(A)) - addr(atom(B)) == 0.
 572   const MCSymbolData *A_Base = 0, *B_Base = 0;
 573
 574   const MCSymbol &SA = DataA.getSymbol().AliasedSymbol();
 575   const MCSection &SecA = SA.getSection();
 576   const MCSection &SecB = FB.getParent()->getSection();
 577
 578   if (IsPCRel) {
 579     // The simple (Darwin, except on x86_64) way of dealing with this was to
 580     // assume that any reference to a temporary symbol *must* be a temporary
 581     // symbol in the same atom, unless the sections differ. Therefore, any PCrel
 582     // relocation to a temporary symbol (in the same section) is fully
 583     // resolved. This also works in conjunction with absolutized .set, which
 584     // requires the compiler to use .set to absolutize the differences between
 585     // symbols which the compiler knows to be assembly time constants, so we
 586     // don't need to worry about considering symbol differences fully resolved.
 587     //
 588     // If the file isn't using sub-sections-via-symbols, we can make the
 589     // same assumptions about any symbol that we normally make about
 590     // assembler locals.
 591
 592     if (!Asm.getBackend().hasReliableSymbolDifference()) {
 593       if (!SA.isInSection() || &SecA != &SecB ||
 594           (!SA.isTemporary() &&
 595            FB.getAtom() != Asm.getSymbolData(SA).getFragment()->getAtom() &&
 596            Asm.getSubsectionsViaSymbols()))
 597         return false;
 598       return true;
 599     }
 600     // For Darwin x86_64, there is one special case when the reference IsPCRel.
 601     // If the fragment with the reference does not have a base symbol but meets
 602     // the simple way of dealing with this, in that it is a temporary symbol in
 603     // the same atom then it is assumed to be fully resolved.  This is needed so
 604     // a relocation entry is not created and so the static linker does not
 605     // mess up the reference later.
 606     else if(!FB.getAtom() &&
 607             SA.isTemporary() && SA.isInSection() && &SecA == &SecB){
 608       return true;
 609     }
 610   } else {
 611     if (!TargetObjectWriter->useAggressiveSymbolFolding())
 612       return false;
 613   }
 614
 615   const MCFragment *FA = Asm.getSymbolData(SA).getFragment();
 616
 617   // Bail if the symbol has no fragment.
 618   if (!FA)
 619     return false;
 620
 621   A_Base = FA->getAtom();
 622   if (!A_Base)
 623     return false;
 624
 625   B_Base = FB.getAtom();
 626   if (!B_Base)
 627     return false;
 628
 629   // If the atoms are the same, they are guaranteed to have the same address.
 630   if (A_Base == B_Base)
 631     return true;
 632
 633   // Otherwise, we can't prove this is fully resolved.
 634   return false;
 635 }
 636
 637 void MachObjectWriter::WriteObject(MCAssembler &Asm,
 638                                    const MCAsmLayout &Layout) {
 639   unsigned NumSections = Asm.size();
 640
 641   // The section data starts after the header, the segment load command (and
 642   // section headers) and the symbol table.
 643   unsigned NumLoadCommands = 1;
 644   uint64_t LoadCommandsSize = is64Bit() ?
 645     macho::SegmentLoadCommand64Size + NumSections * macho::Section64Size :
 646     macho::SegmentLoadCommand32Size + NumSections * macho::Section32Size;
 647
 648   // Add the symbol table load command sizes, if used.
 649   unsigned NumSymbols = LocalSymbolData.size() + ExternalSymbolData.size() +
 650     UndefinedSymbolData.size();
 651   if (NumSymbols) {
 652     NumLoadCommands += 2;
 653     LoadCommandsSize += (macho::SymtabLoadCommandSize +
 654                          macho::DysymtabLoadCommandSize);
 655   }
 656
 657   // Compute the total size of the section data, as well as its file size and vm
 658   // size.
 659   uint64_t SectionDataStart = (is64Bit() ? macho::Header64Size :
 660                                macho::Header32Size) + LoadCommandsSize;
 661   uint64_t SectionDataSize = 0;
 662   uint64_t SectionDataFileSize = 0;
 663   uint64_t VMSize = 0;
 664   for (MCAssembler::const_iterator it = Asm.begin(),
 665          ie = Asm.end(); it != ie; ++it) {
 666     const MCSectionData &SD = *it;
 667     uint64_t Address = getSectionAddress(&SD);
 668     uint64_t Size = Layout.getSectionAddressSize(&SD);
 669     uint64_t FileSize = Layout.getSectionFileSize(&SD);
 670     FileSize += getPaddingSize(&SD, Layout);
 671
 672     VMSize = std::max(VMSize, Address + Size);
 673
 674     if (SD.getSection().isVirtualSection())
 675       continue;
 676
 677     SectionDataSize = std::max(SectionDataSize, Address + Size);
 678     SectionDataFileSize = std::max(SectionDataFileSize, Address + FileSize);
 679   }
 680
 681   // The section data is padded to 4 bytes.
 682   //
 683   // FIXME: Is this machine dependent?
 684   unsigned SectionDataPadding = OffsetToAlignment(SectionDataFileSize, 4);
 685   SectionDataFileSize += SectionDataPadding;
 686
 687   // Write the prolog, starting with the header and load command...
 688   WriteHeader(NumLoadCommands, LoadCommandsSize,
 689               Asm.getSubsectionsViaSymbols());
 690   WriteSegmentLoadCommand(NumSections, VMSize,
 691                           SectionDataStart, SectionDataSize);
 692
 693   // ... and then the section headers.
 694   uint64_t RelocTableEnd = SectionDataStart + SectionDataFileSize;
 695   for (MCAssembler::const_iterator it = Asm.begin(),
 696          ie = Asm.end(); it != ie; ++it) {
 697     std::vector<macho::RelocationEntry> &Relocs = Relocations[it];
 698     unsigned NumRelocs = Relocs.size();
 699     uint64_t SectionStart = SectionDataStart + getSectionAddress(it);
 700     WriteSection(Asm, Layout, *it, SectionStart, RelocTableEnd, NumRelocs);
 701     RelocTableEnd += NumRelocs * macho::RelocationInfoSize;
 702   }
 703
 704   // Write the symbol table load command, if used.
 705   if (NumSymbols) {
 706     unsigned FirstLocalSymbol = 0;
 707     unsigned NumLocalSymbols = LocalSymbolData.size();
 708     unsigned FirstExternalSymbol = FirstLocalSymbol + NumLocalSymbols;
 709     unsigned NumExternalSymbols = ExternalSymbolData.size();
 710     unsigned FirstUndefinedSymbol = FirstExternalSymbol + NumExternalSymbols;
 711     unsigned NumUndefinedSymbols = UndefinedSymbolData.size();
 712     unsigned NumIndirectSymbols = Asm.indirect_symbol_size();
 713     unsigned NumSymTabSymbols =
 714       NumLocalSymbols + NumExternalSymbols + NumUndefinedSymbols;
 715     uint64_t IndirectSymbolSize = NumIndirectSymbols * 4;
 716     uint64_t IndirectSymbolOffset = 0;
 717
 718     // If used, the indirect symbols are written after the section data.
 719     if (NumIndirectSymbols)
 720       IndirectSymbolOffset = RelocTableEnd;
 721
 722     // The symbol table is written after the indirect symbol data.
 723     uint64_t SymbolTableOffset = RelocTableEnd + IndirectSymbolSize;
 724
 725     // The string table is written after symbol table.
 726     uint64_t StringTableOffset =
 727       SymbolTableOffset + NumSymTabSymbols * (is64Bit() ? macho::Nlist64Size :
 728                                               macho::Nlist32Size);
 729     WriteSymtabLoadCommand(SymbolTableOffset, NumSymTabSymbols,
 730                            StringTableOffset, StringTable.size());
 731
 732     WriteDysymtabLoadCommand(FirstLocalSymbol, NumLocalSymbols,
 733                              FirstExternalSymbol, NumExternalSymbols,
 734                              FirstUndefinedSymbol, NumUndefinedSymbols,
 735                              IndirectSymbolOffset, NumIndirectSymbols);
 736   }
 737
 738   // Write the actual section data.
 739   for (MCAssembler::const_iterator it = Asm.begin(),
 740          ie = Asm.end(); it != ie; ++it) {
 741     Asm.writeSectionData(it, Layout);
 742
 743     uint64_t Pad = getPaddingSize(it, Layout);
 744     for (unsigned int i = 0; i < Pad; ++i)
 745       Write8(0);
 746   }
 747
 748   // Write the extra padding.
 749   WriteZeros(SectionDataPadding);
 750
 751   // Write the relocation entries.
 752   for (MCAssembler::const_iterator it = Asm.begin(),
 753          ie = Asm.end(); it != ie; ++it) {
 754     // Write the section relocation entries, in reverse order to match 'as'
 755     // (approximately, the exact algorithm is more complicated than this).
 756     std::vector<macho::RelocationEntry> &Relocs = Relocations[it];
 757     for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
 758       Write32(Relocs[e - i - 1].Word0);
 759       Write32(Relocs[e - i - 1].Word1);
 760     }
 761   }
 762
 763   // Write the symbol table data, if used.
 764   if (NumSymbols) {
 765     // Write the indirect symbol entries.
 766     for (MCAssembler::const_indirect_symbol_iterator
 767            it = Asm.indirect_symbol_begin(),
 768            ie = Asm.indirect_symbol_end(); it != ie; ++it) {
 769       // Indirect symbols in the non lazy symbol pointer section have some
 770       // special handling.
 771       const MCSectionMachO &Section =
 772         static_cast<const MCSectionMachO&>(it->SectionData->getSection());
 773       if (Section.getType() == MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS) {
 774         // If this symbol is defined and internal, mark it as such.
 775         if (it->Symbol->isDefined() &&
 776             !Asm.getSymbolData(*it->Symbol).isExternal()) {
 777           uint32_t Flags = macho::ISF_Local;
 778           if (it->Symbol->isAbsolute())
 779             Flags |= macho::ISF_Absolute;
 780           Write32(Flags);
 781           continue;
 782         }
 783       }
 784
 785       Write32(Asm.getSymbolData(*it->Symbol).getIndex());
 786     }
 787
 788     // FIXME: Check that offsets match computed ones.
 789
 790     // Write the symbol table entries.
 791     for (unsigned i = 0, e = LocalSymbolData.size(); i != e; ++i)
 792       WriteNlist(LocalSymbolData[i], Layout);
 793     for (unsigned i = 0, e = ExternalSymbolData.size(); i != e; ++i)
 794       WriteNlist(ExternalSymbolData[i], Layout);
 795     for (unsigned i = 0, e = UndefinedSymbolData.size(); i != e; ++i)
 796       WriteNlist(UndefinedSymbolData[i], Layout);
 797
 798     // Write the string table.
 799     OS << StringTable.str();
 800   }
 801 }
 802
 803 MCObjectWriter *llvm::createMachObjectWriter(MCMachObjectTargetWriter *MOTW,
 804                                              raw_ostream &OS,
 805                                              bool IsLittleEndian) {
 806   return new MachObjectWriter(MOTW, OS, IsLittleEndian);
 807 }