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/StringMap.h" 12 #include "llvm/ADT/Twine.h" 13 #include "llvm/MC/MCAssembler.h" 14 #include "llvm/MC/MCAsmBackend.h" 15 #include "llvm/MC/MCAsmLayout.h" 16 #include "llvm/MC/MCExpr.h" 17 #include "llvm/MC/MCFixupKindInfo.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 } 808