LLVM  10.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  CallSiteEncoding = dwarf::DW_EH_PE_udata4;
222  break;
223  case Triple::riscv32:
224  case Triple::riscv64:
226  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
230  CallSiteEncoding = dwarf::DW_EH_PE_udata4;
231  break;
232  case Triple::sparcv9:
234  if (isPositionIndependent()) {
235  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
239  } else {
240  PersonalityEncoding = dwarf::DW_EH_PE_absptr;
241  TTypeEncoding = dwarf::DW_EH_PE_absptr;
242  }
243  break;
244  case Triple::systemz:
245  // All currently-defined code models guarantee that 4-byte PC-relative
246  // values will be in range.
247  if (isPositionIndependent()) {
248  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
253  } else {
254  PersonalityEncoding = dwarf::DW_EH_PE_absptr;
255  LSDAEncoding = dwarf::DW_EH_PE_absptr;
256  TTypeEncoding = dwarf::DW_EH_PE_absptr;
257  }
258  break;
259  default:
260  break;
261  }
262 }
263 
265  Module &M) const {
266  auto &C = getContext();
267 
268  if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
269  auto *S = C.getELFSection(".linker-options", ELF::SHT_LLVM_LINKER_OPTIONS,
271 
272  Streamer.SwitchSection(S);
273 
274  for (const auto &Operand : LinkerOptions->operands()) {
275  if (cast<MDNode>(Operand)->getNumOperands() != 2)
276  report_fatal_error("invalid llvm.linker.options");
277  for (const auto &Option : cast<MDNode>(Operand)->operands()) {
278  Streamer.EmitBytes(cast<MDString>(Option)->getString());
279  Streamer.EmitIntValue(0, 1);
280  }
281  }
282  }
283 
284  if (NamedMDNode *DependentLibraries = M.getNamedMetadata("llvm.dependent-libraries")) {
285  auto *S = C.getELFSection(".deplibs", ELF::SHT_LLVM_DEPENDENT_LIBRARIES,
287 
288  Streamer.SwitchSection(S);
289 
290  for (const auto &Operand : DependentLibraries->operands()) {
291  Streamer.EmitBytes(
292  cast<MDString>(cast<MDNode>(Operand)->getOperand(0))->getString());
293  Streamer.EmitIntValue(0, 1);
294  }
295  }
296 
297  unsigned Version = 0;
298  unsigned Flags = 0;
300 
301  GetObjCImageInfo(M, Version, Flags, Section);
302  if (!Section.empty()) {
303  auto *S = C.getELFSection(Section, ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
304  Streamer.SwitchSection(S);
305  Streamer.EmitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
306  Streamer.EmitIntValue(Version, 4);
307  Streamer.EmitIntValue(Flags, 4);
308  Streamer.AddBlankLine();
309  }
310 
312  M.getModuleFlagsMetadata(ModuleFlags);
313 
314  MDNode *CFGProfile = nullptr;
315 
316  for (const auto &MFE : ModuleFlags) {
317  StringRef Key = MFE.Key->getString();
318  if (Key == "CG Profile") {
319  CFGProfile = cast<MDNode>(MFE.Val);
320  break;
321  }
322  }
323 
324  if (!CFGProfile)
325  return;
326 
327  auto GetSym = [this](const MDOperand &MDO) -> MCSymbol * {
328  if (!MDO)
329  return nullptr;
330  auto V = cast<ValueAsMetadata>(MDO);
331  const Function *F = cast<Function>(V->getValue());
332  return TM->getSymbol(F);
333  };
334 
335  for (const auto &Edge : CFGProfile->operands()) {
336  MDNode *E = cast<MDNode>(Edge);
337  const MCSymbol *From = GetSym(E->getOperand(0));
338  const MCSymbol *To = GetSym(E->getOperand(1));
339  // Skip null functions. This can happen if functions are dead stripped after
340  // the CGProfile pass has been run.
341  if (!From || !To)
342  continue;
343  uint64_t Count = cast<ConstantAsMetadata>(E->getOperand(2))
344  ->getValue()
345  ->getUniqueInteger()
346  .getZExtValue();
347  Streamer.emitCGProfileEntry(
350  }
351 }
352 
354  const GlobalValue *GV, const TargetMachine &TM,
355  MachineModuleInfo *MMI) const {
356  unsigned Encoding = getPersonalityEncoding();
357  if ((Encoding & 0x80) == DW_EH_PE_indirect)
358  return getContext().getOrCreateSymbol(StringRef("DW.ref.") +
359  TM.getSymbol(GV)->getName());
360  if ((Encoding & 0x70) == DW_EH_PE_absptr)
361  return TM.getSymbol(GV);
362  report_fatal_error("We do not support this DWARF encoding yet!");
363 }
364 
366  MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym) const {
367  SmallString<64> NameData("DW.ref.");
368  NameData += Sym->getName();
369  MCSymbolELF *Label =
370  cast<MCSymbolELF>(getContext().getOrCreateSymbol(NameData));
371  Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
372  Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
373  unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
374  MCSection *Sec = getContext().getELFNamedSection(".data", Label->getName(),
375  ELF::SHT_PROGBITS, Flags, 0);
376  unsigned Size = DL.getPointerSize();
377  Streamer.SwitchSection(Sec);
379  Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
380  const MCExpr *E = MCConstantExpr::create(Size, getContext());
381  Streamer.emitELFSize(Label, E);
382  Streamer.EmitLabel(Label);
383 
384  Streamer.EmitSymbolValue(Sym, Size);
385 }
386 
388  const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
389  MachineModuleInfo *MMI, MCStreamer &Streamer) const {
390  if (Encoding & DW_EH_PE_indirect) {
392 
393  MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", TM);
394 
395  // Add information about the stub reference to ELFMMI so that the stub
396  // gets emitted by the asmprinter.
397  MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
398  if (!StubSym.getPointer()) {
399  MCSymbol *Sym = TM.getSymbol(GV);
401  }
402 
404  getTTypeReference(MCSymbolRefExpr::create(SSym, getContext()),
405  Encoding & ~DW_EH_PE_indirect, Streamer);
406  }
407 
409  MMI, Streamer);
410 }
411 
413  // N.B.: The defaults used in here are not the same ones used in MC.
414  // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
415  // both gas and MC will produce a section with no flags. Given
416  // section(".eh_frame") gcc will produce:
417  //
418  // .section .eh_frame,"a",@progbits
419 
420  if (Name == getInstrProfSectionName(IPSK_covmap, Triple::ELF,
421  /*AddSegmentInfo=*/false))
422  return SectionKind::getMetadata();
423 
424  if (Name.empty() || Name[0] != '.') return K;
425 
426  // Default implementation based on some magic section names.
427  if (Name == ".bss" ||
428  Name.startswith(".bss.") ||
429  Name.startswith(".gnu.linkonce.b.") ||
430  Name.startswith(".llvm.linkonce.b.") ||
431  Name == ".sbss" ||
432  Name.startswith(".sbss.") ||
433  Name.startswith(".gnu.linkonce.sb.") ||
434  Name.startswith(".llvm.linkonce.sb."))
435  return SectionKind::getBSS();
436 
437  if (Name == ".tdata" ||
438  Name.startswith(".tdata.") ||
439  Name.startswith(".gnu.linkonce.td.") ||
440  Name.startswith(".llvm.linkonce.td."))
442 
443  if (Name == ".tbss" ||
444  Name.startswith(".tbss.") ||
445  Name.startswith(".gnu.linkonce.tb.") ||
446  Name.startswith(".llvm.linkonce.tb."))
447  return SectionKind::getThreadBSS();
448 
449  return K;
450 }
451 
453  // Use SHT_NOTE for section whose name starts with ".note" to allow
454  // emitting ELF notes from C variable declaration.
455  // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77609
456  if (Name.startswith(".note"))
457  return ELF::SHT_NOTE;
458 
459  if (Name == ".init_array")
460  return ELF::SHT_INIT_ARRAY;
461 
462  if (Name == ".fini_array")
463  return ELF::SHT_FINI_ARRAY;
464 
465  if (Name == ".preinit_array")
466  return ELF::SHT_PREINIT_ARRAY;
467 
468  if (K.isBSS() || K.isThreadBSS())
469  return ELF::SHT_NOBITS;
470 
471  return ELF::SHT_PROGBITS;
472 }
473 
474 static unsigned getELFSectionFlags(SectionKind K) {
475  unsigned Flags = 0;
476 
477  if (!K.isMetadata())
478  Flags |= ELF::SHF_ALLOC;
479 
480  if (K.isText())
481  Flags |= ELF::SHF_EXECINSTR;
482 
483  if (K.isExecuteOnly())
484  Flags |= ELF::SHF_ARM_PURECODE;
485 
486  if (K.isWriteable())
487  Flags |= ELF::SHF_WRITE;
488 
489  if (K.isThreadLocal())
490  Flags |= ELF::SHF_TLS;
491 
492  if (K.isMergeableCString() || K.isMergeableConst())
493  Flags |= ELF::SHF_MERGE;
494 
495  if (K.isMergeableCString())
496  Flags |= ELF::SHF_STRINGS;
497 
498  return Flags;
499 }
500 
501 static const Comdat *getELFComdat(const GlobalValue *GV) {
502  const Comdat *C = GV->getComdat();
503  if (!C)
504  return nullptr;
505 
506  if (C->getSelectionKind() != Comdat::Any)
507  report_fatal_error("ELF COMDATs only support SelectionKind::Any, '" +
508  C->getName() + "' cannot be lowered.");
509 
510  return C;
511 }
512 
514  const TargetMachine &TM) {
516  if (!MD)
517  return nullptr;
518 
519  const MDOperand &Op = MD->getOperand(0);
520  if (!Op.get())
521  return nullptr;
522 
523  auto *VM = dyn_cast<ValueAsMetadata>(Op);
524  if (!VM)
525  report_fatal_error("MD_associated operand is not ValueAsMetadata");
526 
527  auto *OtherGV = dyn_cast<GlobalValue>(VM->getValue());
528  return OtherGV ? dyn_cast<MCSymbolELF>(TM.getSymbol(OtherGV)) : nullptr;
529 }
530 
532  if (Kind.isMergeable1ByteCString())
533  return 1;
534  else if (Kind.isMergeable2ByteCString())
535  return 2;
536  else if (Kind.isMergeable4ByteCString())
537  return 4;
538  else if (Kind.isMergeableConst4())
539  return 4;
540  else if (Kind.isMergeableConst8())
541  return 8;
542  else if (Kind.isMergeableConst16())
543  return 16;
544  else if (Kind.isMergeableConst32())
545  return 32;
546  else {
547  // We shouldn't have mergeable C strings or mergeable constants that we
548  // didn't handle above.
549  assert(!Kind.isMergeableCString() && "unknown string width");
550  assert(!Kind.isMergeableConst() && "unknown data width");
551  return 0;
552  }
553 }
554 
556  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
558 
559  // Check if '#pragma clang section' name is applicable.
560  // Note that pragma directive overrides -ffunction-section, -fdata-section
561  // and so section name is exactly as user specified and not uniqued.
562  const GlobalVariable *GV = dyn_cast<GlobalVariable>(GO);
563  if (GV && GV->hasImplicitSection()) {
564  auto Attrs = GV->getAttributes();
565  if (Attrs.hasAttribute("bss-section") && Kind.isBSS()) {
566  SectionName = Attrs.getAttribute("bss-section").getValueAsString();
567  } else if (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly()) {
568  SectionName = Attrs.getAttribute("rodata-section").getValueAsString();
569  } else if (Attrs.hasAttribute("data-section") && Kind.isData()) {
570  SectionName = Attrs.getAttribute("data-section").getValueAsString();
571  }
572  }
573  const Function *F = dyn_cast<Function>(GO);
574  if (F && F->hasFnAttribute("implicit-section-name")) {
575  SectionName = F->getFnAttribute("implicit-section-name").getValueAsString();
576  }
577 
578  // Infer section flags from the section name if we can.
579  Kind = getELFKindForNamedSection(SectionName, Kind);
580 
581  StringRef Group = "";
582  unsigned Flags = getELFSectionFlags(Kind);
583  if (const Comdat *C = getELFComdat(GO)) {
584  Group = C->getName();
585  Flags |= ELF::SHF_GROUP;
586  }
587 
588  // A section can have at most one associated section. Put each global with
589  // MD_associated in a unique section.
590  unsigned UniqueID = MCContext::GenericSectionID;
591  const MCSymbolELF *AssociatedSymbol = getAssociatedSymbol(GO, TM);
592  if (AssociatedSymbol) {
593  UniqueID = NextUniqueID++;
594  Flags |= ELF::SHF_LINK_ORDER;
595  }
596 
597  MCSectionELF *Section = getContext().getELFSection(
598  SectionName, getELFSectionType(SectionName, Kind), Flags,
599  getEntrySizeForKind(Kind), Group, UniqueID, AssociatedSymbol);
600  // Make sure that we did not get some other section with incompatible sh_link.
601  // This should not be possible due to UniqueID code above.
602  assert(Section->getAssociatedSymbol() == AssociatedSymbol &&
603  "Associated symbol mismatch between sections");
604  return Section;
605 }
606 
607 /// Return the section prefix name used by options FunctionsSections and
608 /// DataSections.
610  if (Kind.isText())
611  return ".text";
612  if (Kind.isReadOnly())
613  return ".rodata";
614  if (Kind.isBSS())
615  return ".bss";
616  if (Kind.isThreadData())
617  return ".tdata";
618  if (Kind.isThreadBSS())
619  return ".tbss";
620  if (Kind.isData())
621  return ".data";
622  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
623  return ".data.rel.ro";
624 }
625 
627  MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
628  const TargetMachine &TM, bool EmitUniqueSection, unsigned Flags,
629  unsigned *NextUniqueID, const MCSymbolELF *AssociatedSymbol) {
630 
631  StringRef Group = "";
632  if (const Comdat *C = getELFComdat(GO)) {
633  Flags |= ELF::SHF_GROUP;
634  Group = C->getName();
635  }
636 
637  // Get the section entry size based on the kind.
638  unsigned EntrySize = getEntrySizeForKind(Kind);
639 
641  if (Kind.isMergeableCString()) {
642  // We also need alignment here.
643  // FIXME: this is getting the alignment of the character, not the
644  // alignment of the global!
646  cast<GlobalVariable>(GO));
647 
648  std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
649  Name = SizeSpec + utostr(Align);
650  } else if (Kind.isMergeableConst()) {
651  Name = ".rodata.cst";
652  Name += utostr(EntrySize);
653  } else {
654  Name = getSectionPrefixForGlobal(Kind);
655  }
656 
657  if (const auto *F = dyn_cast<Function>(GO)) {
658  const auto &OptionalPrefix = F->getSectionPrefix();
659  if (OptionalPrefix)
660  Name += *OptionalPrefix;
661  }
662 
663  unsigned UniqueID = MCContext::GenericSectionID;
664  if (EmitUniqueSection) {
665  if (TM.getUniqueSectionNames()) {
666  Name.push_back('.');
667  TM.getNameWithPrefix(Name, GO, Mang, true /*MayAlwaysUsePrivate*/);
668  } else {
669  UniqueID = *NextUniqueID;
670  (*NextUniqueID)++;
671  }
672  }
673  // Use 0 as the unique ID for execute-only text.
674  if (Kind.isExecuteOnly())
675  UniqueID = 0;
676  return Ctx.getELFSection(Name, getELFSectionType(Name, Kind), Flags,
677  EntrySize, Group, UniqueID, AssociatedSymbol);
678 }
679 
681  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
682  unsigned Flags = getELFSectionFlags(Kind);
683 
684  // If we have -ffunction-section or -fdata-section then we should emit the
685  // global value to a uniqued section specifically for it.
686  bool EmitUniqueSection = false;
687  if (!(Flags & ELF::SHF_MERGE) && !Kind.isCommon()) {
688  if (Kind.isText())
689  EmitUniqueSection = TM.getFunctionSections();
690  else
691  EmitUniqueSection = TM.getDataSections();
692  }
693  EmitUniqueSection |= GO->hasComdat();
694 
695  const MCSymbolELF *AssociatedSymbol = getAssociatedSymbol(GO, TM);
696  if (AssociatedSymbol) {
697  EmitUniqueSection = true;
698  Flags |= ELF::SHF_LINK_ORDER;
699  }
700 
702  getContext(), GO, Kind, getMangler(), TM, EmitUniqueSection, Flags,
703  &NextUniqueID, AssociatedSymbol);
704  assert(Section->getAssociatedSymbol() == AssociatedSymbol);
705  return Section;
706 }
707 
709  const Function &F, const TargetMachine &TM) const {
710  // If the function can be removed, produce a unique section so that
711  // the table doesn't prevent the removal.
712  const Comdat *C = F.getComdat();
713  bool EmitUniqueSection = TM.getFunctionSections() || C;
714  if (!EmitUniqueSection)
715  return ReadOnlySection;
716 
717  return selectELFSectionForGlobal(getContext(), &F, SectionKind::getReadOnly(),
718  getMangler(), TM, EmitUniqueSection,
719  ELF::SHF_ALLOC, &NextUniqueID,
720  /* AssociatedSymbol */ nullptr);
721 }
722 
724  bool UsesLabelDifference, const Function &F) const {
725  // We can always create relative relocations, so use another section
726  // that can be marked non-executable.
727  return false;
728 }
729 
730 /// Given a mergeable constant with the specified size and relocation
731 /// information, return a section that it should be placed in.
733  const DataLayout &DL, SectionKind Kind, const Constant *C,
734  unsigned &Align) const {
735  if (Kind.isMergeableConst4() && MergeableConst4Section)
736  return MergeableConst4Section;
737  if (Kind.isMergeableConst8() && MergeableConst8Section)
738  return MergeableConst8Section;
739  if (Kind.isMergeableConst16() && MergeableConst16Section)
740  return MergeableConst16Section;
741  if (Kind.isMergeableConst32() && MergeableConst32Section)
742  return MergeableConst32Section;
743  if (Kind.isReadOnly())
744  return ReadOnlySection;
745 
746  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
747  return DataRelROSection;
748 }
749 
750 static MCSectionELF *getStaticStructorSection(MCContext &Ctx, bool UseInitArray,
751  bool IsCtor, unsigned Priority,
752  const MCSymbol *KeySym) {
753  std::string Name;
754  unsigned Type;
755  unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE;
756  StringRef COMDAT = KeySym ? KeySym->getName() : "";
757 
758  if (KeySym)
759  Flags |= ELF::SHF_GROUP;
760 
761  if (UseInitArray) {
762  if (IsCtor) {
763  Type = ELF::SHT_INIT_ARRAY;
764  Name = ".init_array";
765  } else {
766  Type = ELF::SHT_FINI_ARRAY;
767  Name = ".fini_array";
768  }
769  if (Priority != 65535) {
770  Name += '.';
771  Name += utostr(Priority);
772  }
773  } else {
774  // The default scheme is .ctor / .dtor, so we have to invert the priority
775  // numbering.
776  if (IsCtor)
777  Name = ".ctors";
778  else
779  Name = ".dtors";
780  if (Priority != 65535)
781  raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
782  Type = ELF::SHT_PROGBITS;
783  }
784 
785  return Ctx.getELFSection(Name, Type, Flags, 0, COMDAT);
786 }
787 
789  unsigned Priority, const MCSymbol *KeySym) const {
790  return getStaticStructorSection(getContext(), UseInitArray, true, Priority,
791  KeySym);
792 }
793 
795  unsigned Priority, const MCSymbol *KeySym) const {
796  return getStaticStructorSection(getContext(), UseInitArray, false, Priority,
797  KeySym);
798 }
799 
801  const GlobalValue *LHS, const GlobalValue *RHS,
802  const TargetMachine &TM) const {
803  // We may only use a PLT-relative relocation to refer to unnamed_addr
804  // functions.
805  if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
806  return nullptr;
807 
808  // Basic sanity checks.
809  if (LHS->getType()->getPointerAddressSpace() != 0 ||
810  RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
811  RHS->isThreadLocal())
812  return nullptr;
813 
815  MCSymbolRefExpr::create(TM.getSymbol(LHS), PLTRelativeVariantKind,
816  getContext()),
817  MCSymbolRefExpr::create(TM.getSymbol(RHS), getContext()), getContext());
818 }
819 
821  // Use ".GCC.command.line" since this feature is to support clang's
822  // -frecord-gcc-switches which in turn attempts to mimic GCC's switch of the
823  // same name.
824  return getContext().getELFSection(".GCC.command.line", ELF::SHT_PROGBITS,
826 }
827 
828 void
830  UseInitArray = UseInitArray_;
831  MCContext &Ctx = getContext();
832  if (!UseInitArray) {
833  StaticCtorSection = Ctx.getELFSection(".ctors", ELF::SHT_PROGBITS,
835 
836  StaticDtorSection = Ctx.getELFSection(".dtors", ELF::SHT_PROGBITS,
838  return;
839  }
840 
841  StaticCtorSection = Ctx.getELFSection(".init_array", ELF::SHT_INIT_ARRAY,
843  StaticDtorSection = Ctx.getELFSection(".fini_array", ELF::SHT_FINI_ARRAY,
845 }
846 
847 //===----------------------------------------------------------------------===//
848 // MachO
849 //===----------------------------------------------------------------------===//
850 
854 }
855 
857  const TargetMachine &TM) {
859  if (TM.getRelocationModel() == Reloc::Static) {
860  StaticCtorSection = Ctx.getMachOSection("__TEXT", "__constructor", 0,
862  StaticDtorSection = Ctx.getMachOSection("__TEXT", "__destructor", 0,
864  } else {
865  StaticCtorSection = Ctx.getMachOSection("__DATA", "__mod_init_func",
868  StaticDtorSection = Ctx.getMachOSection("__DATA", "__mod_term_func",
871  }
872 
876  TTypeEncoding =
878 }
879 
881  Module &M) const {
882  // Emit the linker options if present.
883  if (auto *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
884  for (const auto &Option : LinkerOptions->operands()) {
885  SmallVector<std::string, 4> StrOptions;
886  for (const auto &Piece : cast<MDNode>(Option)->operands())
887  StrOptions.push_back(cast<MDString>(Piece)->getString());
888  Streamer.EmitLinkerOptions(StrOptions);
889  }
890  }
891 
892  unsigned VersionVal = 0;
893  unsigned ImageInfoFlags = 0;
894  StringRef SectionVal;
895 
896  GetObjCImageInfo(M, VersionVal, ImageInfoFlags, SectionVal);
897 
898  // The section is mandatory. If we don't have it, then we don't have GC info.
899  if (SectionVal.empty())
900  return;
901 
902  StringRef Segment, Section;
903  unsigned TAA = 0, StubSize = 0;
904  bool TAAParsed;
905  std::string ErrorCode =
906  MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section,
907  TAA, TAAParsed, StubSize);
908  if (!ErrorCode.empty())
909  // If invalid, report the error with report_fatal_error.
910  report_fatal_error("Invalid section specifier '" + Section + "': " +
911  ErrorCode + ".");
912 
913  // Get the section.
915  Segment, Section, TAA, StubSize, SectionKind::getData());
916  Streamer.SwitchSection(S);
917  Streamer.EmitLabel(getContext().
918  getOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
919  Streamer.EmitIntValue(VersionVal, 4);
920  Streamer.EmitIntValue(ImageInfoFlags, 4);
921  Streamer.AddBlankLine();
922 }
923 
924 static void checkMachOComdat(const GlobalValue *GV) {
925  const Comdat *C = GV->getComdat();
926  if (!C)
927  return;
928 
929  report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() +
930  "' cannot be lowered.");
931 }
932 
934  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
935  // Parse the section specifier and create it if valid.
936  StringRef Segment, Section;
937  unsigned TAA = 0, StubSize = 0;
938  bool TAAParsed;
939 
940  checkMachOComdat(GO);
941 
942  std::string ErrorCode =
944  TAA, TAAParsed, StubSize);
945  if (!ErrorCode.empty()) {
946  // If invalid, report the error with report_fatal_error.
947  report_fatal_error("Global variable '" + GO->getName() +
948  "' has an invalid section specifier '" +
949  GO->getSection() + "': " + ErrorCode + ".");
950  }
951 
952  // Get the section.
953  MCSectionMachO *S =
954  getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
955 
956  // If TAA wasn't set by ParseSectionSpecifier() above,
957  // use the value returned by getMachOSection() as a default.
958  if (!TAAParsed)
959  TAA = S->getTypeAndAttributes();
960 
961  // Okay, now that we got the section, verify that the TAA & StubSize agree.
962  // If the user declared multiple globals with different section flags, we need
963  // to reject it here.
964  if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
965  // If invalid, report the error with report_fatal_error.
966  report_fatal_error("Global variable '" + GO->getName() +
967  "' section type or attributes does not match previous"
968  " section specifier");
969  }
970 
971  return S;
972 }
973 
975  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
976  checkMachOComdat(GO);
977 
978  // Handle thread local data.
979  if (Kind.isThreadBSS()) return TLSBSSSection;
980  if (Kind.isThreadData()) return TLSDataSection;
981 
982  if (Kind.isText())
984 
985  // If this is weak/linkonce, put this in a coalescable section, either in text
986  // or data depending on if it is writable.
987  if (GO->isWeakForLinker()) {
988  if (Kind.isReadOnly())
989  return ConstTextCoalSection;
990  if (Kind.isReadOnlyWithRel())
991  return ConstDataCoalSection;
992  return DataCoalSection;
993  }
994 
995  // FIXME: Alignment check should be handled by section classifier.
996  if (Kind.isMergeable1ByteCString() &&
998  cast<GlobalVariable>(GO)) < 32)
999  return CStringSection;
1000 
1001  // Do not put 16-bit arrays in the UString section if they have an
1002  // externally visible label, this runs into issues with certain linker
1003  // versions.
1004  if (Kind.isMergeable2ByteCString() && !GO->hasExternalLinkage() &&
1006  cast<GlobalVariable>(GO)) < 32)
1007  return UStringSection;
1008 
1009  // With MachO only variables whose corresponding symbol starts with 'l' or
1010  // 'L' can be merged, so we only try merging GVs with private linkage.
1011  if (GO->hasPrivateLinkage() && Kind.isMergeableConst()) {
1012  if (Kind.isMergeableConst4())
1013  return FourByteConstantSection;
1014  if (Kind.isMergeableConst8())
1015  return EightByteConstantSection;
1016  if (Kind.isMergeableConst16())
1018  }
1019 
1020  // Otherwise, if it is readonly, but not something we can specially optimize,
1021  // just drop it in .const.
1022  if (Kind.isReadOnly())
1023  return ReadOnlySection;
1024 
1025  // If this is marked const, put it into a const section. But if the dynamic
1026  // linker needs to write to it, put it in the data segment.
1027  if (Kind.isReadOnlyWithRel())
1028  return ConstDataSection;
1029 
1030  // Put zero initialized globals with strong external linkage in the
1031  // DATA, __common section with the .zerofill directive.
1032  if (Kind.isBSSExtern())
1033  return DataCommonSection;
1034 
1035  // Put zero initialized globals with local linkage in __DATA,__bss directive
1036  // with the .zerofill directive (aka .lcomm).
1037  if (Kind.isBSSLocal())
1038  return DataBSSSection;
1039 
1040  // Otherwise, just drop the variable in the normal data section.
1041  return DataSection;
1042 }
1043 
1045  const DataLayout &DL, SectionKind Kind, const Constant *C,
1046  unsigned &Align) const {
1047  // If this constant requires a relocation, we have to put it in the data
1048  // segment, not in the text segment.
1049  if (Kind.isData() || Kind.isReadOnlyWithRel())
1050  return ConstDataSection;
1051 
1052  if (Kind.isMergeableConst4())
1053  return FourByteConstantSection;
1054  if (Kind.isMergeableConst8())
1055  return EightByteConstantSection;
1056  if (Kind.isMergeableConst16())
1058  return ReadOnlySection; // .const
1059 }
1060 
1062  const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
1063  MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1064  // The mach-o version of this method defaults to returning a stub reference.
1065 
1066  if (Encoding & DW_EH_PE_indirect) {
1067  MachineModuleInfoMachO &MachOMMI =
1069 
1070  MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
1071 
1072  // Add information about the stub reference to MachOMMI so that the stub
1073  // gets emitted by the asmprinter.
1074  MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
1075  if (!StubSym.getPointer()) {
1076  MCSymbol *Sym = TM.getSymbol(GV);
1077  StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
1078  }
1079 
1082  Encoding & ~DW_EH_PE_indirect, Streamer);
1083  }
1084 
1085  return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM,
1086  MMI, Streamer);
1087 }
1088 
1090  const GlobalValue *GV, const TargetMachine &TM,
1091  MachineModuleInfo *MMI) const {
1092  // The mach-o version of this method defaults to returning a stub reference.
1093  MachineModuleInfoMachO &MachOMMI =
1095 
1096  MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
1097 
1098  // Add information about the stub reference to MachOMMI so that the stub
1099  // gets emitted by the asmprinter.
1100  MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
1101  if (!StubSym.getPointer()) {
1102  MCSymbol *Sym = TM.getSymbol(GV);
1103  StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
1104  }
1105 
1106  return SSym;
1107 }
1108 
1110  const MCSymbol *Sym, const MCValue &MV, int64_t Offset,
1111  MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1112  // Although MachO 32-bit targets do not explicitly have a GOTPCREL relocation
1113  // as 64-bit do, we replace the GOT equivalent by accessing the final symbol
1114  // through a non_lazy_ptr stub instead. One advantage is that it allows the
1115  // computation of deltas to final external symbols. Example:
1116  //
1117  // _extgotequiv:
1118  // .long _extfoo
1119  //
1120  // _delta:
1121  // .long _extgotequiv-_delta
1122  //
1123  // is transformed to:
1124  //
1125  // _delta:
1126  // .long L_extfoo$non_lazy_ptr-(_delta+0)
1127  //
1128  // .section __IMPORT,__pointers,non_lazy_symbol_pointers
1129  // L_extfoo$non_lazy_ptr:
1130  // .indirect_symbol _extfoo
1131  // .long 0
1132  //
1133  // The indirect symbol table (and sections of non_lazy_symbol_pointers type)
1134  // may point to both local (same translation unit) and global (other
1135  // translation units) symbols. Example:
1136  //
1137  // .section __DATA,__pointers,non_lazy_symbol_pointers
1138  // L1:
1139  // .indirect_symbol _myGlobal
1140  // .long 0
1141  // L2:
1142  // .indirect_symbol _myLocal
1143  // .long _myLocal
1144  //
1145  // If the symbol is local, instead of the symbol's index, the assembler
1146  // places the constant INDIRECT_SYMBOL_LOCAL into the indirect symbol table.
1147  // Then the linker will notice the constant in the table and will look at the
1148  // content of the symbol.
1149  MachineModuleInfoMachO &MachOMMI =
1151  MCContext &Ctx = getContext();
1152 
1153  // The offset must consider the original displacement from the base symbol
1154  // since 32-bit targets don't have a GOTPCREL to fold the PC displacement.
1155  Offset = -MV.getConstant();
1156  const MCSymbol *BaseSym = &MV.getSymB()->getSymbol();
1157 
1158  // Access the final symbol via sym$non_lazy_ptr and generate the appropriated
1159  // non_lazy_ptr stubs.
1161  StringRef Suffix = "$non_lazy_ptr";
1162  Name += MMI->getModule()->getDataLayout().getPrivateGlobalPrefix();
1163  Name += Sym->getName();
1164  Name += Suffix;
1165  MCSymbol *Stub = Ctx.getOrCreateSymbol(Name);
1166 
1167  MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Stub);
1168  if (!StubSym.getPointer()) {
1169  bool IsIndirectLocal = Sym->isDefined() && !Sym->isExternal();
1170  // With the assumption that IsIndirectLocal == GV->hasLocalLinkage().
1171  StubSym = MachineModuleInfoImpl::StubValueTy(const_cast<MCSymbol *>(Sym),
1172  !IsIndirectLocal);
1173  }
1174 
1175  const MCExpr *BSymExpr =
1177  const MCExpr *LHS =
1179 
1180  if (!Offset)
1181  return MCBinaryExpr::createSub(LHS, BSymExpr, Ctx);
1182 
1183  const MCExpr *RHS =
1184  MCBinaryExpr::createAdd(BSymExpr, MCConstantExpr::create(Offset, Ctx), Ctx);
1185  return MCBinaryExpr::createSub(LHS, RHS, Ctx);
1186 }
1187 
1188 static bool canUsePrivateLabel(const MCAsmInfo &AsmInfo,
1189  const MCSection &Section) {
1190  if (!AsmInfo.isSectionAtomizableBySymbols(Section))
1191  return true;
1192 
1193  // If it is not dead stripped, it is safe to use private labels.
1194  const MCSectionMachO &SMO = cast<MCSectionMachO>(Section);
1196  return true;
1197 
1198  return false;
1199 }
1200 
1202  SmallVectorImpl<char> &OutName, const GlobalValue *GV,
1203  const TargetMachine &TM) const {
1204  bool CannotUsePrivateLabel = true;
1205  if (auto *GO = GV->getBaseObject()) {
1207  const MCSection *TheSection = SectionForGlobal(GO, GOKind, TM);
1208  CannotUsePrivateLabel =
1209  !canUsePrivateLabel(*TM.getMCAsmInfo(), *TheSection);
1210  }
1211  getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
1212 }
1213 
1214 //===----------------------------------------------------------------------===//
1215 // COFF
1216 //===----------------------------------------------------------------------===//
1217 
1218 static unsigned
1220  unsigned Flags = 0;
1221  bool isThumb = TM.getTargetTriple().getArch() == Triple::thumb;
1222 
1223  if (K.isMetadata())
1224  Flags |=
1226  else if (K.isText())
1227  Flags |=
1232  else if (K.isBSS())
1233  Flags |=
1237  else if (K.isThreadLocal())
1238  Flags |=
1242  else if (K.isReadOnly() || K.isReadOnlyWithRel())
1243  Flags |=
1246  else if (K.isWriteable())
1247  Flags |=
1251 
1252  return Flags;
1253 }
1254 
1255 static const GlobalValue *getComdatGVForCOFF(const GlobalValue *GV) {
1256  const Comdat *C = GV->getComdat();
1257  assert(C && "expected GV to have a Comdat!");
1258 
1259  StringRef ComdatGVName = C->getName();
1260  const GlobalValue *ComdatGV = GV->getParent()->getNamedValue(ComdatGVName);
1261  if (!ComdatGV)
1262  report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
1263  "' does not exist.");
1264 
1265  if (ComdatGV->getComdat() != C)
1266  report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
1267  "' is not a key for its COMDAT.");
1268 
1269  return ComdatGV;
1270 }
1271 
1272 static int getSelectionForCOFF(const GlobalValue *GV) {
1273  if (const Comdat *C = GV->getComdat()) {
1274  const GlobalValue *ComdatKey = getComdatGVForCOFF(GV);
1275  if (const auto *GA = dyn_cast<GlobalAlias>(ComdatKey))
1276  ComdatKey = GA->getBaseObject();
1277  if (ComdatKey == GV) {
1278  switch (C->getSelectionKind()) {
1279  case Comdat::Any:
1281  case Comdat::ExactMatch:
1283  case Comdat::Largest:
1285  case Comdat::NoDuplicates:
1287  case Comdat::SameSize:
1289  }
1290  } else {
1292  }
1293  }
1294  return 0;
1295 }
1296 
1298  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1299  int Selection = 0;
1300  unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1301  StringRef Name = GO->getSection();
1302  StringRef COMDATSymName = "";
1303  if (GO->hasComdat()) {
1304  Selection = getSelectionForCOFF(GO);
1305  const GlobalValue *ComdatGV;
1306  if (Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE)
1307  ComdatGV = getComdatGVForCOFF(GO);
1308  else
1309  ComdatGV = GO;
1310 
1311  if (!ComdatGV->hasPrivateLinkage()) {
1312  MCSymbol *Sym = TM.getSymbol(ComdatGV);
1313  COMDATSymName = Sym->getName();
1314  Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1315  } else {
1316  Selection = 0;
1317  }
1318  }
1319 
1320  return getContext().getCOFFSection(Name, Characteristics, Kind, COMDATSymName,
1321  Selection);
1322 }
1323 
1325  if (Kind.isText())
1326  return ".text";
1327  if (Kind.isBSS())
1328  return ".bss";
1329  if (Kind.isThreadLocal())
1330  return ".tls$";
1331  if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
1332  return ".rdata";
1333  return ".data";
1334 }
1335 
1337  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1338  // If we have -ffunction-sections then we should emit the global value to a
1339  // uniqued section specifically for it.
1340  bool EmitUniquedSection;
1341  if (Kind.isText())
1342  EmitUniquedSection = TM.getFunctionSections();
1343  else
1344  EmitUniquedSection = TM.getDataSections();
1345 
1346  if ((EmitUniquedSection && !Kind.isCommon()) || GO->hasComdat()) {
1348 
1349  unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1350 
1351  Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1352  int Selection = getSelectionForCOFF(GO);
1353  if (!Selection)
1355  const GlobalValue *ComdatGV;
1356  if (GO->hasComdat())
1357  ComdatGV = getComdatGVForCOFF(GO);
1358  else
1359  ComdatGV = GO;
1360 
1361  unsigned UniqueID = MCContext::GenericSectionID;
1362  if (EmitUniquedSection)
1363  UniqueID = NextUniqueID++;
1364 
1365  if (!ComdatGV->hasPrivateLinkage()) {
1366  MCSymbol *Sym = TM.getSymbol(ComdatGV);
1367  StringRef COMDATSymName = Sym->getName();
1368 
1369  // Append "$symbol" to the section name *before* IR-level mangling is
1370  // applied when targetting mingw. This is what GCC does, and the ld.bfd
1371  // COFF linker will not properly handle comdats otherwise.
1372  if (getTargetTriple().isWindowsGNUEnvironment())
1373  raw_svector_ostream(Name) << '$' << ComdatGV->getName();
1374 
1375  return getContext().getCOFFSection(Name, Characteristics, Kind,
1376  COMDATSymName, Selection, UniqueID);
1377  } else {
1378  SmallString<256> TmpData;
1379  getMangler().getNameWithPrefix(TmpData, GO, /*CannotUsePrivateLabel=*/true);
1380  return getContext().getCOFFSection(Name, Characteristics, Kind, TmpData,
1381  Selection, UniqueID);
1382  }
1383  }
1384 
1385  if (Kind.isText())
1386  return TextSection;
1387 
1388  if (Kind.isThreadLocal())
1389  return TLSDataSection;
1390 
1391  if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
1392  return ReadOnlySection;
1393 
1394  // Note: we claim that common symbols are put in BSSSection, but they are
1395  // really emitted with the magic .comm directive, which creates a symbol table
1396  // entry but not a section.
1397  if (Kind.isBSS() || Kind.isCommon())
1398  return BSSSection;
1399 
1400  return DataSection;
1401 }
1402 
1404  SmallVectorImpl<char> &OutName, const GlobalValue *GV,
1405  const TargetMachine &TM) const {
1406  bool CannotUsePrivateLabel = false;
1407  if (GV->hasPrivateLinkage() &&
1408  ((isa<Function>(GV) && TM.getFunctionSections()) ||
1409  (isa<GlobalVariable>(GV) && TM.getDataSections())))
1410  CannotUsePrivateLabel = true;
1411 
1412  getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
1413 }
1414 
1416  const Function &F, const TargetMachine &TM) const {
1417  // If the function can be removed, produce a unique section so that
1418  // the table doesn't prevent the removal.
1419  const Comdat *C = F.getComdat();
1420  bool EmitUniqueSection = TM.getFunctionSections() || C;
1421  if (!EmitUniqueSection)
1422  return ReadOnlySection;
1423 
1424  // FIXME: we should produce a symbol for F instead.
1425  if (F.hasPrivateLinkage())
1426  return ReadOnlySection;
1427 
1428  MCSymbol *Sym = TM.getSymbol(&F);
1429  StringRef COMDATSymName = Sym->getName();
1430 
1433  unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1434  Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1435  unsigned UniqueID = NextUniqueID++;
1436 
1437  return getContext().getCOFFSection(
1438  SecName, Characteristics, Kind, COMDATSymName,
1440 }
1441 
1443  Module &M) const {
1444  if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
1445  // Emit the linker options to the linker .drectve section. According to the
1446  // spec, this section is a space-separated string containing flags for
1447  // linker.
1448  MCSection *Sec = getDrectveSection();
1449  Streamer.SwitchSection(Sec);
1450  for (const auto &Option : LinkerOptions->operands()) {
1451  for (const auto &Piece : cast<MDNode>(Option)->operands()) {
1452  // Lead with a space for consistency with our dllexport implementation.
1453  std::string Directive(" ");
1454  Directive.append(cast<MDString>(Piece)->getString());
1455  Streamer.EmitBytes(Directive);
1456  }
1457  }
1458  }
1459 
1460  unsigned Version = 0;
1461  unsigned Flags = 0;
1463 
1464  GetObjCImageInfo(M, Version, Flags, Section);
1465  if (Section.empty())
1466  return;
1467 
1468  auto &C = getContext();
1469  auto *S = C.getCOFFSection(
1472  Streamer.SwitchSection(S);
1473  Streamer.EmitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
1474  Streamer.EmitIntValue(Version, 4);
1475  Streamer.EmitIntValue(Flags, 4);
1476  Streamer.AddBlankLine();
1477 }
1478 
1480  const TargetMachine &TM) {
1482  const Triple &T = TM.getTargetTriple();
1492  } else {
1501  }
1502 }
1503 
1505  const Triple &T, bool IsCtor,
1506  unsigned Priority,
1507  const MCSymbol *KeySym,
1510  // If the priority is the default, use .CRT$XCU, possibly associative.
1511  if (Priority == 65535)
1512  return Ctx.getAssociativeCOFFSection(Default, KeySym, 0);
1513 
1514  // Otherwise, we need to compute a new section name. Low priorities should
1515  // run earlier. The linker will sort sections ASCII-betically, and we need a
1516  // string that sorts between .CRT$XCA and .CRT$XCU. In the general case, we
1517  // make a name like ".CRT$XCT12345", since that runs before .CRT$XCU. Really
1518  // low priorities need to sort before 'L', since the CRT uses that
1519  // internally, so we use ".CRT$XCA00001" for them.
1521  raw_svector_ostream OS(Name);
1522  OS << ".CRT$XC" << (Priority < 200 ? 'A' : 'T') << format("%05u", Priority);
1523  MCSectionCOFF *Sec = Ctx.getCOFFSection(
1526  return Ctx.getAssociativeCOFFSection(Sec, KeySym, 0);
1527  }
1528 
1529  std::string Name = IsCtor ? ".ctors" : ".dtors";
1530  if (Priority != 65535)
1531  raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
1532 
1533  return Ctx.getAssociativeCOFFSection(
1538  KeySym, 0);
1539 }
1540 
1542  unsigned Priority, const MCSymbol *KeySym) const {
1544  Priority, KeySym,
1545  cast<MCSectionCOFF>(StaticCtorSection));
1546 }
1547 
1549  unsigned Priority, const MCSymbol *KeySym) const {
1551  Priority, KeySym,
1552  cast<MCSectionCOFF>(StaticDtorSection));
1553 }
1554 
1556  raw_ostream &OS, const GlobalValue *GV) const {
1558 }
1559 
1561  raw_ostream &OS, const GlobalValue *GV) const {
1563 }
1564 
1566  const GlobalValue *LHS, const GlobalValue *RHS,
1567  const TargetMachine &TM) const {
1568  const Triple &T = TM.getTargetTriple();
1569  if (T.isOSCygMing())
1570  return nullptr;
1571 
1572  // Our symbols should exist in address space zero, cowardly no-op if
1573  // otherwise.
1574  if (LHS->getType()->getPointerAddressSpace() != 0 ||
1575  RHS->getType()->getPointerAddressSpace() != 0)
1576  return nullptr;
1577 
1578  // Both ptrtoint instructions must wrap global objects:
1579  // - Only global variables are eligible for image relative relocations.
1580  // - The subtrahend refers to the special symbol __ImageBase, a GlobalVariable.
1581  // We expect __ImageBase to be a global variable without a section, externally
1582  // defined.
1583  //
1584  // It should look something like this: @__ImageBase = external constant i8
1585  if (!isa<GlobalObject>(LHS) || !isa<GlobalVariable>(RHS) ||
1586  LHS->isThreadLocal() || RHS->isThreadLocal() ||
1587  RHS->getName() != "__ImageBase" || !RHS->hasExternalLinkage() ||
1588  cast<GlobalVariable>(RHS)->hasInitializer() || RHS->hasSection())
1589  return nullptr;
1590 
1591  return MCSymbolRefExpr::create(TM.getSymbol(LHS),
1593  getContext());
1594 }
1595 
1596 static std::string APIntToHexString(const APInt &AI) {
1597  unsigned Width = (AI.getBitWidth() / 8) * 2;
1598  std::string HexString = utohexstr(AI.getLimitedValue(), /*LowerCase=*/true);
1599  unsigned Size = HexString.size();
1600  assert(Width >= Size && "hex string is too large!");
1601  HexString.insert(HexString.begin(), Width - Size, '0');
1602 
1603  return HexString;
1604 }
1605 
1606 static std::string scalarConstantToHexString(const Constant *C) {
1607  Type *Ty = C->getType();
1608  if (isa<UndefValue>(C)) {
1610  } else if (const auto *CFP = dyn_cast<ConstantFP>(C)) {
1611  return APIntToHexString(CFP->getValueAPF().bitcastToAPInt());
1612  } else if (const auto *CI = dyn_cast<ConstantInt>(C)) {
1613  return APIntToHexString(CI->getValue());
1614  } else {
1615  unsigned NumElements;
1616  if (isa<VectorType>(Ty))
1617  NumElements = Ty->getVectorNumElements();
1618  else
1619  NumElements = Ty->getArrayNumElements();
1620  std::string HexString;
1621  for (int I = NumElements - 1, E = -1; I != E; --I)
1623  return HexString;
1624  }
1625 }
1626 
1628  const DataLayout &DL, SectionKind Kind, const Constant *C,
1629  unsigned &Align) const {
1630  if (Kind.isMergeableConst() && C &&
1632  // This creates comdat sections with the given symbol name, but unless
1633  // AsmPrinter::GetCPISymbol actually makes the symbol global, the symbol
1634  // will be created with a null storage class, which makes GNU binutils
1635  // error out.
1639  std::string COMDATSymName;
1640  if (Kind.isMergeableConst4()) {
1641  if (Align <= 4) {
1642  COMDATSymName = "__real@" + scalarConstantToHexString(C);
1643  Align = 4;
1644  }
1645  } else if (Kind.isMergeableConst8()) {
1646  if (Align <= 8) {
1647  COMDATSymName = "__real@" + scalarConstantToHexString(C);
1648  Align = 8;
1649  }
1650  } else if (Kind.isMergeableConst16()) {
1651  // FIXME: These may not be appropriate for non-x86 architectures.
1652  if (Align <= 16) {
1653  COMDATSymName = "__xmm@" + scalarConstantToHexString(C);
1654  Align = 16;
1655  }
1656  } else if (Kind.isMergeableConst32()) {
1657  if (Align <= 32) {
1658  COMDATSymName = "__ymm@" + scalarConstantToHexString(C);
1659  Align = 32;
1660  }
1661  }
1662 
1663  if (!COMDATSymName.empty())
1664  return getContext().getCOFFSection(".rdata", Characteristics, Kind,
1665  COMDATSymName,
1667  }
1668 
1669  return TargetLoweringObjectFile::getSectionForConstant(DL, Kind, C, Align);
1670 }
1671 
1672 
1673 //===----------------------------------------------------------------------===//
1674 // Wasm
1675 //===----------------------------------------------------------------------===//
1676 
1677 static const Comdat *getWasmComdat(const GlobalValue *GV) {
1678  const Comdat *C = GV->getComdat();
1679  if (!C)
1680  return nullptr;
1681 
1682  if (C->getSelectionKind() != Comdat::Any)
1683  report_fatal_error("WebAssembly COMDATs only support "
1684  "SelectionKind::Any, '" + C->getName() + "' cannot be "
1685  "lowered.");
1686 
1687  return C;
1688 }
1689 
1691  // If we're told we have function data, then use that.
1692  if (K.isText())
1693  return SectionKind::getText();
1694 
1695  // Otherwise, ignore whatever section type the generic impl detected and use
1696  // a plain data section.
1697  return SectionKind::getData();
1698 }
1699 
1701  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1702  // We don't support explict section names for functions in the wasm object
1703  // format. Each function has to be in its own unique section.
1704  if (isa<Function>(GO)) {
1705  return SelectSectionForGlobal(GO, Kind, TM);
1706  }
1707 
1708  StringRef Name = GO->getSection();
1709 
1710  Kind = getWasmKindForNamedSection(Name, Kind);
1711 
1712  StringRef Group = "";
1713  if (const Comdat *C = getWasmComdat(GO)) {
1714  Group = C->getName();
1715  }
1716 
1718  getContext().getWasmSection(Name, Kind, Group,
1720 
1721  return Section;
1722 }
1723 
1725  MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
1726  const TargetMachine &TM, bool EmitUniqueSection, unsigned *NextUniqueID) {
1727  StringRef Group = "";
1728  if (const Comdat *C = getWasmComdat(GO)) {
1729  Group = C->getName();
1730  }
1731 
1732  bool UniqueSectionNames = TM.getUniqueSectionNames();
1734 
1735  if (const auto *F = dyn_cast<Function>(GO)) {
1736  const auto &OptionalPrefix = F->getSectionPrefix();
1737  if (OptionalPrefix)
1738  Name += *OptionalPrefix;
1739  }
1740 
1741  if (EmitUniqueSection && UniqueSectionNames) {
1742  Name.push_back('.');
1743  TM.getNameWithPrefix(Name, GO, Mang, true);
1744  }
1745  unsigned UniqueID = MCContext::GenericSectionID;
1746  if (EmitUniqueSection && !UniqueSectionNames) {
1747  UniqueID = *NextUniqueID;
1748  (*NextUniqueID)++;
1749  }
1750 
1751  return Ctx.getWasmSection(Name, Kind, Group, UniqueID);
1752 }
1753 
1755  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1756 
1757  if (Kind.isCommon())
1758  report_fatal_error("mergable sections not supported yet on wasm");
1759 
1760  // If we have -ffunction-section or -fdata-section then we should emit the
1761  // global value to a uniqued section specifically for it.
1762  bool EmitUniqueSection = false;
1763  if (Kind.isText())
1764  EmitUniqueSection = TM.getFunctionSections();
1765  else
1766  EmitUniqueSection = TM.getDataSections();
1767  EmitUniqueSection |= GO->hasComdat();
1768 
1769  return selectWasmSectionForGlobal(getContext(), GO, Kind, getMangler(), TM,
1770  EmitUniqueSection, &NextUniqueID);
1771 }
1772 
1774  bool UsesLabelDifference, const Function &F) const {
1775  // We can always create relative relocations, so use another section
1776  // that can be marked non-executable.
1777  return false;
1778 }
1779 
1781  const GlobalValue *LHS, const GlobalValue *RHS,
1782  const TargetMachine &TM) const {
1783  // We may only use a PLT-relative relocation to refer to unnamed_addr
1784  // functions.
1785  if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
1786  return nullptr;
1787 
1788  // Basic sanity checks.
1789  if (LHS->getType()->getPointerAddressSpace() != 0 ||
1790  RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
1791  RHS->isThreadLocal())
1792  return nullptr;
1793 
1794  return MCBinaryExpr::createSub(
1796  getContext()),
1798 }
1799 
1802  getContext().getWasmSection(".init_array", SectionKind::getData());
1803 
1804  // We don't use PersonalityEncoding and LSDAEncoding because we don't emit
1805  // .cfi directives. We use TTypeEncoding to encode typeinfo global variables.
1807 }
1808 
1810  unsigned Priority, const MCSymbol *KeySym) const {
1811  return Priority == UINT16_MAX ?
1813  getContext().getWasmSection(".init_array." + utostr(Priority),
1815 }
1816 
1818  unsigned Priority, const MCSymbol *KeySym) const {
1819  llvm_unreachable("@llvm.global_dtors should have been lowered already");
1820  return nullptr;
1821 }
const MCExpr * lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS, const TargetMachine &TM) const override
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:310
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:445
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:331
bool hasPrivateLinkage() const
Definition: GlobalValue.h:444
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:469
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:580
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:627
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:428
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:468
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:273
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:422
virtual void Initialize(MCContext &ctx, const TargetMachine &TM)
This method must be called before any actual lowering is done.
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:476
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:64
bool hasExternalLinkage() const
Definition: GlobalValue.h:431
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:554
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:279
op_range operands() const
Definition: Metadata.h:1066
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:296
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:469
bool isWindowsItaniumEnvironment() const
Definition: Triple.h:557
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
static StringRef getCOFFSectionNameForUniqueGlobal(SectionKind Kind)
MCSection * DataSection
Section directive for standard data.
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false)
Definition: MCExpr.cpp:169
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
Pass this value as the UniqueID during section creation to get the generic section with the given nam...
Definition: MCContext.h:389
static bool isWeakForLinker(LinkageTypes Linkage)
Whether the definition of this global may be replaced at link time.
Definition: GlobalValue.h:379
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:56
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:645
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:405
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:344
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:837
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:203
std::string utostr(uint64_t X, bool isNeg=false)
Definition: StringExtras.h:223
bool isOSFreeBSD() const
Definition: Triple.h:501
unsigned getVectorNumElements() const
Definition: DerivedTypes.h:535
unsigned getPreferredAlignment(const GlobalVariable *GV) const
Returns the preferred alignment of the specified global.
Definition: DataLayout.cpp:834
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:249
const Comdat * getComdat() const
Definition: Globals.cpp:171
Class for arbitrary precision integers.
Definition: APInt.h:69
CodeModel::Model getCodeModel() const
Returns the code model.
static SectionKind getWasmKindForNamedSection(StringRef Name, SectionKind K)
bool isOSCygMing() const
Tests for either Cygwin or MinGW OS.
Definition: Triple.h:570
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:223
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:279
uint32_t Size
Definition: Profile.cpp:46
void emitLinkerFlagsForUsedCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &T, Mangler &M)
Definition: Mangler.cpp:215
const Module * getModule() const
MachineModuleInfoMachO - This is a MachineModuleInfoImpl implementation for MachO targets...
const GlobalObject * getBaseObject() const
Definition: Globals.cpp:282
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:204
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:406
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:575
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:576
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:250
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
bool isWindowsMSVCEnvironment() const
Checks if the environment could be MSVC.
Definition: Triple.h:548
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)
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:277
This class contains meta information specific to a module.
std::string utohexstr(uint64_t X, bool LowerCase=false)
Definition: StringExtras.h:124
S_ATTR_NO_DEAD_STRIP - No dead stripping.
Definition: MachO.h:189
SelectionKind getSelectionKind() const
Definition: Comdat.h:44
static SectionKind getText()
Definition: SectionKind.h:179
bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const override