LLVM  9.0.0svn
TargetLoweringObjectFileImpl.cpp
Go to the documentation of this file.
1 //===- llvm/CodeGen/TargetLoweringObjectFileImpl.cpp - Object File Info ---===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements classes used to handle lowerings specific to common
10 // object file formats.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/ADT/SmallString.h"
16 #include "llvm/ADT/SmallVector.h"
17 #include "llvm/ADT/StringExtras.h"
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/ADT/Triple.h"
20 #include "llvm/BinaryFormat/COFF.h"
22 #include "llvm/BinaryFormat/ELF.h"
26 #include "llvm/IR/Comdat.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DataLayout.h"
29 #include "llvm/IR/DerivedTypes.h"
30 #include "llvm/IR/Function.h"
31 #include "llvm/IR/GlobalAlias.h"
32 #include "llvm/IR/GlobalObject.h"
33 #include "llvm/IR/GlobalValue.h"
34 #include "llvm/IR/GlobalVariable.h"
35 #include "llvm/IR/Mangler.h"
36 #include "llvm/IR/Metadata.h"
37 #include "llvm/IR/Module.h"
38 #include "llvm/IR/Type.h"
39 #include "llvm/MC/MCAsmInfo.h"
40 #include "llvm/MC/MCContext.h"
41 #include "llvm/MC/MCExpr.h"
42 #include "llvm/MC/MCSectionCOFF.h"
43 #include "llvm/MC/MCSectionELF.h"
44 #include "llvm/MC/MCSectionMachO.h"
45 #include "llvm/MC/MCSectionWasm.h"
46 #include "llvm/MC/MCStreamer.h"
47 #include "llvm/MC/MCSymbol.h"
48 #include "llvm/MC/MCSymbolELF.h"
49 #include "llvm/MC/MCValue.h"
50 #include "llvm/MC/SectionKind.h"
52 #include "llvm/Support/Casting.h"
53 #include "llvm/Support/CodeGen.h"
54 #include "llvm/Support/Format.h"
58 #include <cassert>
59 #include <string>
60 
61 using namespace llvm;
62 using namespace dwarf;
63 
64 static void GetObjCImageInfo(Module &M, unsigned &Version, unsigned &Flags,
65  StringRef &Section) {
67  M.getModuleFlagsMetadata(ModuleFlags);
68 
69  for (const auto &MFE: ModuleFlags) {
70  // Ignore flags with 'Require' behaviour.
71  if (MFE.Behavior == Module::Require)
72  continue;
73 
74  StringRef Key = MFE.Key->getString();
75  if (Key == "Objective-C Image Info Version") {
76  Version = mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
77  } else if (Key == "Objective-C Garbage Collection" ||
78  Key == "Objective-C GC Only" ||
79  Key == "Objective-C Is Simulated" ||
80  Key == "Objective-C Class Properties" ||
81  Key == "Objective-C Image Swift Version") {
82  Flags |= mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
83  } else if (Key == "Objective-C Image Info Section") {
84  Section = cast<MDString>(MFE.Val)->getString();
85  }
86  }
87 }
88 
89 //===----------------------------------------------------------------------===//
90 // ELF
91 //===----------------------------------------------------------------------===//
92 
94  const TargetMachine &TgtM) {
96  TM = &TgtM;
97 
98  CodeModel::Model CM = TgtM.getCodeModel();
99 
100  switch (TgtM.getTargetTriple().getArch()) {
101  case Triple::arm:
102  case Triple::armeb:
103  case Triple::thumb:
104  case Triple::thumbeb:
106  break;
107  // Fallthrough if not using EHABI
109  case Triple::ppc:
110  case Triple::x86:
111  PersonalityEncoding = isPositionIndependent()
116  LSDAEncoding = isPositionIndependent()
119  TTypeEncoding = isPositionIndependent()
123  break;
124  case Triple::x86_64:
125  if (isPositionIndependent()) {
126  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
127  ((CM == CodeModel::Small || CM == CodeModel::Medium)
129  LSDAEncoding = dwarf::DW_EH_PE_pcrel |
130  (CM == CodeModel::Small
133  ((CM == CodeModel::Small || CM == CodeModel::Medium)
134  ? dwarf::DW_EH_PE_sdata8 : dwarf::DW_EH_PE_sdata4);
135  } else {
136  PersonalityEncoding =
137  (CM == CodeModel::Small || CM == CodeModel::Medium)
139  LSDAEncoding = (CM == CodeModel::Small)
141  TTypeEncoding = (CM == CodeModel::Small)
143  }
144  break;
145  case Triple::hexagon:
146  PersonalityEncoding = dwarf::DW_EH_PE_absptr;
147  LSDAEncoding = dwarf::DW_EH_PE_absptr;
148  TTypeEncoding = dwarf::DW_EH_PE_absptr;
149  if (isPositionIndependent()) {
150  PersonalityEncoding |= dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel;
151  LSDAEncoding |= dwarf::DW_EH_PE_pcrel;
153  }
154  break;
155  case Triple::aarch64:
156  case Triple::aarch64_be:
157  // The small model guarantees static code/data size < 4GB, but not where it
158  // will be in memory. Most of these could end up >2GB away so even a signed
159  // pc-relative 32-bit address is insufficient, theoretically.
160  if (isPositionIndependent()) {
161  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
166  } else {
167  PersonalityEncoding = dwarf::DW_EH_PE_absptr;
168  LSDAEncoding = dwarf::DW_EH_PE_absptr;
169  TTypeEncoding = dwarf::DW_EH_PE_absptr;
170  }
171  break;
172  case Triple::lanai:
173  LSDAEncoding = dwarf::DW_EH_PE_absptr;
174  PersonalityEncoding = dwarf::DW_EH_PE_absptr;
175  TTypeEncoding = dwarf::DW_EH_PE_absptr;
176  break;
177  case Triple::mips:
178  case Triple::mipsel:
179  case Triple::mips64:
180  case Triple::mips64el:
181  // MIPS uses indirect pointer to refer personality functions and types, so
182  // that the eh_frame section can be read-only. DW.ref.personality will be
183  // generated for relocation.
184  PersonalityEncoding = dwarf::DW_EH_PE_indirect;
185  // FIXME: The N64 ABI probably ought to use DW_EH_PE_sdata8 but we can't
186  // identify N64 from just a triple.
189  // We don't support PC-relative LSDA references in GAS so we use the default
190  // DW_EH_PE_absptr for those.
191 
192  // FreeBSD must be explicit about the data size and using pcrel since it's
193  // assembler/linker won't do the automatic conversion that the Linux tools
194  // do.
195  if (TgtM.getTargetTriple().isOSFreeBSD()) {
196  PersonalityEncoding |= dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
198  }
199  break;
200  case Triple::ppc64:
201  case Triple::ppc64le:
202  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
207  break;
208  case Triple::sparcel:
209  case Triple::sparc:
210  if (isPositionIndependent()) {
212  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
216  } else {
217  LSDAEncoding = dwarf::DW_EH_PE_absptr;
218  PersonalityEncoding = dwarf::DW_EH_PE_absptr;
219  TTypeEncoding = dwarf::DW_EH_PE_absptr;
220  }
221  break;
222  case Triple::sparcv9:
224  if (isPositionIndependent()) {
225  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
229  } else {
230  PersonalityEncoding = dwarf::DW_EH_PE_absptr;
231  TTypeEncoding = dwarf::DW_EH_PE_absptr;
232  }
233  break;
234  case Triple::systemz:
235  // All currently-defined code models guarantee that 4-byte PC-relative
236  // values will be in range.
237  if (isPositionIndependent()) {
238  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
243  } else {
244  PersonalityEncoding = dwarf::DW_EH_PE_absptr;
245  LSDAEncoding = dwarf::DW_EH_PE_absptr;
246  TTypeEncoding = dwarf::DW_EH_PE_absptr;
247  }
248  break;
249  default:
250  break;
251  }
252 }
253 
255  Module &M) const {
256  auto &C = getContext();
257 
258  if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
259  auto *S = C.getELFSection(".linker-options", ELF::SHT_LLVM_LINKER_OPTIONS,
261 
262  Streamer.SwitchSection(S);
263 
264  for (const auto &Operand : LinkerOptions->operands()) {
265  if (cast<MDNode>(Operand)->getNumOperands() != 2)
266  report_fatal_error("invalid llvm.linker.options");
267  for (const auto &Option : cast<MDNode>(Operand)->operands()) {
268  Streamer.EmitBytes(cast<MDString>(Option)->getString());
269  Streamer.EmitIntValue(0, 1);
270  }
271  }
272  }
273 
274  if (NamedMDNode *DependentLibraries = M.getNamedMetadata("llvm.dependent-libraries")) {
275  auto *S = C.getELFSection(".deplibs", ELF::SHT_LLVM_DEPENDENT_LIBRARIES,
277 
278  Streamer.SwitchSection(S);
279 
280  for (const auto &Operand : DependentLibraries->operands()) {
281  Streamer.EmitBytes(
282  cast<MDString>(cast<MDNode>(Operand)->getOperand(0))->getString());
283  Streamer.EmitIntValue(0, 1);
284  }
285  }
286 
287  unsigned Version = 0;
288  unsigned Flags = 0;
290 
291  GetObjCImageInfo(M, Version, Flags, Section);
292  if (!Section.empty()) {
293  auto *S = C.getELFSection(Section, ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
294  Streamer.SwitchSection(S);
295  Streamer.EmitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
296  Streamer.EmitIntValue(Version, 4);
297  Streamer.EmitIntValue(Flags, 4);
298  Streamer.AddBlankLine();
299  }
300 
302  M.getModuleFlagsMetadata(ModuleFlags);
303 
304  MDNode *CFGProfile = nullptr;
305 
306  for (const auto &MFE : ModuleFlags) {
307  StringRef Key = MFE.Key->getString();
308  if (Key == "CG Profile") {
309  CFGProfile = cast<MDNode>(MFE.Val);
310  break;
311  }
312  }
313 
314  if (!CFGProfile)
315  return;
316 
317  auto GetSym = [this](const MDOperand &MDO) -> MCSymbol * {
318  if (!MDO)
319  return nullptr;
320  auto V = cast<ValueAsMetadata>(MDO);
321  const Function *F = cast<Function>(V->getValue());
322  return TM->getSymbol(F);
323  };
324 
325  for (const auto &Edge : CFGProfile->operands()) {
326  MDNode *E = cast<MDNode>(Edge);
327  const MCSymbol *From = GetSym(E->getOperand(0));
328  const MCSymbol *To = GetSym(E->getOperand(1));
329  // Skip null functions. This can happen if functions are dead stripped after
330  // the CGProfile pass has been run.
331  if (!From || !To)
332  continue;
333  uint64_t Count = cast<ConstantAsMetadata>(E->getOperand(2))
334  ->getValue()
335  ->getUniqueInteger()
336  .getZExtValue();
337  Streamer.emitCGProfileEntry(
340  }
341 }
342 
344  const GlobalValue *GV, const TargetMachine &TM,
345  MachineModuleInfo *MMI) const {
346  unsigned Encoding = getPersonalityEncoding();
347  if ((Encoding & 0x80) == DW_EH_PE_indirect)
348  return getContext().getOrCreateSymbol(StringRef("DW.ref.") +
349  TM.getSymbol(GV)->getName());
350  if ((Encoding & 0x70) == DW_EH_PE_absptr)
351  return TM.getSymbol(GV);
352  report_fatal_error("We do not support this DWARF encoding yet!");
353 }
354 
356  MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym) const {
357  SmallString<64> NameData("DW.ref.");
358  NameData += Sym->getName();
359  MCSymbolELF *Label =
360  cast<MCSymbolELF>(getContext().getOrCreateSymbol(NameData));
361  Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
362  Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
363  unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
364  MCSection *Sec = getContext().getELFNamedSection(".data", Label->getName(),
365  ELF::SHT_PROGBITS, Flags, 0);
366  unsigned Size = DL.getPointerSize();
367  Streamer.SwitchSection(Sec);
369  Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
370  const MCExpr *E = MCConstantExpr::create(Size, getContext());
371  Streamer.emitELFSize(Label, E);
372  Streamer.EmitLabel(Label);
373 
374  Streamer.EmitSymbolValue(Sym, Size);
375 }
376 
378  const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
379  MachineModuleInfo *MMI, MCStreamer &Streamer) const {
380  if (Encoding & DW_EH_PE_indirect) {
382 
383  MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", TM);
384 
385  // Add information about the stub reference to ELFMMI so that the stub
386  // gets emitted by the asmprinter.
387  MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
388  if (!StubSym.getPointer()) {
389  MCSymbol *Sym = TM.getSymbol(GV);
391  }
392 
394  getTTypeReference(MCSymbolRefExpr::create(SSym, getContext()),
395  Encoding & ~DW_EH_PE_indirect, Streamer);
396  }
397 
399  MMI, Streamer);
400 }
401 
403  // N.B.: The defaults used in here are not the same ones used in MC.
404  // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
405  // both gas and MC will produce a section with no flags. Given
406  // section(".eh_frame") gcc will produce:
407  //
408  // .section .eh_frame,"a",@progbits
409 
410  if (Name == getInstrProfSectionName(IPSK_covmap, Triple::ELF,
411  /*AddSegmentInfo=*/false))
412  return SectionKind::getMetadata();
413 
414  if (Name.empty() || Name[0] != '.') return K;
415 
416  // Default implementation based on some magic section names.
417  if (Name == ".bss" ||
418  Name.startswith(".bss.") ||
419  Name.startswith(".gnu.linkonce.b.") ||
420  Name.startswith(".llvm.linkonce.b.") ||
421  Name == ".sbss" ||
422  Name.startswith(".sbss.") ||
423  Name.startswith(".gnu.linkonce.sb.") ||
424  Name.startswith(".llvm.linkonce.sb."))
425  return SectionKind::getBSS();
426 
427  if (Name == ".tdata" ||
428  Name.startswith(".tdata.") ||
429  Name.startswith(".gnu.linkonce.td.") ||
430  Name.startswith(".llvm.linkonce.td."))
432 
433  if (Name == ".tbss" ||
434  Name.startswith(".tbss.") ||
435  Name.startswith(".gnu.linkonce.tb.") ||
436  Name.startswith(".llvm.linkonce.tb."))
437  return SectionKind::getThreadBSS();
438 
439  return K;
440 }
441 
443  // Use SHT_NOTE for section whose name starts with ".note" to allow
444  // emitting ELF notes from C variable declaration.
445  // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77609
446  if (Name.startswith(".note"))
447  return ELF::SHT_NOTE;
448 
449  if (Name == ".init_array")
450  return ELF::SHT_INIT_ARRAY;
451 
452  if (Name == ".fini_array")
453  return ELF::SHT_FINI_ARRAY;
454 
455  if (Name == ".preinit_array")
456  return ELF::SHT_PREINIT_ARRAY;
457 
458  if (K.isBSS() || K.isThreadBSS())
459  return ELF::SHT_NOBITS;
460 
461  return ELF::SHT_PROGBITS;
462 }
463 
464 static unsigned getELFSectionFlags(SectionKind K) {
465  unsigned Flags = 0;
466 
467  if (!K.isMetadata())
468  Flags |= ELF::SHF_ALLOC;
469 
470  if (K.isText())
471  Flags |= ELF::SHF_EXECINSTR;
472 
473  if (K.isExecuteOnly())
474  Flags |= ELF::SHF_ARM_PURECODE;
475 
476  if (K.isWriteable())
477  Flags |= ELF::SHF_WRITE;
478 
479  if (K.isThreadLocal())
480  Flags |= ELF::SHF_TLS;
481 
482  if (K.isMergeableCString() || K.isMergeableConst())
483  Flags |= ELF::SHF_MERGE;
484 
485  if (K.isMergeableCString())
486  Flags |= ELF::SHF_STRINGS;
487 
488  return Flags;
489 }
490 
491 static const Comdat *getELFComdat(const GlobalValue *GV) {
492  const Comdat *C = GV->getComdat();
493  if (!C)
494  return nullptr;
495 
496  if (C->getSelectionKind() != Comdat::Any)
497  report_fatal_error("ELF COMDATs only support SelectionKind::Any, '" +
498  C->getName() + "' cannot be lowered.");
499 
500  return C;
501 }
502 
504  const TargetMachine &TM) {
506  if (!MD)
507  return nullptr;
508 
509  const MDOperand &Op = MD->getOperand(0);
510  if (!Op.get())
511  return nullptr;
512 
513  auto *VM = dyn_cast<ValueAsMetadata>(Op);
514  if (!VM)
515  report_fatal_error("MD_associated operand is not ValueAsMetadata");
516 
517  GlobalObject *OtherGO = dyn_cast<GlobalObject>(VM->getValue());
518  return OtherGO ? dyn_cast<MCSymbolELF>(TM.getSymbol(OtherGO)) : nullptr;
519 }
520 
522  if (Kind.isMergeable1ByteCString())
523  return 1;
524  else if (Kind.isMergeable2ByteCString())
525  return 2;
526  else if (Kind.isMergeable4ByteCString())
527  return 4;
528  else if (Kind.isMergeableConst4())
529  return 4;
530  else if (Kind.isMergeableConst8())
531  return 8;
532  else if (Kind.isMergeableConst16())
533  return 16;
534  else if (Kind.isMergeableConst32())
535  return 32;
536  else {
537  // We shouldn't have mergeable C strings or mergeable constants that we
538  // didn't handle above.
539  assert(!Kind.isMergeableCString() && "unknown string width");
540  assert(!Kind.isMergeableConst() && "unknown data width");
541  return 0;
542  }
543 }
544 
546  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
548 
549  // Check if '#pragma clang section' name is applicable.
550  // Note that pragma directive overrides -ffunction-section, -fdata-section
551  // and so section name is exactly as user specified and not uniqued.
552  const GlobalVariable *GV = dyn_cast<GlobalVariable>(GO);
553  if (GV && GV->hasImplicitSection()) {
554  auto Attrs = GV->getAttributes();
555  if (Attrs.hasAttribute("bss-section") && Kind.isBSS()) {
556  SectionName = Attrs.getAttribute("bss-section").getValueAsString();
557  } else if (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly()) {
558  SectionName = Attrs.getAttribute("rodata-section").getValueAsString();
559  } else if (Attrs.hasAttribute("data-section") && Kind.isData()) {
560  SectionName = Attrs.getAttribute("data-section").getValueAsString();
561  }
562  }
563  const Function *F = dyn_cast<Function>(GO);
564  if (F && F->hasFnAttribute("implicit-section-name")) {
565  SectionName = F->getFnAttribute("implicit-section-name").getValueAsString();
566  }
567 
568  // Infer section flags from the section name if we can.
569  Kind = getELFKindForNamedSection(SectionName, Kind);
570 
571  StringRef Group = "";
572  unsigned Flags = getELFSectionFlags(Kind);
573  if (const Comdat *C = getELFComdat(GO)) {
574  Group = C->getName();
575  Flags |= ELF::SHF_GROUP;
576  }
577 
578  // A section can have at most one associated section. Put each global with
579  // MD_associated in a unique section.
580  unsigned UniqueID = MCContext::GenericSectionID;
581  const MCSymbolELF *AssociatedSymbol = getAssociatedSymbol(GO, TM);
582  if (AssociatedSymbol) {
583  UniqueID = NextUniqueID++;
584  Flags |= ELF::SHF_LINK_ORDER;
585  }
586 
587  MCSectionELF *Section = getContext().getELFSection(
588  SectionName, getELFSectionType(SectionName, Kind), Flags,
589  getEntrySizeForKind(Kind), Group, UniqueID, AssociatedSymbol);
590  // Make sure that we did not get some other section with incompatible sh_link.
591  // This should not be possible due to UniqueID code above.
592  assert(Section->getAssociatedSymbol() == AssociatedSymbol &&
593  "Associated symbol mismatch between sections");
594  return Section;
595 }
596 
597 /// Return the section prefix name used by options FunctionsSections and
598 /// DataSections.
600  if (Kind.isText())
601  return ".text";
602  if (Kind.isReadOnly())
603  return ".rodata";
604  if (Kind.isBSS())
605  return ".bss";
606  if (Kind.isThreadData())
607  return ".tdata";
608  if (Kind.isThreadBSS())
609  return ".tbss";
610  if (Kind.isData())
611  return ".data";
612  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
613  return ".data.rel.ro";
614 }
615 
617  MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
618  const TargetMachine &TM, bool EmitUniqueSection, unsigned Flags,
619  unsigned *NextUniqueID, const MCSymbolELF *AssociatedSymbol) {
620 
621  StringRef Group = "";
622  if (const Comdat *C = getELFComdat(GO)) {
623  Flags |= ELF::SHF_GROUP;
624  Group = C->getName();
625  }
626 
627  // Get the section entry size based on the kind.
628  unsigned EntrySize = getEntrySizeForKind(Kind);
629 
631  if (Kind.isMergeableCString()) {
632  // We also need alignment here.
633  // FIXME: this is getting the alignment of the character, not the
634  // alignment of the global!
636  cast<GlobalVariable>(GO));
637 
638  std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
639  Name = SizeSpec + utostr(Align);
640  } else if (Kind.isMergeableConst()) {
641  Name = ".rodata.cst";
642  Name += utostr(EntrySize);
643  } else {
644  Name = getSectionPrefixForGlobal(Kind);
645  }
646 
647  if (const auto *F = dyn_cast<Function>(GO)) {
648  const auto &OptionalPrefix = F->getSectionPrefix();
649  if (OptionalPrefix)
650  Name += *OptionalPrefix;
651  }
652 
653  unsigned UniqueID = MCContext::GenericSectionID;
654  if (EmitUniqueSection) {
655  if (TM.getUniqueSectionNames()) {
656  Name.push_back('.');
657  TM.getNameWithPrefix(Name, GO, Mang, true /*MayAlwaysUsePrivate*/);
658  } else {
659  UniqueID = *NextUniqueID;
660  (*NextUniqueID)++;
661  }
662  }
663  // Use 0 as the unique ID for execute-only text.
664  if (Kind.isExecuteOnly())
665  UniqueID = 0;
666  return Ctx.getELFSection(Name, getELFSectionType(Name, Kind), Flags,
667  EntrySize, Group, UniqueID, AssociatedSymbol);
668 }
669 
671  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
672  unsigned Flags = getELFSectionFlags(Kind);
673 
674  // If we have -ffunction-section or -fdata-section then we should emit the
675  // global value to a uniqued section specifically for it.
676  bool EmitUniqueSection = false;
677  if (!(Flags & ELF::SHF_MERGE) && !Kind.isCommon()) {
678  if (Kind.isText())
679  EmitUniqueSection = TM.getFunctionSections();
680  else
681  EmitUniqueSection = TM.getDataSections();
682  }
683  EmitUniqueSection |= GO->hasComdat();
684 
685  const MCSymbolELF *AssociatedSymbol = getAssociatedSymbol(GO, TM);
686  if (AssociatedSymbol) {
687  EmitUniqueSection = true;
688  Flags |= ELF::SHF_LINK_ORDER;
689  }
690 
692  getContext(), GO, Kind, getMangler(), TM, EmitUniqueSection, Flags,
693  &NextUniqueID, AssociatedSymbol);
694  assert(Section->getAssociatedSymbol() == AssociatedSymbol);
695  return Section;
696 }
697 
699  const Function &F, const TargetMachine &TM) const {
700  // If the function can be removed, produce a unique section so that
701  // the table doesn't prevent the removal.
702  const Comdat *C = F.getComdat();
703  bool EmitUniqueSection = TM.getFunctionSections() || C;
704  if (!EmitUniqueSection)
705  return ReadOnlySection;
706 
707  return selectELFSectionForGlobal(getContext(), &F, SectionKind::getReadOnly(),
708  getMangler(), TM, EmitUniqueSection,
709  ELF::SHF_ALLOC, &NextUniqueID,
710  /* AssociatedSymbol */ nullptr);
711 }
712 
714  bool UsesLabelDifference, const Function &F) const {
715  // We can always create relative relocations, so use another section
716  // that can be marked non-executable.
717  return false;
718 }
719 
720 /// Given a mergeable constant with the specified size and relocation
721 /// information, return a section that it should be placed in.
723  const DataLayout &DL, SectionKind Kind, const Constant *C,
724  unsigned &Align) const {
725  if (Kind.isMergeableConst4() && MergeableConst4Section)
726  return MergeableConst4Section;
727  if (Kind.isMergeableConst8() && MergeableConst8Section)
728  return MergeableConst8Section;
729  if (Kind.isMergeableConst16() && MergeableConst16Section)
730  return MergeableConst16Section;
731  if (Kind.isMergeableConst32() && MergeableConst32Section)
732  return MergeableConst32Section;
733  if (Kind.isReadOnly())
734  return ReadOnlySection;
735 
736  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
737  return DataRelROSection;
738 }
739 
740 static MCSectionELF *getStaticStructorSection(MCContext &Ctx, bool UseInitArray,
741  bool IsCtor, unsigned Priority,
742  const MCSymbol *KeySym) {
743  std::string Name;
744  unsigned Type;
745  unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE;
746  StringRef COMDAT = KeySym ? KeySym->getName() : "";
747 
748  if (KeySym)
749  Flags |= ELF::SHF_GROUP;
750 
751  if (UseInitArray) {
752  if (IsCtor) {
753  Type = ELF::SHT_INIT_ARRAY;
754  Name = ".init_array";
755  } else {
756  Type = ELF::SHT_FINI_ARRAY;
757  Name = ".fini_array";
758  }
759  if (Priority != 65535) {
760  Name += '.';
761  Name += utostr(Priority);
762  }
763  } else {
764  // The default scheme is .ctor / .dtor, so we have to invert the priority
765  // numbering.
766  if (IsCtor)
767  Name = ".ctors";
768  else
769  Name = ".dtors";
770  if (Priority != 65535)
771  raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
772  Type = ELF::SHT_PROGBITS;
773  }
774 
775  return Ctx.getELFSection(Name, Type, Flags, 0, COMDAT);
776 }
777 
779  unsigned Priority, const MCSymbol *KeySym) const {
780  return getStaticStructorSection(getContext(), UseInitArray, true, Priority,
781  KeySym);
782 }
783 
785  unsigned Priority, const MCSymbol *KeySym) const {
786  return getStaticStructorSection(getContext(), UseInitArray, false, Priority,
787  KeySym);
788 }
789 
791  const GlobalValue *LHS, const GlobalValue *RHS,
792  const TargetMachine &TM) const {
793  // We may only use a PLT-relative relocation to refer to unnamed_addr
794  // functions.
795  if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
796  return nullptr;
797 
798  // Basic sanity checks.
799  if (LHS->getType()->getPointerAddressSpace() != 0 ||
800  RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
801  RHS->isThreadLocal())
802  return nullptr;
803 
805  MCSymbolRefExpr::create(TM.getSymbol(LHS), PLTRelativeVariantKind,
806  getContext()),
807  MCSymbolRefExpr::create(TM.getSymbol(RHS), getContext()), getContext());
808 }
809 
811  // Use ".GCC.command.line" since this feature is to support clang's
812  // -frecord-gcc-switches which in turn attempts to mimic GCC's switch of the
813  // same name.
814  return getContext().getELFSection(".GCC.command.line", ELF::SHT_PROGBITS,
816 }
817 
818 void
820  UseInitArray = UseInitArray_;
821  MCContext &Ctx = getContext();
822  if (!UseInitArray) {
823  StaticCtorSection = Ctx.getELFSection(".ctors", ELF::SHT_PROGBITS,
825 
826  StaticDtorSection = Ctx.getELFSection(".dtors", ELF::SHT_PROGBITS,
828  return;
829  }
830 
831  StaticCtorSection = Ctx.getELFSection(".init_array", ELF::SHT_INIT_ARRAY,
833  StaticDtorSection = Ctx.getELFSection(".fini_array", ELF::SHT_FINI_ARRAY,
835 }
836 
837 //===----------------------------------------------------------------------===//
838 // MachO
839 //===----------------------------------------------------------------------===//
840 
844 }
845 
847  const TargetMachine &TM) {
849  if (TM.getRelocationModel() == Reloc::Static) {
850  StaticCtorSection = Ctx.getMachOSection("__TEXT", "__constructor", 0,
852  StaticDtorSection = Ctx.getMachOSection("__TEXT", "__destructor", 0,
854  } else {
855  StaticCtorSection = Ctx.getMachOSection("__DATA", "__mod_init_func",
858  StaticDtorSection = Ctx.getMachOSection("__DATA", "__mod_term_func",
861  }
862 
866  TTypeEncoding =
868 }
869 
871  Module &M) const {
872  // Emit the linker options if present.
873  if (auto *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
874  for (const auto &Option : LinkerOptions->operands()) {
875  SmallVector<std::string, 4> StrOptions;
876  for (const auto &Piece : cast<MDNode>(Option)->operands())
877  StrOptions.push_back(cast<MDString>(Piece)->getString());
878  Streamer.EmitLinkerOptions(StrOptions);
879  }
880  }
881 
882  unsigned VersionVal = 0;
883  unsigned ImageInfoFlags = 0;
884  StringRef SectionVal;
885 
886  GetObjCImageInfo(M, VersionVal, ImageInfoFlags, SectionVal);
887 
888  // The section is mandatory. If we don't have it, then we don't have GC info.
889  if (SectionVal.empty())
890  return;
891 
892  StringRef Segment, Section;
893  unsigned TAA = 0, StubSize = 0;
894  bool TAAParsed;
895  std::string ErrorCode =
896  MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section,
897  TAA, TAAParsed, StubSize);
898  if (!ErrorCode.empty())
899  // If invalid, report the error with report_fatal_error.
900  report_fatal_error("Invalid section specifier '" + Section + "': " +
901  ErrorCode + ".");
902 
903  // Get the section.
905  Segment, Section, TAA, StubSize, SectionKind::getData());
906  Streamer.SwitchSection(S);
907  Streamer.EmitLabel(getContext().
908  getOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
909  Streamer.EmitIntValue(VersionVal, 4);
910  Streamer.EmitIntValue(ImageInfoFlags, 4);
911  Streamer.AddBlankLine();
912 }
913 
914 static void checkMachOComdat(const GlobalValue *GV) {
915  const Comdat *C = GV->getComdat();
916  if (!C)
917  return;
918 
919  report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() +
920  "' cannot be lowered.");
921 }
922 
924  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
925  // Parse the section specifier and create it if valid.
926  StringRef Segment, Section;
927  unsigned TAA = 0, StubSize = 0;
928  bool TAAParsed;
929 
930  checkMachOComdat(GO);
931 
932  std::string ErrorCode =
934  TAA, TAAParsed, StubSize);
935  if (!ErrorCode.empty()) {
936  // If invalid, report the error with report_fatal_error.
937  report_fatal_error("Global variable '" + GO->getName() +
938  "' has an invalid section specifier '" +
939  GO->getSection() + "': " + ErrorCode + ".");
940  }
941 
942  // Get the section.
943  MCSectionMachO *S =
944  getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
945 
946  // If TAA wasn't set by ParseSectionSpecifier() above,
947  // use the value returned by getMachOSection() as a default.
948  if (!TAAParsed)
949  TAA = S->getTypeAndAttributes();
950 
951  // Okay, now that we got the section, verify that the TAA & StubSize agree.
952  // If the user declared multiple globals with different section flags, we need
953  // to reject it here.
954  if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
955  // If invalid, report the error with report_fatal_error.
956  report_fatal_error("Global variable '" + GO->getName() +
957  "' section type or attributes does not match previous"
958  " section specifier");
959  }
960 
961  return S;
962 }
963 
965  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
966  checkMachOComdat(GO);
967 
968  // Handle thread local data.
969  if (Kind.isThreadBSS()) return TLSBSSSection;
970  if (Kind.isThreadData()) return TLSDataSection;
971 
972  if (Kind.isText())
974 
975  // If this is weak/linkonce, put this in a coalescable section, either in text
976  // or data depending on if it is writable.
977  if (GO->isWeakForLinker()) {
978  if (Kind.isReadOnly())
979  return ConstTextCoalSection;
980  if (Kind.isReadOnlyWithRel())
981  return ConstDataCoalSection;
982  return DataCoalSection;
983  }
984 
985  // FIXME: Alignment check should be handled by section classifier.
986  if (Kind.isMergeable1ByteCString() &&
988  cast<GlobalVariable>(GO)) < 32)
989  return CStringSection;
990 
991  // Do not put 16-bit arrays in the UString section if they have an
992  // externally visible label, this runs into issues with certain linker
993  // versions.
994  if (Kind.isMergeable2ByteCString() && !GO->hasExternalLinkage() &&
996  cast<GlobalVariable>(GO)) < 32)
997  return UStringSection;
998 
999  // With MachO only variables whose corresponding symbol starts with 'l' or
1000  // 'L' can be merged, so we only try merging GVs with private linkage.
1001  if (GO->hasPrivateLinkage() && Kind.isMergeableConst()) {
1002  if (Kind.isMergeableConst4())
1003  return FourByteConstantSection;
1004  if (Kind.isMergeableConst8())
1005  return EightByteConstantSection;
1006  if (Kind.isMergeableConst16())
1008  }
1009 
1010  // Otherwise, if it is readonly, but not something we can specially optimize,
1011  // just drop it in .const.
1012  if (Kind.isReadOnly())
1013  return ReadOnlySection;
1014 
1015  // If this is marked const, put it into a const section. But if the dynamic
1016  // linker needs to write to it, put it in the data segment.
1017  if (Kind.isReadOnlyWithRel())
1018  return ConstDataSection;
1019 
1020  // Put zero initialized globals with strong external linkage in the
1021  // DATA, __common section with the .zerofill directive.
1022  if (Kind.isBSSExtern())
1023  return DataCommonSection;
1024 
1025  // Put zero initialized globals with local linkage in __DATA,__bss directive
1026  // with the .zerofill directive (aka .lcomm).
1027  if (Kind.isBSSLocal())
1028  return DataBSSSection;
1029 
1030  // Otherwise, just drop the variable in the normal data section.
1031  return DataSection;
1032 }
1033 
1035  const DataLayout &DL, SectionKind Kind, const Constant *C,
1036  unsigned &Align) const {
1037  // If this constant requires a relocation, we have to put it in the data
1038  // segment, not in the text segment.
1039  if (Kind.isData() || Kind.isReadOnlyWithRel())
1040  return ConstDataSection;
1041 
1042  if (Kind.isMergeableConst4())
1043  return FourByteConstantSection;
1044  if (Kind.isMergeableConst8())
1045  return EightByteConstantSection;
1046  if (Kind.isMergeableConst16())
1048  return ReadOnlySection; // .const
1049 }
1050 
1052  const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
1053  MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1054  // The mach-o version of this method defaults to returning a stub reference.
1055 
1056  if (Encoding & DW_EH_PE_indirect) {
1057  MachineModuleInfoMachO &MachOMMI =
1059 
1060  MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
1061 
1062  // Add information about the stub reference to MachOMMI so that the stub
1063  // gets emitted by the asmprinter.
1064  MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
1065  if (!StubSym.getPointer()) {
1066  MCSymbol *Sym = TM.getSymbol(GV);
1067  StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
1068  }
1069 
1072  Encoding & ~DW_EH_PE_indirect, Streamer);
1073  }
1074 
1075  return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM,
1076  MMI, Streamer);
1077 }
1078 
1080  const GlobalValue *GV, const TargetMachine &TM,
1081  MachineModuleInfo *MMI) const {
1082  // The mach-o version of this method defaults to returning a stub reference.
1083  MachineModuleInfoMachO &MachOMMI =
1085 
1086  MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
1087 
1088  // Add information about the stub reference to MachOMMI so that the stub
1089  // gets emitted by the asmprinter.
1090  MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
1091  if (!StubSym.getPointer()) {
1092  MCSymbol *Sym = TM.getSymbol(GV);
1093  StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
1094  }
1095 
1096  return SSym;
1097 }
1098 
1100  const MCSymbol *Sym, const MCValue &MV, int64_t Offset,
1101  MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1102  // Although MachO 32-bit targets do not explicitly have a GOTPCREL relocation
1103  // as 64-bit do, we replace the GOT equivalent by accessing the final symbol
1104  // through a non_lazy_ptr stub instead. One advantage is that it allows the
1105  // computation of deltas to final external symbols. Example:
1106  //
1107  // _extgotequiv:
1108  // .long _extfoo
1109  //
1110  // _delta:
1111  // .long _extgotequiv-_delta
1112  //
1113  // is transformed to:
1114  //
1115  // _delta:
1116  // .long L_extfoo$non_lazy_ptr-(_delta+0)
1117  //
1118  // .section __IMPORT,__pointers,non_lazy_symbol_pointers
1119  // L_extfoo$non_lazy_ptr:
1120  // .indirect_symbol _extfoo
1121  // .long 0
1122  //
1123  // The indirect symbol table (and sections of non_lazy_symbol_pointers type)
1124  // may point to both local (same translation unit) and global (other
1125  // translation units) symbols. Example:
1126  //
1127  // .section __DATA,__pointers,non_lazy_symbol_pointers
1128  // L1:
1129  // .indirect_symbol _myGlobal
1130  // .long 0
1131  // L2:
1132  // .indirect_symbol _myLocal
1133  // .long _myLocal
1134  //
1135  // If the symbol is local, instead of the symbol's index, the assembler
1136  // places the constant INDIRECT_SYMBOL_LOCAL into the indirect symbol table.
1137  // Then the linker will notice the constant in the table and will look at the
1138  // content of the symbol.
1139  MachineModuleInfoMachO &MachOMMI =
1141  MCContext &Ctx = getContext();
1142 
1143  // The offset must consider the original displacement from the base symbol
1144  // since 32-bit targets don't have a GOTPCREL to fold the PC displacement.
1145  Offset = -MV.getConstant();
1146  const MCSymbol *BaseSym = &MV.getSymB()->getSymbol();
1147 
1148  // Access the final symbol via sym$non_lazy_ptr and generate the appropriated
1149  // non_lazy_ptr stubs.
1151  StringRef Suffix = "$non_lazy_ptr";
1152  Name += MMI->getModule()->getDataLayout().getPrivateGlobalPrefix();
1153  Name += Sym->getName();
1154  Name += Suffix;
1155  MCSymbol *Stub = Ctx.getOrCreateSymbol(Name);
1156 
1157  MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Stub);
1158  if (!StubSym.getPointer()) {
1159  bool IsIndirectLocal = Sym->isDefined() && !Sym->isExternal();
1160  // With the assumption that IsIndirectLocal == GV->hasLocalLinkage().
1161  StubSym = MachineModuleInfoImpl::StubValueTy(const_cast<MCSymbol *>(Sym),
1162  !IsIndirectLocal);
1163  }
1164 
1165  const MCExpr *BSymExpr =
1167  const MCExpr *LHS =
1169 
1170  if (!Offset)
1171  return MCBinaryExpr::createSub(LHS, BSymExpr, Ctx);
1172 
1173  const MCExpr *RHS =
1174  MCBinaryExpr::createAdd(BSymExpr, MCConstantExpr::create(Offset, Ctx), Ctx);
1175  return MCBinaryExpr::createSub(LHS, RHS, Ctx);
1176 }
1177 
1178 static bool canUsePrivateLabel(const MCAsmInfo &AsmInfo,
1179  const MCSection &Section) {
1180  if (!AsmInfo.isSectionAtomizableBySymbols(Section))
1181  return true;
1182 
1183  // If it is not dead stripped, it is safe to use private labels.
1184  const MCSectionMachO &SMO = cast<MCSectionMachO>(Section);
1186  return true;
1187 
1188  return false;
1189 }
1190 
1192  SmallVectorImpl<char> &OutName, const GlobalValue *GV,
1193  const TargetMachine &TM) const {
1194  bool CannotUsePrivateLabel = true;
1195  if (auto *GO = GV->getBaseObject()) {
1197  const MCSection *TheSection = SectionForGlobal(GO, GOKind, TM);
1198  CannotUsePrivateLabel =
1199  !canUsePrivateLabel(*TM.getMCAsmInfo(), *TheSection);
1200  }
1201  getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
1202 }
1203 
1204 //===----------------------------------------------------------------------===//
1205 // COFF
1206 //===----------------------------------------------------------------------===//
1207 
1208 static unsigned
1210  unsigned Flags = 0;
1211  bool isThumb = TM.getTargetTriple().getArch() == Triple::thumb;
1212 
1213  if (K.isMetadata())
1214  Flags |=
1216  else if (K.isText())
1217  Flags |=
1222  else if (K.isBSS())
1223  Flags |=
1227  else if (K.isThreadLocal())
1228  Flags |=
1232  else if (K.isReadOnly() || K.isReadOnlyWithRel())
1233  Flags |=
1236  else if (K.isWriteable())
1237  Flags |=
1241 
1242  return Flags;
1243 }
1244 
1245 static const GlobalValue *getComdatGVForCOFF(const GlobalValue *GV) {
1246  const Comdat *C = GV->getComdat();
1247  assert(C && "expected GV to have a Comdat!");
1248 
1249  StringRef ComdatGVName = C->getName();
1250  const GlobalValue *ComdatGV = GV->getParent()->getNamedValue(ComdatGVName);
1251  if (!ComdatGV)
1252  report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
1253  "' does not exist.");
1254 
1255  if (ComdatGV->getComdat() != C)
1256  report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
1257  "' is not a key for its COMDAT.");
1258 
1259  return ComdatGV;
1260 }
1261 
1262 static int getSelectionForCOFF(const GlobalValue *GV) {
1263  if (const Comdat *C = GV->getComdat()) {
1264  const GlobalValue *ComdatKey = getComdatGVForCOFF(GV);
1265  if (const auto *GA = dyn_cast<GlobalAlias>(ComdatKey))
1266  ComdatKey = GA->getBaseObject();
1267  if (ComdatKey == GV) {
1268  switch (C->getSelectionKind()) {
1269  case Comdat::Any:
1271  case Comdat::ExactMatch:
1273  case Comdat::Largest:
1275  case Comdat::NoDuplicates:
1277  case Comdat::SameSize:
1279  }
1280  } else {
1282  }
1283  }
1284  return 0;
1285 }
1286 
1288  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1289  int Selection = 0;
1290  unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1291  StringRef Name = GO->getSection();
1292  StringRef COMDATSymName = "";
1293  if (GO->hasComdat()) {
1294  Selection = getSelectionForCOFF(GO);
1295  const GlobalValue *ComdatGV;
1296  if (Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE)
1297  ComdatGV = getComdatGVForCOFF(GO);
1298  else
1299  ComdatGV = GO;
1300 
1301  if (!ComdatGV->hasPrivateLinkage()) {
1302  MCSymbol *Sym = TM.getSymbol(ComdatGV);
1303  COMDATSymName = Sym->getName();
1304  Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1305  } else {
1306  Selection = 0;
1307  }
1308  }
1309 
1310  return getContext().getCOFFSection(Name, Characteristics, Kind, COMDATSymName,
1311  Selection);
1312 }
1313 
1315  if (Kind.isText())
1316  return ".text";
1317  if (Kind.isBSS())
1318  return ".bss";
1319  if (Kind.isThreadLocal())
1320  return ".tls$";
1321  if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
1322  return ".rdata";
1323  return ".data";
1324 }
1325 
1327  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1328  // If we have -ffunction-sections then we should emit the global value to a
1329  // uniqued section specifically for it.
1330  bool EmitUniquedSection;
1331  if (Kind.isText())
1332  EmitUniquedSection = TM.getFunctionSections();
1333  else
1334  EmitUniquedSection = TM.getDataSections();
1335 
1336  if ((EmitUniquedSection && !Kind.isCommon()) || GO->hasComdat()) {
1338 
1339  unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1340 
1341  Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1342  int Selection = getSelectionForCOFF(GO);
1343  if (!Selection)
1345  const GlobalValue *ComdatGV;
1346  if (GO->hasComdat())
1347  ComdatGV = getComdatGVForCOFF(GO);
1348  else
1349  ComdatGV = GO;
1350 
1351  unsigned UniqueID = MCContext::GenericSectionID;
1352  if (EmitUniquedSection)
1353  UniqueID = NextUniqueID++;
1354 
1355  if (!ComdatGV->hasPrivateLinkage()) {
1356  MCSymbol *Sym = TM.getSymbol(ComdatGV);
1357  StringRef COMDATSymName = Sym->getName();
1358 
1359  // Append "$symbol" to the section name *before* IR-level mangling is
1360  // applied when targetting mingw. This is what GCC does, and the ld.bfd
1361  // COFF linker will not properly handle comdats otherwise.
1362  if (getTargetTriple().isWindowsGNUEnvironment())
1363  raw_svector_ostream(Name) << '$' << ComdatGV->getName();
1364 
1365  return getContext().getCOFFSection(Name, Characteristics, Kind,
1366  COMDATSymName, Selection, UniqueID);
1367  } else {
1368  SmallString<256> TmpData;
1369  getMangler().getNameWithPrefix(TmpData, GO, /*CannotUsePrivateLabel=*/true);
1370  return getContext().getCOFFSection(Name, Characteristics, Kind, TmpData,
1371  Selection, UniqueID);
1372  }
1373  }
1374 
1375  if (Kind.isText())
1376  return TextSection;
1377 
1378  if (Kind.isThreadLocal())
1379  return TLSDataSection;
1380 
1381  if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
1382  return ReadOnlySection;
1383 
1384  // Note: we claim that common symbols are put in BSSSection, but they are
1385  // really emitted with the magic .comm directive, which creates a symbol table
1386  // entry but not a section.
1387  if (Kind.isBSS() || Kind.isCommon())
1388  return BSSSection;
1389 
1390  return DataSection;
1391 }
1392 
1394  SmallVectorImpl<char> &OutName, const GlobalValue *GV,
1395  const TargetMachine &TM) const {
1396  bool CannotUsePrivateLabel = false;
1397  if (GV->hasPrivateLinkage() &&
1398  ((isa<Function>(GV) && TM.getFunctionSections()) ||
1399  (isa<GlobalVariable>(GV) && TM.getDataSections())))
1400  CannotUsePrivateLabel = true;
1401 
1402  getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
1403 }
1404 
1406  const Function &F, const TargetMachine &TM) const {
1407  // If the function can be removed, produce a unique section so that
1408  // the table doesn't prevent the removal.
1409  const Comdat *C = F.getComdat();
1410  bool EmitUniqueSection = TM.getFunctionSections() || C;
1411  if (!EmitUniqueSection)
1412  return ReadOnlySection;
1413 
1414  // FIXME: we should produce a symbol for F instead.
1415  if (F.hasPrivateLinkage())
1416  return ReadOnlySection;
1417 
1418  MCSymbol *Sym = TM.getSymbol(&F);
1419  StringRef COMDATSymName = Sym->getName();
1420 
1423  unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1424  Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1425  unsigned UniqueID = NextUniqueID++;
1426 
1427  return getContext().getCOFFSection(
1428  SecName, Characteristics, Kind, COMDATSymName,
1430 }
1431 
1433  Module &M) const {
1434  if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
1435  // Emit the linker options to the linker .drectve section. According to the
1436  // spec, this section is a space-separated string containing flags for
1437  // linker.
1438  MCSection *Sec = getDrectveSection();
1439  Streamer.SwitchSection(Sec);
1440  for (const auto &Option : LinkerOptions->operands()) {
1441  for (const auto &Piece : cast<MDNode>(Option)->operands()) {
1442  // Lead with a space for consistency with our dllexport implementation.
1443  std::string Directive(" ");
1444  Directive.append(cast<MDString>(Piece)->getString());
1445  Streamer.EmitBytes(Directive);
1446  }
1447  }
1448  }
1449 
1450  unsigned Version = 0;
1451  unsigned Flags = 0;
1453 
1454  GetObjCImageInfo(M, Version, Flags, Section);
1455  if (Section.empty())
1456  return;
1457 
1458  auto &C = getContext();
1459  auto *S = C.getCOFFSection(
1462  Streamer.SwitchSection(S);
1463  Streamer.EmitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
1464  Streamer.EmitIntValue(Version, 4);
1465  Streamer.EmitIntValue(Flags, 4);
1466  Streamer.AddBlankLine();
1467 }
1468 
1470  const TargetMachine &TM) {
1472  const Triple &T = TM.getTargetTriple();
1482  } else {
1491  }
1492 }
1493 
1495  const Triple &T, bool IsCtor,
1496  unsigned Priority,
1497  const MCSymbol *KeySym,
1500  // If the priority is the default, use .CRT$XCU, possibly associative.
1501  if (Priority == 65535)
1502  return Ctx.getAssociativeCOFFSection(Default, KeySym, 0);
1503 
1504  // Otherwise, we need to compute a new section name. Low priorities should
1505  // run earlier. The linker will sort sections ASCII-betically, and we need a
1506  // string that sorts between .CRT$XCA and .CRT$XCU. In the general case, we
1507  // make a name like ".CRT$XCT12345", since that runs before .CRT$XCU. Really
1508  // low priorities need to sort before 'L', since the CRT uses that
1509  // internally, so we use ".CRT$XCA00001" for them.
1511  raw_svector_ostream OS(Name);
1512  OS << ".CRT$XC" << (Priority < 200 ? 'A' : 'T') << format("%05u", Priority);
1513  MCSectionCOFF *Sec = Ctx.getCOFFSection(
1516  return Ctx.getAssociativeCOFFSection(Sec, KeySym, 0);
1517  }
1518 
1519  std::string Name = IsCtor ? ".ctors" : ".dtors";
1520  if (Priority != 65535)
1521  raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
1522 
1523  return Ctx.getAssociativeCOFFSection(
1528  KeySym, 0);
1529 }
1530 
1532  unsigned Priority, const MCSymbol *KeySym) const {
1534  Priority, KeySym,
1535  cast<MCSectionCOFF>(StaticCtorSection));
1536 }
1537 
1539  unsigned Priority, const MCSymbol *KeySym) const {
1541  Priority, KeySym,
1542  cast<MCSectionCOFF>(StaticDtorSection));
1543 }
1544 
1546  raw_ostream &OS, const GlobalValue *GV) const {
1548 }
1549 
1551  raw_ostream &OS, const GlobalValue *GV) const {
1553 }
1554 
1556  const GlobalValue *LHS, const GlobalValue *RHS,
1557  const TargetMachine &TM) const {
1558  const Triple &T = TM.getTargetTriple();
1559  if (!T.isKnownWindowsMSVCEnvironment() &&
1562  return nullptr;
1563 
1564  // Our symbols should exist in address space zero, cowardly no-op if
1565  // otherwise.
1566  if (LHS->getType()->getPointerAddressSpace() != 0 ||
1567  RHS->getType()->getPointerAddressSpace() != 0)
1568  return nullptr;
1569 
1570  // Both ptrtoint instructions must wrap global objects:
1571  // - Only global variables are eligible for image relative relocations.
1572  // - The subtrahend refers to the special symbol __ImageBase, a GlobalVariable.
1573  // We expect __ImageBase to be a global variable without a section, externally
1574  // defined.
1575  //
1576  // It should look something like this: @__ImageBase = external constant i8
1577  if (!isa<GlobalObject>(LHS) || !isa<GlobalVariable>(RHS) ||
1578  LHS->isThreadLocal() || RHS->isThreadLocal() ||
1579  RHS->getName() != "__ImageBase" || !RHS->hasExternalLinkage() ||
1580  cast<GlobalVariable>(RHS)->hasInitializer() || RHS->hasSection())
1581  return nullptr;
1582 
1583  return MCSymbolRefExpr::create(TM.getSymbol(LHS),
1585  getContext());
1586 }
1587 
1588 static std::string APIntToHexString(const APInt &AI) {
1589  unsigned Width = (AI.getBitWidth() / 8) * 2;
1590  std::string HexString = utohexstr(AI.getLimitedValue(), /*LowerCase=*/true);
1591  unsigned Size = HexString.size();
1592  assert(Width >= Size && "hex string is too large!");
1593  HexString.insert(HexString.begin(), Width - Size, '0');
1594 
1595  return HexString;
1596 }
1597 
1598 static std::string scalarConstantToHexString(const Constant *C) {
1599  Type *Ty = C->getType();
1600  if (isa<UndefValue>(C)) {
1602  } else if (const auto *CFP = dyn_cast<ConstantFP>(C)) {
1603  return APIntToHexString(CFP->getValueAPF().bitcastToAPInt());
1604  } else if (const auto *CI = dyn_cast<ConstantInt>(C)) {
1605  return APIntToHexString(CI->getValue());
1606  } else {
1607  unsigned NumElements;
1608  if (isa<VectorType>(Ty))
1609  NumElements = Ty->getVectorNumElements();
1610  else
1611  NumElements = Ty->getArrayNumElements();
1612  std::string HexString;
1613  for (int I = NumElements - 1, E = -1; I != E; --I)
1615  return HexString;
1616  }
1617 }
1618 
1620  const DataLayout &DL, SectionKind Kind, const Constant *C,
1621  unsigned &Align) const {
1622  if (Kind.isMergeableConst() && C &&
1624  // This creates comdat sections with the given symbol name, but unless
1625  // AsmPrinter::GetCPISymbol actually makes the symbol global, the symbol
1626  // will be created with a null storage class, which makes GNU binutils
1627  // error out.
1631  std::string COMDATSymName;
1632  if (Kind.isMergeableConst4()) {
1633  if (Align <= 4) {
1634  COMDATSymName = "__real@" + scalarConstantToHexString(C);
1635  Align = 4;
1636  }
1637  } else if (Kind.isMergeableConst8()) {
1638  if (Align <= 8) {
1639  COMDATSymName = "__real@" + scalarConstantToHexString(C);
1640  Align = 8;
1641  }
1642  } else if (Kind.isMergeableConst16()) {
1643  // FIXME: These may not be appropriate for non-x86 architectures.
1644  if (Align <= 16) {
1645  COMDATSymName = "__xmm@" + scalarConstantToHexString(C);
1646  Align = 16;
1647  }
1648  } else if (Kind.isMergeableConst32()) {
1649  if (Align <= 32) {
1650  COMDATSymName = "__ymm@" + scalarConstantToHexString(C);
1651  Align = 32;
1652  }
1653  }
1654 
1655  if (!COMDATSymName.empty())
1656  return getContext().getCOFFSection(".rdata", Characteristics, Kind,
1657  COMDATSymName,
1659  }
1660 
1661  return TargetLoweringObjectFile::getSectionForConstant(DL, Kind, C, Align);
1662 }
1663 
1664 
1665 //===----------------------------------------------------------------------===//
1666 // Wasm
1667 //===----------------------------------------------------------------------===//
1668 
1669 static const Comdat *getWasmComdat(const GlobalValue *GV) {
1670  const Comdat *C = GV->getComdat();
1671  if (!C)
1672  return nullptr;
1673 
1674  if (C->getSelectionKind() != Comdat::Any)
1675  report_fatal_error("WebAssembly COMDATs only support "
1676  "SelectionKind::Any, '" + C->getName() + "' cannot be "
1677  "lowered.");
1678 
1679  return C;
1680 }
1681 
1683  // If we're told we have function data, then use that.
1684  if (K.isText())
1685  return SectionKind::getText();
1686 
1687  // Otherwise, ignore whatever section type the generic impl detected and use
1688  // a plain data section.
1689  return SectionKind::getData();
1690 }
1691 
1693  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1694  // We don't support explict section names for functions in the wasm object
1695  // format. Each function has to be in its own unique section.
1696  if (isa<Function>(GO)) {
1697  return SelectSectionForGlobal(GO, Kind, TM);
1698  }
1699 
1700  StringRef Name = GO->getSection();
1701 
1702  Kind = getWasmKindForNamedSection(Name, Kind);
1703 
1704  StringRef Group = "";
1705  if (const Comdat *C = getWasmComdat(GO)) {
1706  Group = C->getName();
1707  }
1708 
1710  getContext().getWasmSection(Name, Kind, Group,
1712 
1713  return Section;
1714 }
1715 
1717  MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
1718  const TargetMachine &TM, bool EmitUniqueSection, unsigned *NextUniqueID) {
1719  StringRef Group = "";
1720  if (const Comdat *C = getWasmComdat(GO)) {
1721  Group = C->getName();
1722  }
1723 
1724  bool UniqueSectionNames = TM.getUniqueSectionNames();
1726 
1727  if (const auto *F = dyn_cast<Function>(GO)) {
1728  const auto &OptionalPrefix = F->getSectionPrefix();
1729  if (OptionalPrefix)
1730  Name += *OptionalPrefix;
1731  }
1732 
1733  if (EmitUniqueSection && UniqueSectionNames) {
1734  Name.push_back('.');
1735  TM.getNameWithPrefix(Name, GO, Mang, true);
1736  }
1737  unsigned UniqueID = MCContext::GenericSectionID;
1738  if (EmitUniqueSection && !UniqueSectionNames) {
1739  UniqueID = *NextUniqueID;
1740  (*NextUniqueID)++;
1741  }
1742 
1743  return Ctx.getWasmSection(Name, Kind, Group, UniqueID);
1744 }
1745 
1747  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1748 
1749  if (Kind.isCommon())
1750  report_fatal_error("mergable sections not supported yet on wasm");
1751 
1752  // If we have -ffunction-section or -fdata-section then we should emit the
1753  // global value to a uniqued section specifically for it.
1754  bool EmitUniqueSection = false;
1755  if (Kind.isText())
1756  EmitUniqueSection = TM.getFunctionSections();
1757  else
1758  EmitUniqueSection = TM.getDataSections();
1759  EmitUniqueSection |= GO->hasComdat();
1760 
1761  return selectWasmSectionForGlobal(getContext(), GO, Kind, getMangler(), TM,
1762  EmitUniqueSection, &NextUniqueID);
1763 }
1764 
1766  bool UsesLabelDifference, const Function &F) const {
1767  // We can always create relative relocations, so use another section
1768  // that can be marked non-executable.
1769  return false;
1770 }
1771 
1773  const GlobalValue *LHS, const GlobalValue *RHS,
1774  const TargetMachine &TM) const {
1775  // We may only use a PLT-relative relocation to refer to unnamed_addr
1776  // functions.
1777  if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
1778  return nullptr;
1779 
1780  // Basic sanity checks.
1781  if (LHS->getType()->getPointerAddressSpace() != 0 ||
1782  RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
1783  RHS->isThreadLocal())
1784  return nullptr;
1785 
1786  return MCBinaryExpr::createSub(
1788  getContext()),
1790 }
1791 
1794  getContext().getWasmSection(".init_array", SectionKind::getData());
1795 
1796  // We don't use PersonalityEncoding and LSDAEncoding because we don't emit
1797  // .cfi directives. We use TTypeEncoding to encode typeinfo global variables.
1799 }
1800 
1802  unsigned Priority, const MCSymbol *KeySym) const {
1803  return Priority == UINT16_MAX ?
1805  getContext().getWasmSection(".init_array." + utostr(Priority),
1807 }
1808 
1810  unsigned Priority, const MCSymbol *KeySym) const {
1811  llvm_unreachable("@llvm.global_dtors should have been lowered already");
1812  return nullptr;
1813 }
const MCExpr * lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS, const TargetMachine &TM) const override
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:292
AttributeSet getAttributes() const
Return the attribute set for this global.
uint64_t CallInst * C
void getNameWithPrefix(SmallVectorImpl< char > &OutName, const GlobalValue *GV, const TargetMachine &TM) const override
bool isBSSExtern() const
Definition: SectionKind.h:161
StringRef getSection() const
Get the custom section of this global if it has one.
Definition: GlobalObject.h:89
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:38
void emitModuleMetadata(MCStreamer &Streamer, Module &M) const override
Emit Obj-C garbage collection and linker options.
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:110
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
Tracking metadata reference owned by Metadata.
Definition: Metadata.h:710
static SectionKind getData()
Definition: SectionKind.h:201
static MCSectionCOFF * getCOFFStaticStructorSection(MCContext &Ctx, const Triple &T, bool IsCtor, unsigned Priority, const MCSymbol *KeySym, MCSectionCOFF *Default)
static MCSectionELF * selectELFSectionForGlobal(MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang, const TargetMachine &TM, bool EmitUniqueSection, unsigned Flags, unsigned *NextUniqueID, const MCSymbolELF *AssociatedSymbol)
bool isThreadData() const
Definition: SectionKind.h:153
bool hasLocalLinkage() const
Definition: GlobalValue.h:435
MCSection * getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
Targets should implement this method to assign a section to globals with an explicit section specfied...
bool hasAttribute(unsigned Value) const
This represents a section on a Mach-O system (used by Mac OS X).
MCSection * getSectionForJumpTable(const Function &F, const TargetMachine &TM) const override
MCSection * getStaticCtorSection(unsigned Priority, const MCSymbol *KeySym) const override
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:321
bool hasPrivateLinkage() const
Definition: GlobalValue.h:434
S_ATTR_NO_DEAD_STRIP - No dead stripping.
Definition: MachO.h:189
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:139
This class represents lattice values for constants.
Definition: AllocatorList.h:23
PointerTy getPointer() const
void EmitSymbolValue(const MCSymbol *Sym, unsigned Size, bool IsSectionRelative=false)
Special case of EmitValue that avoids the client having to pass in a MCExpr for MCSymbols.
Definition: MCStreamer.cpp:163
MCSection * SectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const
This method computes the appropriate section to emit the specified global variable or function defini...
.type _foo, STT_OBJECT # aka
Definition: MCDirectives.h:25
This represents an "assembler immediate".
Definition: MCValue.h:39
bool isWriteable() const
Definition: SectionKind.h:144
void emitPersonalityValue(MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym) const override
StringRef getPrivateGlobalPrefix() const
Definition: DataLayout.h:316
static std::string scalarConstantToHexString(const Constant *C)
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
void emitLinkerFlagsForGlobal(raw_ostream &OS, const GlobalValue *GV) const override
virtual void AddBlankLine()
AddBlankLine - Emit a blank line to a .s file to pretty it up.
Definition: MCStreamer.h:330
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
MCSymbol * getCFIPersonalitySymbol(const GlobalValue *GV, const TargetMachine &TM, MachineModuleInfo *MMI) const override
void Initialize(MCContext &Ctx, const TargetMachine &TM) override
This method must be called before any actual lowering is done.
MCSection * SixteenByteConstantSection
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:256
void push_back(const T &Elt)
Definition: SmallVector.h:211
MCSection * TextSection
Section directive for standard text.
void emitModuleMetadata(MCStreamer &Streamer, Module &M) const override
Emit Obj-C garbage collection and linker options.
MCSection * StaticCtorSection
This section contains the static constructor pointer list.
MCSection * ConstTextCoalSection
virtual void EmitBytes(StringRef Data)
Emit the bytes in Data into the output.
void emitModuleMetadata(MCStreamer &Streamer, Module &M) const override
Emit the module flags that specify the garbage collection information.
static void checkMachOComdat(const GlobalValue *GV)
This file contains the declarations for metadata subclasses.
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:123
MCSymbol * getCFIPersonalitySymbol(const GlobalValue *GV, const TargetMachine &TM, MachineModuleInfo *MMI) const override
MCSectionWasm * getWasmSection(const Twine &Section, SectionKind K)
Definition: MCContext.h:453
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM...
bool isMergeableConst8() const
Definition: SectionKind.h:140
PointerIntPair< MCSymbol *, 1, bool > StubValueTy
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:323
The data referenced by the COMDAT must be the same size.
Definition: Comdat.h:38
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:509
MCSection * getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
Targets should implement this method to assign a section to globals with an explicit section specfied...
bool isMergeableCString() const
Definition: SectionKind.h:127
const MCExpr * getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding, MCStreamer &Streamer) const
Metadata node.
Definition: Metadata.h:863
std::string getInstrProfSectionName(InstrProfSectKind IPSK, Triple::ObjectFormatType OF, bool AddSegmentInfo=true)
Return the name of the profile section corresponding to IPSK.
Definition: InstrProf.cpp:165
F(f)
MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, unsigned &Align) const override
Given a constant with the SectionKind, return a section that it should be placed in.
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1068
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:534
MCSection * getSectionForJumpTable(const Function &F, const TargetMachine &TM) const override
const MCExpr * getIndirectSymViaGOTPCRel(const MCSymbol *Sym, const MCValue &MV, int64_t Offset, MachineModuleInfo *MMI, MCStreamer &Streamer) const override
Get MachO PC relative GOT entry relocation.
unsigned getPointerABIAlignment(unsigned AS) const
Layout pointer alignment.
Definition: DataLayout.cpp:630
static bool isThumb(const MCSubtargetInfo &STI)
unsigned getTypeAndAttributes() const
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1508
MCSectionCOFF * getCOFFSection(StringRef Section, unsigned Characteristics, SectionKind Kind, StringRef COMDATSymName, int Selection, unsigned UniqueID=GenericSectionID, const char *BeginSymName=nullptr)
Definition: MCContext.cpp:425
bool isMergeable2ByteCString() const
Definition: SectionKind.h:132
MCSectionCOFF * getAssociativeCOFFSection(MCSectionCOFF *Sec, const MCSymbol *KeySym, unsigned UniqueID=GenericSectionID)
Gets or creates a section equivalent to Sec that is associated with the section containing KeySym...
Definition: MCContext.cpp:473
Adds a requirement that another module flag be present and have a specified value after linking is pe...
Definition: Module.h:129
unsigned PersonalityEncoding
PersonalityEncoding, LSDAEncoding, TTypeEncoding - Some encoding values for EH.
This represents a section on Windows.
Definition: MCSectionCOFF.h:26
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
static MCSectionWasm * selectWasmSectionForGlobal(MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang, const TargetMachine &TM, bool EmitUniqueSection, unsigned *NextUniqueID)
bool hasSection() const
Definition: GlobalValue.h:269
int64_t getConstant() const
Definition: MCValue.h:46
const MCSymbolRefExpr * getSymB() const
Definition: MCValue.h:48
A tuple of MDNodes.
Definition: Metadata.h:1325
static SectionKind getBSS()
Definition: SectionKind.h:197
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:369
uint64_t getArrayNumElements() const
Definition: DerivedTypes.h:419
virtual void Initialize(MCContext &ctx, const TargetMachine &TM)
This method must be called before any actual lowering is done.
bool isKnownWindowsMSVCEnvironment() const
Checks if the environment is MSVC.
Definition: Triple.h:535
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
Definition: Metadata.cpp:1440
The linker may choose any COMDAT.
Definition: Comdat.h:34
bool hasCOFFComdatConstants() const
Definition: MCAsmInfo.h:475
void getNameWithPrefix(SmallVectorImpl< char > &Name, const GlobalValue *GV, Mangler &Mang, bool MayAlwaysUsePrivate=false) const
const MCExpr * lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS, const TargetMachine &TM) const override
MCSection * EightByteConstantSection
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:126
S_MOD_TERM_FUNC_POINTERS - Section with only function pointers for termination.
Definition: MachO.h:142
MCSection * TLSDataSection
Section directive for Thread Local data. ELF, MachO, COFF, and Wasm.
static const GlobalValue * getComdatGVForCOFF(const GlobalValue *GV)
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
Context object for machine code objects.
Definition: MCContext.h:62
bool hasExternalLinkage() const
Definition: GlobalValue.h:421
Key
PAL metadata keys.
bool isText() const
Definition: SectionKind.h:118
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:244
MCSection * getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
Targets should implement this method to assign a section to globals with an explicit section specfied...
static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:544
MCSectionMachO * getMachOSection(StringRef Segment, StringRef Section, unsigned TypeAndAttributes, unsigned Reserved2, SectionKind K, const char *BeginSymName=nullptr)
Return the MCSection for the specified mach-o section.
Definition: MCContext.cpp:276
op_range operands() const
Definition: Metadata.h:1066
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:292
static std::string APIntToHexString(const APInt &AI)
MCSection * StaticDtorSection
This section contains the static destructor pointer list.
MCSection * getStaticDtorSection(unsigned Priority, const MCSymbol *KeySym) const override
static void GetObjCImageInfo(Module &M, unsigned &Version, unsigned &Flags, StringRef &Section)
NamedMDNode * getNamedMetadata(const Twine &Name) const
Return the first NamedMDNode in the module with the specified name.
Definition: Module.cpp:250
MCSection * ConstDataCoalSection
GlobalValue * getNamedValue(StringRef Name) const
Return the global value in the module with the specified name, of arbitrary type. ...
Definition: Module.cpp:113
void Initialize(MCContext &Ctx, const TargetMachine &TM) override
This method must be called before any actual lowering is done.
bool isBSSLocal() const
Definition: SectionKind.h:160
bool isMergeableConst32() const
Definition: SectionKind.h:142
bool hasImplicitSection() const
Check if section name is present.
Reloc::Model getRelocationModel() const
Returns the code generation relocation model.
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
Value wrapper in the Metadata hierarchy.
Definition: Metadata.h:338
static SectionKind getThreadData()
Definition: SectionKind.h:196
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:459
bool isWindowsItaniumEnvironment() const
Definition: Triple.h:549
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
virtual void EmitIntValue(uint64_t Value, unsigned Size)
Special case of EmitValue that avoids the client having to pass in a MCExpr for constant integers...
Definition: MCStreamer.cpp:128
bool isWindowsCoreCLREnvironment() const
Definition: Triple.h:545
static StringRef getCOFFSectionNameForUniqueGlobal(SectionKind Kind)
MCSection * DataSection
Section directive for standard data.
bool getDataSections() const
Return true if data objects should be emitted into their own section, corresponds to -fdata-sections...
SectionCharacteristics
Definition: COFF.h:283
bool isReadOnlyWithRel() const
Definition: SectionKind.h:167
void getNameWithPrefix(SmallVectorImpl< char > &OutName, const GlobalValue *GV, const TargetMachine &TM) const override
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:344
static bool isWeakForLinker(LinkageTypes Linkage)
Whether the definition of this global may be replaced at link time.
Definition: GlobalValue.h:369
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:55
bool getFunctionSections() const
Return true if functions should be emitted into their own section, corresponding to -ffunction-sectio...
.hidden (ELF)
Definition: MCDirectives.h:31
void getModuleFlagsMetadata(SmallVectorImpl< ModuleFlagEntry > &Flags) const
Returns the module flags in the provided vector.
Definition: Module.cpp:290
static const Comdat * getWasmComdat(const GlobalValue *GV)
No other Module may specify this COMDAT.
Definition: Comdat.h:37
Streaming machine code generation interface.
Definition: MCStreamer.h:188
StringRef getName() const
Definition: Comdat.cpp:26
static std::string ParseSectionSpecifier(StringRef Spec, StringRef &Segment, StringRef &Section, unsigned &TAA, bool &TAAParsed, unsigned &StubSize)
Parse the section specifier indicated by "Spec".
MCSection * getSectionForCommandLines() const override
If supported, return the section to use for the llvm.commandline metadata.
PointerIntPair - This class implements a pair of a pointer and small integer.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, unsigned &Align) const override
Given a mergeable constant with the specified size and relocation information, return a section that ...
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:41
unsigned getPointerSize(unsigned AS=0) const
Layout pointer size FIXME: The defaults need to be removed once all of the backends/clients are updat...
Definition: DataLayout.cpp:648
virtual void SwitchSection(MCSection *Section, const MCExpr *Subsection=nullptr)
Set the current section where code is being emitted to Section.
This represents a section on wasm.
Definition: MCSectionWasm.h:27
const MCExpr * getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM, MachineModuleInfo *MMI, MCStreamer &Streamer) const override
Return an MCExpr to use for a reference to the specified type info global variable from exception han...
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static SectionKind getELFKindForNamedSection(StringRef Name, SectionKind K)
virtual MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, unsigned &Align) const
Given a constant with the SectionKind, return a section that it should be placed in.
const MCAsmInfo * getMCAsmInfo() const
Return target specific asm information.
MCSymbol * getSymbol(const GlobalValue *GV) const
MCSection * getStaticDtorSection(unsigned Priority, const MCSymbol *KeySym) const override
virtual bool isSectionAtomizableBySymbols(const MCSection &Section) const
True if the section is atomized using the symbols in it.
Definition: MCAsmInfo.cpp:77
MCSymbol * getSymbolWithGlobalValueBase(const GlobalValue *GV, StringRef Suffix, const TargetMachine &TM) const
Return the MCSymbol for a private symbol with global value name as its base, with the specified suffi...
virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value=0, unsigned ValueSize=1, unsigned MaxBytesToEmit=0)
Emit some number of copies of Value until the byte alignment ByteAlignment is reached.
virtual bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute)=0
Add the given Attribute to Symbol.
void emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &TT, Mangler &Mangler)
Definition: Mangler.cpp:184
SectionKind - This is a simple POD value that classifies the properties of a section.
Definition: SectionKind.h:22
const Triple & getTargetTriple() const
void emitLinkerFlagsForUsed(raw_ostream &OS, const GlobalValue *GV) const override
virtual const MCExpr * getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM, MachineModuleInfo *MMI, MCStreamer &Streamer) const
Return an MCExpr to use for a reference to the specified global variable from exception handling info...
bool isMergeableConst16() const
Definition: SectionKind.h:141
MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, unsigned &Align) const override
Given a constant with the SectionKind, return a section that it should be placed in.
Ty & getObjFileInfo()
Keep track of various per-function pieces of information for backends that would like to do so...
The data referenced by the COMDAT must be the same.
Definition: Comdat.h:35
StubValueTy & getGVStubEntry(MCSymbol *Sym)
bool isExternal() const
Definition: MCSymbol.h:392
StubValueTy & getGVStubEntry(MCSymbol *Sym)
MCSection * getStaticDtorSection(unsigned Priority, const MCSymbol *KeySym) const override
bool isThreadBSS() const
Definition: SectionKind.h:152
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:43
MCSection * getDrectveSection() const
bool isBSS() const
Definition: SectionKind.h:159
const MCExpr * getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM, MachineModuleInfo *MMI, MCStreamer &Streamer) const override
The mach-o version of this method defaults to returning a stub reference.
bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const override
bool isMergeableConst4() const
Definition: SectionKind.h:139
static const MCSymbolELF * getAssociatedSymbol(const GlobalObject *GO, const TargetMachine &TM)
static SectionKind getThreadBSS()
Definition: SectionKind.h:195
BlockVerifier::State From
static bool canUsePrivateLabel(const MCAsmInfo &AsmInfo, const MCSection &Section)
const MCSymbol & getSymbol() const
Definition: MCExpr.h:334
bool isMergeable4ByteCString() const
Definition: SectionKind.h:133
bool isCommon() const
Definition: SectionKind.h:163
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:841
Module.h This file contains the declarations for the Module class.
static SectionKind getMetadata()
Definition: SectionKind.h:178
bool isMetadata() const
Definition: SectionKind.h:116
const Triple & getTargetTriple() const
static const Comdat * getELFComdat(const GlobalValue *GV)
The linker will choose the largest COMDAT.
Definition: Comdat.h:36
bool hasGlobalUnnamedAddr() const
Definition: GlobalValue.h:199
std::string utostr(uint64_t X, bool isNeg=false)
Definition: StringExtras.h:223
bool isOSFreeBSD() const
Definition: Triple.h:493
unsigned getVectorNumElements() const
Definition: DerivedTypes.h:493
unsigned getPreferredAlignment(const GlobalVariable *GV) const
Returns the preferred alignment of the specified global.
Definition: DataLayout.cpp:837
This file contains constants used for implementing Dwarf debug support.
bool isDefined() const
isDefined - Check if this symbol is defined (i.e., it has an address).
Definition: MCSymbol.h:247
const Comdat * getComdat() const
Definition: Globals.cpp:170
Class for arbitrary precision integers.
Definition: APInt.h:69
CodeModel::Model getCodeModel() const
Returns the code model.
static SectionKind getWasmKindForNamedSection(StringRef Name, SectionKind K)
amdgpu AMDGPU DAG DAG Pattern Instruction Selection
static StringRef getSectionPrefixForGlobal(SectionKind Kind)
Return the section prefix name used by options FunctionsSections and DataSections.
MCSection * FourByteConstantSection
bool hasComdat() const
Definition: GlobalObject.h:99
bool isReadOnly() const
Definition: SectionKind.h:122
MachineModuleInfoELF - This is a MachineModuleInfoImpl implementation for ELF targets.
const Comdat * getComdat() const
Definition: GlobalObject.h:100
bool isMergeableConst() const
Definition: SectionKind.h:135
const MCExpr * lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS, const TargetMachine &TM) const override
bool isFunctionTy() const
True if this is an instance of FunctionType.
Definition: Type.h:214
MCSection * getStaticCtorSection(unsigned Priority, const MCSymbol *KeySym) const override
virtual void EmitLinkerOptions(ArrayRef< std::string > Kind)
Emit the given list Options of strings as linker options into the output.
Definition: MCStreamer.h:446
bool getUniqueSectionNames() const
StringRef getValueAsString() const
Return the attribute&#39;s value as a string.
Definition: Attributes.cpp:194
MCSection * getStaticCtorSection(unsigned Priority, const MCSymbol *KeySym) const override
uint64_t getLimitedValue(uint64_t Limit=UINT64_MAX) const
If this value is smaller than the specified limit, return it, otherwise return the limit value...
Definition: APInt.h:481
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:214
static int getSelectionForCOFF(const GlobalValue *GV)
#define I(x, y, z)
Definition: MD5.cpp:58
COFFYAML::WeakExternalCharacteristics Characteristics
Definition: COFFYAML.cpp:325
virtual void emitELFSize(MCSymbol *Symbol, const MCExpr *Value)
Emit an ELF .size directive.
static unsigned getCOFFSectionFlags(SectionKind K, const TargetMachine &TM)
This represents a section on linux, lots of unix variants and some bare metal systems.
Definition: MCSectionELF.h:27
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:332
Type * getValueType() const
Definition: GlobalValue.h:275
uint32_t Size
Definition: Profile.cpp:46
void emitLinkerFlagsForUsedCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &T, Mangler &M)
Definition: Mangler.cpp:215
Pass this value as the UniqueID during section creation to get the generic section with the given nam...
Definition: MCContext.h:371
const Module * getModule() const
MachineModuleInfoMachO - This is a MachineModuleInfoImpl implementation for MachO targets...
const GlobalObject * getBaseObject() const
Definition: Globals.cpp:260
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:202
static unsigned getEntrySizeForKind(SectionKind Kind)
MCSection * TLSBSSSection
Section directive for Thread Local uninitialized data.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:482
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:388
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:114
static MCSectionELF * getStaticStructorSection(MCContext &Ctx, bool UseInitArray, bool IsCtor, unsigned Priority, const MCSymbol *KeySym)
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:565
bool isData() const
Definition: SectionKind.h:165
bool isThreadLocal() const
Definition: SectionKind.h:148
bool isMergeable1ByteCString() const
Definition: SectionKind.h:131
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:250
MCSection * getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
Targets should implement this method to assign a section to globals with an explicit section specfied...
virtual void EmitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc())
Emit a label for Symbol into the current section.
Definition: MCStreamer.cpp:351
ExceptionHandling getExceptionHandlingType() const
Definition: MCAsmInfo.h:569
Attribute getFnAttribute(Attribute::AttrKind Kind) const
Return the attribute for the given attribute kind.
Definition: Function.h:333
Metadata * get() const
Definition: Metadata.h:721
bool isExecuteOnly() const
Definition: SectionKind.h:120
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
virtual void emitCGProfileEntry(const MCSymbolRefExpr *From, const MCSymbolRefExpr *To, uint64_t Count)
Definition: MCStreamer.cpp:713
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:65
void getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV, bool CannotUsePrivateLabel) const
Print the appropriate prefix and the specified global variable&#39;s name.
Definition: Mangler.cpp:111
MCSection * BSSSection
Section that is default initialized to zero.
bool isThreadLocal() const
If the value is "Thread Local", its value isn&#39;t shared by the threads.
Definition: GlobalValue.h:246
const MCSymbol * getAssociatedSymbol() const
Definition: MCSectionELF.h:87
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
MCSection * ReadOnlySection
Section that is readonly and can contain arbitrary initialized data.
static unsigned getELFSectionFlags(SectionKind K)
static SectionKind getKindForGlobal(const GlobalObject *GO, const TargetMachine &TM)
Classify the specified global variable into a set of target independent categories embodied in Sectio...
static APInt getNullValue(unsigned numBits)
Get the &#39;0&#39; value.
Definition: APInt.h:568
S_MOD_INIT_FUNC_POINTERS - Section with only function pointers for initialization.
Definition: MachO.h:139
void Initialize(MCContext &Ctx, const TargetMachine &TM) override
This method must be called before any actual lowering is done.
static SectionKind getReadOnly()
Definition: SectionKind.h:181
const uint64_t Version
Definition: InstrProf.h:984
static unsigned getELFSectionType(StringRef Name, SectionKind K)
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx)
Definition: MCExpr.cpp:163
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:273
This class contains meta information specific to a module.
std::string utohexstr(uint64_t X, bool LowerCase=false)
Definition: StringExtras.h:124
SelectionKind getSelectionKind() const
Definition: Comdat.h:44
static SectionKind getText()
Definition: SectionKind.h:179
bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const override