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