LLVM  6.0.0svn
MachObjectWriter.cpp
Go to the documentation of this file.
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/ADT/DenseMap.h"
11 #include "llvm/ADT/Twine.h"
14 #include "llvm/MC/MCAsmBackend.h"
15 #include "llvm/MC/MCAsmLayout.h"
16 #include "llvm/MC/MCAssembler.h"
17 #include "llvm/MC/MCDirectives.h"
18 #include "llvm/MC/MCExpr.h"
20 #include "llvm/MC/MCFragment.h"
22 #include "llvm/MC/MCObjectWriter.h"
23 #include "llvm/MC/MCSection.h"
24 #include "llvm/MC/MCSectionMachO.h"
25 #include "llvm/MC/MCSymbol.h"
26 #include "llvm/MC/MCSymbolMachO.h"
27 #include "llvm/MC/MCValue.h"
28 #include "llvm/Support/Casting.h"
29 #include "llvm/Support/Debug.h"
33 #include <algorithm>
34 #include <cassert>
35 #include <cstdint>
36 #include <string>
37 #include <utility>
38 #include <vector>
39 
40 using namespace llvm;
41 
42 #define DEBUG_TYPE "mc"
43 
45  Relocations.clear();
46  IndirectSymBase.clear();
47  StringTable.clear();
48  LocalSymbolData.clear();
49  ExternalSymbolData.clear();
50  UndefinedSymbolData.clear();
52 }
53 
55  // Undefined symbols are always extern.
56  if (S.isUndefined())
57  return true;
58 
59  // References to weak definitions require external relocation entries; the
60  // definition may not always be the one in the same object file.
61  if (cast<MCSymbolMachO>(S).isWeakDefinition())
62  return true;
63 
64  // Otherwise, we can use an internal relocation.
65  return false;
66 }
67 
69 MachSymbolData::operator<(const MachSymbolData &RHS) const {
70  return Symbol->getName() < RHS.Symbol->getName();
71 }
72 
74  const MCFixupKindInfo &FKI = Asm.getBackend().getFixupKindInfo(
75  (MCFixupKind) Kind);
76 
78 }
79 
81  const MCAsmLayout &Layout) const {
82  return getSectionAddress(Fragment->getParent()) +
83  Layout.getFragmentOffset(Fragment);
84 }
85 
87  const MCAsmLayout &Layout) const {
88  // If this is a variable, then recursively evaluate now.
89  if (S.isVariable()) {
90  if (const MCConstantExpr *C =
91  dyn_cast<const MCConstantExpr>(S.getVariableValue()))
92  return C->getValue();
93 
95  if (!S.getVariableValue()->evaluateAsRelocatable(Target, &Layout, nullptr))
96  report_fatal_error("unable to evaluate offset for variable '" +
97  S.getName() + "'");
98 
99  // Verify that any used symbols are defined.
100  if (Target.getSymA() && Target.getSymA()->getSymbol().isUndefined())
101  report_fatal_error("unable to evaluate offset to undefined symbol '" +
102  Target.getSymA()->getSymbol().getName() + "'");
103  if (Target.getSymB() && Target.getSymB()->getSymbol().isUndefined())
104  report_fatal_error("unable to evaluate offset to undefined symbol '" +
105  Target.getSymB()->getSymbol().getName() + "'");
106 
107  uint64_t Address = Target.getConstant();
108  if (Target.getSymA())
109  Address += getSymbolAddress(Target.getSymA()->getSymbol(), Layout);
110  if (Target.getSymB())
111  Address += getSymbolAddress(Target.getSymB()->getSymbol(), Layout);
112  return Address;
113  }
114 
115  return getSectionAddress(S.getFragment()->getParent()) +
116  Layout.getSymbolOffset(S);
117 }
118 
120  const MCAsmLayout &Layout) const {
121  uint64_t EndAddr = getSectionAddress(Sec) + Layout.getSectionAddressSize(Sec);
122  unsigned Next = Sec->getLayoutOrder() + 1;
123  if (Next >= Layout.getSectionOrder().size())
124  return 0;
125 
126  const MCSection &NextSec = *Layout.getSectionOrder()[Next];
127  if (NextSec.isVirtualSection())
128  return 0;
129  return OffsetToAlignment(EndAddr, NextSec.getAlignment());
130 }
131 
133  unsigned NumLoadCommands,
134  unsigned LoadCommandsSize,
135  bool SubsectionsViaSymbols) {
136  uint32_t Flags = 0;
137 
138  if (SubsectionsViaSymbols)
140 
141  // struct mach_header (28 bytes) or
142  // struct mach_header_64 (32 bytes)
143 
144  uint64_t Start = getStream().tell();
145  (void) Start;
146 
148 
149  write32(TargetObjectWriter->getCPUType());
150  write32(TargetObjectWriter->getCPUSubtype());
151 
152  write32(Type);
153  write32(NumLoadCommands);
154  write32(LoadCommandsSize);
155  write32(Flags);
156  if (is64Bit())
157  write32(0); // reserved
158 
159  assert(
160  getStream().tell() - Start ==
161  (is64Bit() ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header)));
162 }
163 
164 /// writeSegmentLoadCommand - Write a segment load command.
165 ///
166 /// \param NumSections The number of sections in this segment.
167 /// \param SectionDataSize The total size of the sections.
169  StringRef Name, unsigned NumSections, uint64_t VMAddr, uint64_t VMSize,
170  uint64_t SectionDataStartOffset, uint64_t SectionDataSize, uint32_t MaxProt,
171  uint32_t InitProt) {
172  // struct segment_command (56 bytes) or
173  // struct segment_command_64 (72 bytes)
174 
175  uint64_t Start = getStream().tell();
176  (void) Start;
177 
178  unsigned SegmentLoadCommandSize =
180  sizeof(MachO::segment_command);
181  write32(is64Bit() ? MachO::LC_SEGMENT_64 : MachO::LC_SEGMENT);
182  write32(SegmentLoadCommandSize +
183  NumSections * (is64Bit() ? sizeof(MachO::section_64) :
184  sizeof(MachO::section)));
185 
186  assert(Name.size() <= 16);
187  writeBytes(Name, 16);
188  if (is64Bit()) {
189  write64(VMAddr); // vmaddr
190  write64(VMSize); // vmsize
191  write64(SectionDataStartOffset); // file offset
192  write64(SectionDataSize); // file size
193  } else {
194  write32(VMAddr); // vmaddr
195  write32(VMSize); // vmsize
196  write32(SectionDataStartOffset); // file offset
197  write32(SectionDataSize); // file size
198  }
199  // maxprot
200  write32(MaxProt);
201  // initprot
202  write32(InitProt);
203  write32(NumSections);
204  write32(0); // flags
205 
206  assert(getStream().tell() - Start == SegmentLoadCommandSize);
207 }
208 
210  const MCSection &Sec, uint64_t VMAddr,
211  uint64_t FileOffset, unsigned Flags,
212  uint64_t RelocationsStart,
213  unsigned NumRelocations) {
214  uint64_t SectionSize = Layout.getSectionAddressSize(&Sec);
215  const MCSectionMachO &Section = cast<MCSectionMachO>(Sec);
216 
217  // The offset is unused for virtual sections.
218  if (Section.isVirtualSection()) {
219  assert(Layout.getSectionFileSize(&Sec) == 0 && "Invalid file size!");
220  FileOffset = 0;
221  }
222 
223  // struct section (68 bytes) or
224  // struct section_64 (80 bytes)
225 
226  uint64_t Start = getStream().tell();
227  (void) Start;
228 
229  writeBytes(Section.getSectionName(), 16);
230  writeBytes(Section.getSegmentName(), 16);
231  if (is64Bit()) {
232  write64(VMAddr); // address
233  write64(SectionSize); // size
234  } else {
235  write32(VMAddr); // address
236  write32(SectionSize); // size
237  }
238  write32(FileOffset);
239 
240  assert(isPowerOf2_32(Section.getAlignment()) && "Invalid alignment!");
241  write32(Log2_32(Section.getAlignment()));
242  write32(NumRelocations ? RelocationsStart : 0);
243  write32(NumRelocations);
244  write32(Flags);
245  write32(IndirectSymBase.lookup(&Sec)); // reserved1
246  write32(Section.getStubSize()); // reserved2
247  if (is64Bit())
248  write32(0); // reserved3
249 
250  assert(getStream().tell() - Start ==
251  (is64Bit() ? sizeof(MachO::section_64) : sizeof(MachO::section)));
252 }
253 
255  uint32_t NumSymbols,
256  uint32_t StringTableOffset,
257  uint32_t StringTableSize) {
258  // struct symtab_command (24 bytes)
259 
260  uint64_t Start = getStream().tell();
261  (void) Start;
262 
263  write32(MachO::LC_SYMTAB);
265  write32(SymbolOffset);
266  write32(NumSymbols);
267  write32(StringTableOffset);
268  write32(StringTableSize);
269 
270  assert(getStream().tell() - Start == sizeof(MachO::symtab_command));
271 }
272 
274  uint32_t NumLocalSymbols,
275  uint32_t FirstExternalSymbol,
276  uint32_t NumExternalSymbols,
277  uint32_t FirstUndefinedSymbol,
278  uint32_t NumUndefinedSymbols,
279  uint32_t IndirectSymbolOffset,
280  uint32_t NumIndirectSymbols) {
281  // struct dysymtab_command (80 bytes)
282 
283  uint64_t Start = getStream().tell();
284  (void) Start;
285 
286  write32(MachO::LC_DYSYMTAB);
288  write32(FirstLocalSymbol);
289  write32(NumLocalSymbols);
290  write32(FirstExternalSymbol);
291  write32(NumExternalSymbols);
292  write32(FirstUndefinedSymbol);
293  write32(NumUndefinedSymbols);
294  write32(0); // tocoff
295  write32(0); // ntoc
296  write32(0); // modtaboff
297  write32(0); // nmodtab
298  write32(0); // extrefsymoff
299  write32(0); // nextrefsyms
300  write32(IndirectSymbolOffset);
301  write32(NumIndirectSymbols);
302  write32(0); // extreloff
303  write32(0); // nextrel
304  write32(0); // locreloff
305  write32(0); // nlocrel
306 
307  assert(getStream().tell() - Start == sizeof(MachO::dysymtab_command));
308 }
309 
310 MachObjectWriter::MachSymbolData *
311 MachObjectWriter::findSymbolData(const MCSymbol &Sym) {
312  for (auto *SymbolData :
313  {&LocalSymbolData, &ExternalSymbolData, &UndefinedSymbolData})
314  for (MachSymbolData &Entry : *SymbolData)
315  if (Entry.Symbol == &Sym)
316  return &Entry;
317 
318  return nullptr;
319 }
320 
322  const MCSymbol *S = &Sym;
323  while (S->isVariable()) {
324  const MCExpr *Value = S->getVariableValue();
325  const auto *Ref = dyn_cast<MCSymbolRefExpr>(Value);
326  if (!Ref)
327  return *S;
328  S = &Ref->getSymbol();
329  }
330  return *S;
331 }
332 
333 void MachObjectWriter::writeNlist(MachSymbolData &MSD,
334  const MCAsmLayout &Layout) {
335  const MCSymbol *Symbol = MSD.Symbol;
336  const MCSymbol &Data = *Symbol;
337  const MCSymbol *AliasedSymbol = &findAliasedSymbol(*Symbol);
338  uint8_t SectionIndex = MSD.SectionIndex;
339  uint8_t Type = 0;
340  uint64_t Address = 0;
341  bool IsAlias = Symbol != AliasedSymbol;
342 
343  const MCSymbol &OrigSymbol = *Symbol;
344  MachSymbolData *AliaseeInfo;
345  if (IsAlias) {
346  AliaseeInfo = findSymbolData(*AliasedSymbol);
347  if (AliaseeInfo)
348  SectionIndex = AliaseeInfo->SectionIndex;
349  Symbol = AliasedSymbol;
350  // FIXME: Should this update Data as well?
351  }
352 
353  // Set the N_TYPE bits. See <mach-o/nlist.h>.
354  //
355  // FIXME: Are the prebound or indirect fields possible here?
356  if (IsAlias && Symbol->isUndefined())
357  Type = MachO::N_INDR;
358  else if (Symbol->isUndefined())
359  Type = MachO::N_UNDF;
360  else if (Symbol->isAbsolute())
361  Type = MachO::N_ABS;
362  else
363  Type = MachO::N_SECT;
364 
365  // FIXME: Set STAB bits.
366 
367  if (Data.isPrivateExtern())
368  Type |= MachO::N_PEXT;
369 
370  // Set external bit.
371  if (Data.isExternal() || (!IsAlias && Symbol->isUndefined()))
372  Type |= MachO::N_EXT;
373 
374  // Compute the symbol address.
375  if (IsAlias && Symbol->isUndefined())
376  Address = AliaseeInfo->StringIndex;
377  else if (Symbol->isDefined())
378  Address = getSymbolAddress(OrigSymbol, Layout);
379  else if (Symbol->isCommon()) {
380  // Common symbols are encoded with the size in the address
381  // field, and their alignment in the flags.
382  Address = Symbol->getCommonSize();
383  }
384 
385  // struct nlist (12 bytes)
386 
387  write32(MSD.StringIndex);
388  write8(Type);
389  write8(SectionIndex);
390 
391  // The Mach-O streamer uses the lowest 16-bits of the flags for the 'desc'
392  // value.
393  bool EncodeAsAltEntry =
394  IsAlias && cast<MCSymbolMachO>(OrigSymbol).isAltEntry();
395  write16(cast<MCSymbolMachO>(Symbol)->getEncodedFlags(EncodeAsAltEntry));
396  if (is64Bit())
397  write64(Address);
398  else
399  write32(Address);
400 }
401 
403  uint32_t DataOffset,
404  uint32_t DataSize) {
405  uint64_t Start = getStream().tell();
406  (void) Start;
407 
408  write32(Type);
410  write32(DataOffset);
411  write32(DataSize);
412 
413  assert(getStream().tell() - Start == sizeof(MachO::linkedit_data_command));
414 }
415 
417  const std::vector<std::string> &Options, bool is64Bit)
418 {
419  unsigned Size = sizeof(MachO::linker_option_command);
420  for (const std::string &Option : Options)
421  Size += Option.size() + 1;
422  return alignTo(Size, is64Bit ? 8 : 4);
423 }
424 
426  const std::vector<std::string> &Options)
427 {
428  unsigned Size = ComputeLinkerOptionsLoadCommandSize(Options, is64Bit());
429  uint64_t Start = getStream().tell();
430  (void) Start;
431 
432  write32(MachO::LC_LINKER_OPTION);
433  write32(Size);
434  write32(Options.size());
435  uint64_t BytesWritten = sizeof(MachO::linker_option_command);
436  for (const std::string &Option : Options) {
437  // Write each string, including the null byte.
438  writeBytes(Option, Option.size() + 1);
439  BytesWritten += Option.size() + 1;
440  }
441 
442  // Pad to a multiple of the pointer size.
443  writeBytes("", OffsetToAlignment(BytesWritten, is64Bit() ? 8 : 4));
444 
445  assert(getStream().tell() - Start == Size);
446 }
447 
449  const MCAsmLayout &Layout,
450  const MCFragment *Fragment,
451  const MCFixup &Fixup, MCValue Target,
452  uint64_t &FixedValue) {
453  TargetObjectWriter->recordRelocation(this, Asm, Layout, Fragment, Fixup,
454  Target, FixedValue);
455 }
456 
458  // This is the point where 'as' creates actual symbols for indirect symbols
459  // (in the following two passes). It would be easier for us to do this sooner
460  // when we see the attribute, but that makes getting the order in the symbol
461  // table much more complicated than it is worth.
462  //
463  // FIXME: Revisit this when the dust settles.
464 
465  // Report errors for use of .indirect_symbol not in a symbol pointer section
466  // or stub section.
468  ie = Asm.indirect_symbol_end(); it != ie; ++it) {
469  const MCSectionMachO &Section = cast<MCSectionMachO>(*it->Section);
470 
471  if (Section.getType() != MachO::S_NON_LAZY_SYMBOL_POINTERS &&
472  Section.getType() != MachO::S_LAZY_SYMBOL_POINTERS &&
474  Section.getType() != MachO::S_SYMBOL_STUBS) {
475  MCSymbol &Symbol = *it->Symbol;
476  report_fatal_error("indirect symbol '" + Symbol.getName() +
477  "' not in a symbol pointer or stub section");
478  }
479  }
480 
481  // Bind non-lazy symbol pointers first.
482  unsigned IndirectIndex = 0;
484  ie = Asm.indirect_symbol_end(); it != ie; ++it, ++IndirectIndex) {
485  const MCSectionMachO &Section = cast<MCSectionMachO>(*it->Section);
486 
487  if (Section.getType() != MachO::S_NON_LAZY_SYMBOL_POINTERS &&
489  continue;
490 
491  // Initialize the section indirect symbol base, if necessary.
492  IndirectSymBase.insert(std::make_pair(it->Section, IndirectIndex));
493 
494  Asm.registerSymbol(*it->Symbol);
495  }
496 
497  // Then lazy symbol pointers and symbol stubs.
498  IndirectIndex = 0;
500  ie = Asm.indirect_symbol_end(); it != ie; ++it, ++IndirectIndex) {
501  const MCSectionMachO &Section = cast<MCSectionMachO>(*it->Section);
502 
503  if (Section.getType() != MachO::S_LAZY_SYMBOL_POINTERS &&
504  Section.getType() != MachO::S_SYMBOL_STUBS)
505  continue;
506 
507  // Initialize the section indirect symbol base, if necessary.
508  IndirectSymBase.insert(std::make_pair(it->Section, IndirectIndex));
509 
510  // Set the symbol type to undefined lazy, but only on construction.
511  //
512  // FIXME: Do not hardcode.
513  bool Created;
514  Asm.registerSymbol(*it->Symbol, &Created);
515  if (Created)
516  cast<MCSymbolMachO>(it->Symbol)->setReferenceTypeUndefinedLazy(true);
517  }
518 }
519 
520 /// computeSymbolTable - Compute the symbol table data
522  MCAssembler &Asm, std::vector<MachSymbolData> &LocalSymbolData,
523  std::vector<MachSymbolData> &ExternalSymbolData,
524  std::vector<MachSymbolData> &UndefinedSymbolData) {
525  // Build section lookup table.
526  DenseMap<const MCSection*, uint8_t> SectionIndexMap;
527  unsigned Index = 1;
528  for (MCAssembler::iterator it = Asm.begin(),
529  ie = Asm.end(); it != ie; ++it, ++Index)
530  SectionIndexMap[&*it] = Index;
531  assert(Index <= 256 && "Too many sections!");
532 
533  // Build the string table.
534  for (const MCSymbol &Symbol : Asm.symbols()) {
535  if (!Asm.isSymbolLinkerVisible(Symbol))
536  continue;
537 
538  StringTable.add(Symbol.getName());
539  }
540  StringTable.finalize();
541 
542  // Build the symbol arrays but only for non-local symbols.
543  //
544  // The particular order that we collect and then sort the symbols is chosen to
545  // match 'as'. Even though it doesn't matter for correctness, this is
546  // important for letting us diff .o files.
547  for (const MCSymbol &Symbol : Asm.symbols()) {
548  // Ignore non-linker visible symbols.
549  if (!Asm.isSymbolLinkerVisible(Symbol))
550  continue;
551 
552  if (!Symbol.isExternal() && !Symbol.isUndefined())
553  continue;
554 
555  MachSymbolData MSD;
556  MSD.Symbol = &Symbol;
557  MSD.StringIndex = StringTable.getOffset(Symbol.getName());
558 
559  if (Symbol.isUndefined()) {
560  MSD.SectionIndex = 0;
561  UndefinedSymbolData.push_back(MSD);
562  } else if (Symbol.isAbsolute()) {
563  MSD.SectionIndex = 0;
564  ExternalSymbolData.push_back(MSD);
565  } else {
566  MSD.SectionIndex = SectionIndexMap.lookup(&Symbol.getSection());
567  assert(MSD.SectionIndex && "Invalid section index!");
568  ExternalSymbolData.push_back(MSD);
569  }
570  }
571 
572  // Now add the data for local symbols.
573  for (const MCSymbol &Symbol : Asm.symbols()) {
574  // Ignore non-linker visible symbols.
575  if (!Asm.isSymbolLinkerVisible(Symbol))
576  continue;
577 
578  if (Symbol.isExternal() || Symbol.isUndefined())
579  continue;
580 
581  MachSymbolData MSD;
582  MSD.Symbol = &Symbol;
583  MSD.StringIndex = StringTable.getOffset(Symbol.getName());
584 
585  if (Symbol.isAbsolute()) {
586  MSD.SectionIndex = 0;
587  LocalSymbolData.push_back(MSD);
588  } else {
589  MSD.SectionIndex = SectionIndexMap.lookup(&Symbol.getSection());
590  assert(MSD.SectionIndex && "Invalid section index!");
591  LocalSymbolData.push_back(MSD);
592  }
593  }
594 
595  // External and undefined symbols are required to be in lexicographic order.
596  std::sort(ExternalSymbolData.begin(), ExternalSymbolData.end());
597  std::sort(UndefinedSymbolData.begin(), UndefinedSymbolData.end());
598 
599  // Set the symbol indices.
600  Index = 0;
601  for (auto *SymbolData :
602  {&LocalSymbolData, &ExternalSymbolData, &UndefinedSymbolData})
603  for (MachSymbolData &Entry : *SymbolData)
604  Entry.Symbol->setIndex(Index++);
605 
606  for (const MCSection &Section : Asm) {
607  for (RelAndSymbol &Rel : Relocations[&Section]) {
608  if (!Rel.Sym)
609  continue;
610 
611  // Set the Index and the IsExtern bit.
612  unsigned Index = Rel.Sym->getIndex();
613  assert(isInt<24>(Index));
614  if (IsLittleEndian)
615  Rel.MRE.r_word1 = (Rel.MRE.r_word1 & (~0U << 24)) | Index | (1 << 27);
616  else
617  Rel.MRE.r_word1 = (Rel.MRE.r_word1 & 0xff) | Index << 8 | (1 << 4);
618  }
619  }
620 }
621 
623  const MCAsmLayout &Layout) {
624  uint64_t StartAddress = 0;
625  for (const MCSection *Sec : Layout.getSectionOrder()) {
626  StartAddress = alignTo(StartAddress, Sec->getAlignment());
627  SectionAddress[Sec] = StartAddress;
628  StartAddress += Layout.getSectionAddressSize(Sec);
629 
630  // Explicitly pad the section to match the alignment requirements of the
631  // following one. This is for 'gas' compatibility, it shouldn't
632  /// strictly be necessary.
633  StartAddress += getPaddingSize(Sec, Layout);
634  }
635 }
636 
638  const MCAsmLayout &Layout) {
639  computeSectionAddresses(Asm, Layout);
640 
641  // Create symbol data for any indirect symbols.
642  bindIndirectSymbols(Asm);
643 }
644 
646  const MCAssembler &Asm, const MCSymbol &A, const MCSymbol &B,
647  bool InSet) const {
648  // FIXME: We don't handle things like
649  // foo = .
650  // creating atoms.
651  if (A.isVariable() || B.isVariable())
652  return false;
654  InSet);
655 }
656 
658  const MCAssembler &Asm, const MCSymbol &SymA, const MCFragment &FB,
659  bool InSet, bool IsPCRel) const {
660  if (InSet)
661  return true;
662 
663  // The effective address is
664  // addr(atom(A)) + offset(A)
665  // - addr(atom(B)) - offset(B)
666  // and the offsets are not relocatable, so the fixup is fully resolved when
667  // addr(atom(A)) - addr(atom(B)) == 0.
668  const MCSymbol &SA = findAliasedSymbol(SymA);
669  const MCSection &SecA = SA.getSection();
670  const MCSection &SecB = *FB.getParent();
671 
672  if (IsPCRel) {
673  // The simple (Darwin, except on x86_64) way of dealing with this was to
674  // assume that any reference to a temporary symbol *must* be a temporary
675  // symbol in the same atom, unless the sections differ. Therefore, any PCrel
676  // relocation to a temporary symbol (in the same section) is fully
677  // resolved. This also works in conjunction with absolutized .set, which
678  // requires the compiler to use .set to absolutize the differences between
679  // symbols which the compiler knows to be assembly time constants, so we
680  // don't need to worry about considering symbol differences fully resolved.
681  //
682  // If the file isn't using sub-sections-via-symbols, we can make the
683  // same assumptions about any symbol that we normally make about
684  // assembler locals.
685 
686  bool hasReliableSymbolDifference = isX86_64();
687  if (!hasReliableSymbolDifference) {
688  if (!SA.isInSection() || &SecA != &SecB ||
689  (!SA.isTemporary() && FB.getAtom() != SA.getFragment()->getAtom() &&
691  return false;
692  return true;
693  }
694  // For Darwin x86_64, there is one special case when the reference IsPCRel.
695  // If the fragment with the reference does not have a base symbol but meets
696  // the simple way of dealing with this, in that it is a temporary symbol in
697  // the same atom then it is assumed to be fully resolved. This is needed so
698  // a relocation entry is not created and so the static linker does not
699  // mess up the reference later.
700  else if(!FB.getAtom() &&
701  SA.isTemporary() && SA.isInSection() && &SecA == &SecB){
702  return true;
703  }
704  }
705 
706  // If they are not in the same section, we can't compute the diff.
707  if (&SecA != &SecB)
708  return false;
709 
710  const MCFragment *FA = SA.getFragment();
711 
712  // Bail if the symbol has no fragment.
713  if (!FA)
714  return false;
715 
716  // If the atoms are the same, they are guaranteed to have the same address.
717  if (FA->getAtom() == FB.getAtom())
718  return true;
719 
720  // Otherwise, we can't prove this is fully resolved.
721  return false;
722 }
723 
725  const MCAsmLayout &Layout) {
726  // Compute symbol table information and bind symbol indices.
727  computeSymbolTable(Asm, LocalSymbolData, ExternalSymbolData,
728  UndefinedSymbolData);
729 
730  unsigned NumSections = Asm.size();
731  const MCAssembler::VersionMinInfoType &VersionInfo =
732  Layout.getAssembler().getVersionMinInfo();
733 
734  // The section data starts after the header, the segment load command (and
735  // section headers) and the symbol table.
736  unsigned NumLoadCommands = 1;
737  uint64_t LoadCommandsSize = is64Bit() ?
738  sizeof(MachO::segment_command_64) + NumSections * sizeof(MachO::section_64):
739  sizeof(MachO::segment_command) + NumSections * sizeof(MachO::section);
740 
741  // Add the deployment target version info load command size, if used.
742  if (VersionInfo.Major != 0) {
743  ++NumLoadCommands;
744  LoadCommandsSize += sizeof(MachO::version_min_command);
745  }
746 
747  // Add the data-in-code load command size, if used.
748  unsigned NumDataRegions = Asm.getDataRegions().size();
749  if (NumDataRegions) {
750  ++NumLoadCommands;
751  LoadCommandsSize += sizeof(MachO::linkedit_data_command);
752  }
753 
754  // Add the loh load command size, if used.
755  uint64_t LOHRawSize = Asm.getLOHContainer().getEmitSize(*this, Layout);
756  uint64_t LOHSize = alignTo(LOHRawSize, is64Bit() ? 8 : 4);
757  if (LOHSize) {
758  ++NumLoadCommands;
759  LoadCommandsSize += sizeof(MachO::linkedit_data_command);
760  }
761 
762  // Add the symbol table load command sizes, if used.
763  unsigned NumSymbols = LocalSymbolData.size() + ExternalSymbolData.size() +
764  UndefinedSymbolData.size();
765  if (NumSymbols) {
766  NumLoadCommands += 2;
767  LoadCommandsSize += (sizeof(MachO::symtab_command) +
768  sizeof(MachO::dysymtab_command));
769  }
770 
771  // Add the linker option load commands sizes.
772  for (const auto &Option : Asm.getLinkerOptions()) {
773  ++NumLoadCommands;
774  LoadCommandsSize += ComputeLinkerOptionsLoadCommandSize(Option, is64Bit());
775  }
776 
777  // Compute the total size of the section data, as well as its file size and vm
778  // size.
779  uint64_t SectionDataStart = (is64Bit() ? sizeof(MachO::mach_header_64) :
780  sizeof(MachO::mach_header)) + LoadCommandsSize;
781  uint64_t SectionDataSize = 0;
782  uint64_t SectionDataFileSize = 0;
783  uint64_t VMSize = 0;
784  for (const MCSection &Sec : Asm) {
785  uint64_t Address = getSectionAddress(&Sec);
786  uint64_t Size = Layout.getSectionAddressSize(&Sec);
787  uint64_t FileSize = Layout.getSectionFileSize(&Sec);
788  FileSize += getPaddingSize(&Sec, Layout);
789 
790  VMSize = std::max(VMSize, Address + Size);
791 
792  if (Sec.isVirtualSection())
793  continue;
794 
795  SectionDataSize = std::max(SectionDataSize, Address + Size);
796  SectionDataFileSize = std::max(SectionDataFileSize, Address + FileSize);
797  }
798 
799  // The section data is padded to 4 bytes.
800  //
801  // FIXME: Is this machine dependent?
802  unsigned SectionDataPadding = OffsetToAlignment(SectionDataFileSize, 4);
803  SectionDataFileSize += SectionDataPadding;
804 
805  // Write the prolog, starting with the header and load command...
806  writeHeader(MachO::MH_OBJECT, NumLoadCommands, LoadCommandsSize,
807  Asm.getSubsectionsViaSymbols());
808  uint32_t Prot =
810  writeSegmentLoadCommand("", NumSections, 0, VMSize, SectionDataStart,
811  SectionDataSize, Prot, Prot);
812 
813  // ... and then the section headers.
814  uint64_t RelocTableEnd = SectionDataStart + SectionDataFileSize;
815  for (const MCSection &Section : Asm) {
816  const auto &Sec = cast<MCSectionMachO>(Section);
817  std::vector<RelAndSymbol> &Relocs = Relocations[&Sec];
818  unsigned NumRelocs = Relocs.size();
819  uint64_t SectionStart = SectionDataStart + getSectionAddress(&Sec);
820  unsigned Flags = Sec.getTypeAndAttributes();
821  if (Sec.hasInstructions())
823  writeSection(Layout, Sec, getSectionAddress(&Sec), SectionStart, Flags,
824  RelocTableEnd, NumRelocs);
825  RelocTableEnd += NumRelocs * sizeof(MachO::any_relocation_info);
826  }
827 
828  // Write out the deployment target information, if it's available.
829  if (VersionInfo.Major != 0) {
830  assert(VersionInfo.Update < 256 && "unencodable update target version");
831  assert(VersionInfo.Minor < 256 && "unencodable minor target version");
832  assert(VersionInfo.Major < 65536 && "unencodable major target version");
833  uint32_t EncodedVersion = VersionInfo.Update | (VersionInfo.Minor << 8) |
834  (VersionInfo.Major << 16);
835  MachO::LoadCommandType LCType;
836  switch (VersionInfo.Kind) {
837  case MCVM_OSXVersionMin:
838  LCType = MachO::LC_VERSION_MIN_MACOSX;
839  break;
840  case MCVM_IOSVersionMin:
841  LCType = MachO::LC_VERSION_MIN_IPHONEOS;
842  break;
843  case MCVM_TvOSVersionMin:
844  LCType = MachO::LC_VERSION_MIN_TVOS;
845  break;
847  LCType = MachO::LC_VERSION_MIN_WATCHOS;
848  break;
849  }
850  write32(LCType);
852  write32(EncodedVersion);
853  write32(0); // reserved.
854  }
855 
856  // Write the data-in-code load command, if used.
857  uint64_t DataInCodeTableEnd = RelocTableEnd + NumDataRegions * 8;
858  if (NumDataRegions) {
859  uint64_t DataRegionsOffset = RelocTableEnd;
860  uint64_t DataRegionsSize = NumDataRegions * 8;
861  writeLinkeditLoadCommand(MachO::LC_DATA_IN_CODE, DataRegionsOffset,
862  DataRegionsSize);
863  }
864 
865  // Write the loh load command, if used.
866  uint64_t LOHTableEnd = DataInCodeTableEnd + LOHSize;
867  if (LOHSize)
868  writeLinkeditLoadCommand(MachO::LC_LINKER_OPTIMIZATION_HINT,
869  DataInCodeTableEnd, LOHSize);
870 
871  // Write the symbol table load command, if used.
872  if (NumSymbols) {
873  unsigned FirstLocalSymbol = 0;
874  unsigned NumLocalSymbols = LocalSymbolData.size();
875  unsigned FirstExternalSymbol = FirstLocalSymbol + NumLocalSymbols;
876  unsigned NumExternalSymbols = ExternalSymbolData.size();
877  unsigned FirstUndefinedSymbol = FirstExternalSymbol + NumExternalSymbols;
878  unsigned NumUndefinedSymbols = UndefinedSymbolData.size();
879  unsigned NumIndirectSymbols = Asm.indirect_symbol_size();
880  unsigned NumSymTabSymbols =
881  NumLocalSymbols + NumExternalSymbols + NumUndefinedSymbols;
882  uint64_t IndirectSymbolSize = NumIndirectSymbols * 4;
883  uint64_t IndirectSymbolOffset = 0;
884 
885  // If used, the indirect symbols are written after the section data.
886  if (NumIndirectSymbols)
887  IndirectSymbolOffset = LOHTableEnd;
888 
889  // The symbol table is written after the indirect symbol data.
890  uint64_t SymbolTableOffset = LOHTableEnd + IndirectSymbolSize;
891 
892  // The string table is written after symbol table.
893  uint64_t StringTableOffset =
894  SymbolTableOffset + NumSymTabSymbols * (is64Bit() ?
895  sizeof(MachO::nlist_64) :
896  sizeof(MachO::nlist));
897  writeSymtabLoadCommand(SymbolTableOffset, NumSymTabSymbols,
898  StringTableOffset, StringTable.getSize());
899 
900  writeDysymtabLoadCommand(FirstLocalSymbol, NumLocalSymbols,
901  FirstExternalSymbol, NumExternalSymbols,
902  FirstUndefinedSymbol, NumUndefinedSymbols,
903  IndirectSymbolOffset, NumIndirectSymbols);
904  }
905 
906  // Write the linker options load commands.
907  for (const auto &Option : Asm.getLinkerOptions())
909 
910  // Write the actual section data.
911  for (const MCSection &Sec : Asm) {
912  Asm.writeSectionData(&Sec, Layout);
913 
914  uint64_t Pad = getPaddingSize(&Sec, Layout);
915  WriteZeros(Pad);
916  }
917 
918  // Write the extra padding.
919  WriteZeros(SectionDataPadding);
920 
921  // Write the relocation entries.
922  for (const MCSection &Sec : Asm) {
923  // Write the section relocation entries, in reverse order to match 'as'
924  // (approximately, the exact algorithm is more complicated than this).
925  std::vector<RelAndSymbol> &Relocs = Relocations[&Sec];
926  for (const RelAndSymbol &Rel : make_range(Relocs.rbegin(), Relocs.rend())) {
927  write32(Rel.MRE.r_word0);
928  write32(Rel.MRE.r_word1);
929  }
930  }
931 
932  // Write out the data-in-code region payload, if there is one.
934  it = Asm.data_region_begin(), ie = Asm.data_region_end();
935  it != ie; ++it) {
936  const DataRegionData *Data = &(*it);
937  uint64_t Start = getSymbolAddress(*Data->Start, Layout);
938  uint64_t End = getSymbolAddress(*Data->End, Layout);
939  DEBUG(dbgs() << "data in code region-- kind: " << Data->Kind
940  << " start: " << Start << "(" << Data->Start->getName() << ")"
941  << " end: " << End << "(" << Data->End->getName() << ")"
942  << " size: " << End - Start
943  << "\n");
944  write32(Start);
945  write16(End - Start);
946  write16(Data->Kind);
947  }
948 
949  // Write out the loh commands, if there is one.
950  if (LOHSize) {
951 #ifndef NDEBUG
952  unsigned Start = getStream().tell();
953 #endif
954  Asm.getLOHContainer().emit(*this, Layout);
955  // Pad to a multiple of the pointer size.
956  writeBytes("", OffsetToAlignment(LOHRawSize, is64Bit() ? 8 : 4));
957  assert(getStream().tell() - Start == LOHSize);
958  }
959 
960  // Write the symbol table data, if used.
961  if (NumSymbols) {
962  // Write the indirect symbol entries.
964  it = Asm.indirect_symbol_begin(),
965  ie = Asm.indirect_symbol_end(); it != ie; ++it) {
966  // Indirect symbols in the non-lazy symbol pointer section have some
967  // special handling.
968  const MCSectionMachO &Section =
969  static_cast<const MCSectionMachO &>(*it->Section);
970  if (Section.getType() == MachO::S_NON_LAZY_SYMBOL_POINTERS) {
971  // If this symbol is defined and internal, mark it as such.
972  if (it->Symbol->isDefined() && !it->Symbol->isExternal()) {
974  if (it->Symbol->isAbsolute())
976  write32(Flags);
977  continue;
978  }
979  }
980 
981  write32(it->Symbol->getIndex());
982  }
983 
984  // FIXME: Check that offsets match computed ones.
985 
986  // Write the symbol table entries.
987  for (auto *SymbolData :
988  {&LocalSymbolData, &ExternalSymbolData, &UndefinedSymbolData})
989  for (MachSymbolData &Entry : *SymbolData)
990  writeNlist(Entry, Layout);
991 
992  // Write the string table.
993  StringTable.write(getStream());
994  }
995 }
996 
998  raw_pwrite_stream &OS,
999  bool IsLittleEndian) {
1000  return new MachObjectWriter(MOTW, OS, IsLittleEndian);
1001 }
uint64_t CallInst * C
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:39
LoadCommandType
Definition: MachO.h:92
S_NON_LAZY_SYMBOL_POINTERS - Section with non-lazy symbol pointers.
Definition: MachO.h:132
const MCSymbol & findAliasedSymbol(const MCSymbol &Sym) const
MachObjectWriter(MCMachObjectTargetWriter *MOTW, raw_pwrite_stream &OS, bool IsLittleEndian)
S_SYMBOL_STUBS - Section with symbol stubs, byte size of stub in the Reserved2 field.
Definition: MachO.h:137
uint64_t getSymbolAddress(const MCSymbol &S, const MCAsmLayout &Layout) const
void WriteZeros(unsigned N)
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
This represents a section on a Mach-O system (used by Mac OS X).
void computeSectionAddresses(const MCAssembler &Asm, const MCAsmLayout &Layout)
struct fuzzer::@309 Flags
bool doesSymbolRequireExternRelocation(const MCSymbol &S)
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:103
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
bool isVariable() const
isVariable - Check if this is a variable symbol.
Definition: MCSymbol.h:295
raw_pwrite_stream & getStream()
void write64(uint64_t Value)
This represents an "assembler immediate".
Definition: MCValue.h:40
uint64_t getSectionAddressSize(const MCSection *Sec) const
Get the address space size of the given section, as it effects layout.
Definition: MCFragment.cpp:175
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
MCSection & getSection(bool SetUsed=true) const
Get the section associated with a defined, non-absolute symbol.
Definition: MCSymbol.h:268
iterator begin()
Definition: MCAssembler.h:303
.watchos_version_min
Definition: MCDirectives.h:68
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
void executePostLayoutBinding(MCAssembler &Asm, const MCAsmLayout &Layout) override
Perform any late binding of symbols (for example, to assign symbol indices for use when generating re...
virtual const MCFixupKindInfo & getFixupKindInfo(MCFixupKind Kind) const
Get information on a fixup kind.
.ios_version_min
Definition: MCDirectives.h:65
S_ATTR_SOME_INSTRUCTIONS - Section contains some machine instructions.
Definition: MachO.h:203
void registerSymbol(const MCSymbol &Symbol, bool *Created=nullptr)
uint64_t alignTo(uint64_t Value, uint64_t Align, uint64_t Skew=0)
Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Alig...
Definition: MathExtras.h:677
.macosx_version_min
Definition: MCDirectives.h:66
bool isCommon() const
Is this a &#39;common&#39; symbol.
Definition: MCSymbol.h:379
Defines the object file and target independent interfaces used by the assembler backend to write nati...
void write8(uint8_t Value)
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition: MCFixup.h:66
unsigned getAlignment() const
Definition: MCSection.h:117
Is this fixup kind PCrelative? This is used by the assembler backend to evaluate fixup values in a ta...
enum llvm::DataRegionData::KindTy Kind
int64_t getConstant() const
Definition: MCValue.h:46
const MCSymbolRefExpr * getSymB() const
Definition: MCValue.h:48
void writeDysymtabLoadCommand(uint32_t FirstLocalSymbol, uint32_t NumLocalSymbols, uint32_t FirstExternalSymbol, uint32_t NumExternalSymbols, uint32_t FirstUndefinedSymbol, uint32_t NumUndefinedSymbols, uint32_t IndirectSymbolOffset, uint32_t NumIndirectSymbols)
void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override
Write the object file.
bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm, const MCSymbol &A, const MCSymbol &B, bool InSet) const override
Encapsulates the layout of an assembly file at a particular point in time.
Definition: MCAsmLayout.h:29
HeaderFileType
Definition: MachO.h:37
bool isSymbolLinkerVisible(const MCSymbol &SD) const
Check whether a particular symbol is visible to the linker and is required in the symbol table...
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:36
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:165
struct { MCVersionMinType Kind VersionMinInfoType
MachO specific deployment target version info.
Definition: MCAssembler.h:88
StringRef getSectionName() const
uint64_t getPaddingSize(const MCSection *SD, const MCAsmLayout &Layout) const
bool isAbsolute(bool SetUsed=true) const
isAbsolute - Check if this is an absolute symbol.
Definition: MCSymbol.h:263
void writeSegmentLoadCommand(StringRef Name, unsigned NumSections, uint64_t VMAddr, uint64_t VMSize, uint64_t SectionDataStartOffset, uint64_t SectionDataSize, uint32_t MaxProt, uint32_t InitProt)
Write a segment load command.
bool isFixupKindPCRel(const MCAssembler &Asm, unsigned Kind)
void write(raw_ostream &OS) const
bool evaluateAsRelocatable(MCValue &Res, const MCAsmLayout *Layout, const MCFixup *Fixup) const
Try to evaluate the expression to a relocatable value, i.e.
Definition: MCExpr.cpp:594
size_t add(CachedHashStringRef S)
Add a string to the builder.
uint64_t getEmitSize(const MachObjectWriter &ObjWriter, const MCAsmLayout &Layout) const
Get the size of the directives if emitted.
unsigned getStubSize() const
void writeSymtabLoadCommand(uint32_t SymbolOffset, uint32_t NumSymbols, uint32_t StringTableOffset, uint32_t StringTableSize)
MCAssembler & getAssembler() const
Get the assembler object this is a layout for.
Definition: MCAsmLayout.h:51
iterator end()
Definition: MCAssembler.h:306
void writeLinkerOptionsLoadCommand(const std::vector< std::string > &Options)
StringRef getSegmentName() const
void write32(uint32_t Value)
void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout, const MCFragment *Fragment, const MCFixup &Fixup, MCValue Target, uint64_t &FixedValue) override
Record a relocation entry.
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
Definition: MathExtras.h:421
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
.tvos_version_min
Definition: MCDirectives.h:67
virtual void reset()
lifetime management
MCFixupKind
Extensible enumeration to represent the type of a fixup.
Definition: MCFixup.h:23
bool getSymbolOffset(const MCSymbol &S, uint64_t &Val) const
Get the offset of the given symbol, as computed in the current layout.
Definition: MCFragment.cpp:129
bool isTemporary() const
isTemporary - Check if this is an assembler temporary symbol.
Definition: MCSymbol.h:220
const MCSymbolRefExpr * getSymA() const
Definition: MCValue.h:47
uint64_t getCommonSize() const
Return the size of a &#39;common&#39; symbol.
Definition: MCSymbol.h:335
static const unsigned End
std::vector< DataRegionData >::const_iterator const_data_region_iterator
Definition: MCAssembler.h:81
const MCSymbol * getAtom() const
Definition: MCFragment.h:105
void writeHeader(MachO::HeaderFileType Type, unsigned NumLoadCommands, unsigned LoadCommandsSize, bool SubsectionsViaSymbols)
std::vector< IndirectSymbolData >::const_iterator const_indirect_symbol_iterator
Definition: MCAssembler.h:77
llvm::SmallVectorImpl< MCSection * > & getSectionOrder()
Definition: MCAsmLayout.h:66
void finalize()
Analyze the strings and build the final table.
bool isExternal() const
Definition: MCSymbol.h:392
MachO::SectionType getType() const
void write16(uint16_t Value)
uint64_t getFragmentOffset(const MCFragment *F) const
Get the offset of the given fragment inside its containing section.
Definition: MCFragment.cpp:77
PowerPC TLS Dynamic Call Fixup
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
S_LAZY_SYMBOL_POINTERS - Section with lazy symbol pointers.
Definition: MachO.h:134
size_t getOffset(CachedHashStringRef S) const
Get the offest of a string in the string table.
std::vector< std::vector< std::string > > & getLinkerOptions()
Definition: MCAssembler.h:358
bool isInSection(bool SetUsed=true) const
isInSection - Check if this symbol is defined in some section (i.e., it is defined but not absolute)...
Definition: MCSymbol.h:255
void writeLinkeditLoadCommand(uint32_t Type, uint32_t DataOffset, uint32_t DataSize)
void writeSection(const MCAsmLayout &Layout, const MCSection &Sec, uint64_t VMAddr, uint64_t FileOffset, unsigned Flags, uint64_t RelocationsStart, unsigned NumRelocations)
indirect_symbol_iterator indirect_symbol_begin()
Definition: MCAssembler.h:338
uint64_t getFragmentAddress(const MCFragment *Fragment, const MCAsmLayout &Layout) const
virtual bool isVirtualSection() const =0
Check whether this section is "virtual", that is has no actual object file contents.
MCAsmBackend & getBackend() const
Definition: MCAssembler.h:259
const MCSymbol & getSymbol() const
Definition: MCExpr.h:318
bool isUndefined(bool SetUsed=true) const
isUndefined - Check if this symbol undefined (i.e., implicitly defined).
Definition: MCSymbol.h:260
MCFragment * getFragment(bool SetUsed=true) const
Definition: MCSymbol.h:383
An iterator type that allows iterating over the pointees via some other iterator. ...
Definition: iterator.h:289
S_THREAD_LOCAL_VARIABLE_POINTERS - Section with pointers to thread local structures.
Definition: MachO.h:168
bool getSubsectionsViaSymbols() const
Definition: MCAssembler.h:277
MCLOHContainer & getLOHContainer()
Definition: MCAssembler.h:390
static unsigned ComputeLinkerOptionsLoadCommandSize(const std::vector< std::string > &Options, bool is64Bit)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
unsigned Log2_32(uint32_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
Definition: MathExtras.h:531
Target - Wrapper for Target specific information.
MCSection * getParent() const
Definition: MCFragment.h:102
MCObjectWriter * createMachObjectWriter(MCMachObjectTargetWriter *MOTW, raw_pwrite_stream &OS, bool IsLittleEndian)
Construct a new Mach-O writer instance.
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
const VersionMinInfoType & getVersionMinInfo() const
MachO deployment target version information.
Definition: MCAssembler.h:244
void computeSymbolTable(MCAssembler &Asm, std::vector< MachSymbolData > &LocalSymbolData, std::vector< MachSymbolData > &ExternalSymbolData, std::vector< MachSymbolData > &UndefinedSymbolData)
Compute the symbol table data.
virtual bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm, const MCSymbol &A, const MCSymbol &B, bool InSet) const
bool isDefined(bool SetUsed=true) const
isDefined - Check if this symbol is defined (i.e., it has an address).
Definition: MCSymbol.h:249
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:323
symbol_range symbols()
Definition: MCAssembler.h:320
unsigned getLayoutOrder() const
Definition: MCSection.h:123
Target independent information on a fixup kind.
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:181
void writeBytes(const SmallVectorImpl< char > &ByteVec, unsigned ZeroFillSize=0)
size_t size() const
Definition: MCAssembler.h:309
std::vector< IndirectSymbolData >::iterator indirect_symbol_iterator
Definition: MCAssembler.h:78
uint64_t getSectionAddress(const MCSection *Sec) const
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:203
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:337
const unsigned Kind
void reset() override
lifetime management
uint64_t getSectionFileSize(const MCSection *Sec) const
Get the data size of the given section, as emitted to the object file.
Definition: MCFragment.cpp:181
bool isVirtualSection() const override
Check whether this section is "virtual", that is has no actual object file contents.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
const MCExpr * getVariableValue(bool SetUsed=true) const
getVariableValue - Get the value for variable symbols.
Definition: MCSymbol.h:300
bool operator<(int64_t V1, const APSInt &V2)
Definition: APSInt.h:326
LLVM Value Representation.
Definition: Value.h:73
indirect_symbol_iterator indirect_symbol_end()
Definition: MCAssembler.h:345
uint64_t OffsetToAlignment(uint64_t Value, uint64_t Align)
Returns the offset to the next integer (mod 2**64) that is greater than or equal to Value and is a mu...
Definition: MathExtras.h:719
uint64_t tell() const
tell - Return the current offset with the file.
Definition: raw_ostream.h:98
#define DEBUG(X)
Definition: Debug.h:118
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
void bindIndirectSymbols(MCAssembler &Asm)
void sort(Policy policy, RandomAccessIterator Start, RandomAccessIterator End, const Comparator &Comp=Comparator())
Definition: Parallel.h:199
std::vector< DataRegionData > & getDataRegions()
Definition: MCAssembler.h:369
bool isPrivateExtern() const
Definition: MCSymbol.h:395
void writeNlist(MachSymbolData &MSD, const MCAsmLayout &Layout)
unsigned Flags
Flags describing additional information on this fixup kind.