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/MCSectionXCOFF.h"
47 #include "llvm/MC/MCStreamer.h"
48 #include "llvm/MC/MCSymbol.h"
49 #include "llvm/MC/MCSymbolELF.h"
50 #include "llvm/MC/MCValue.h"
51 #include "llvm/MC/SectionKind.h"
53 #include "llvm/Support/Casting.h"
54 #include "llvm/Support/CodeGen.h"
55 #include "llvm/Support/Format.h"
59 #include <cassert>
60 #include <string>
61 
62 using namespace llvm;
63 using namespace dwarf;
64 
65 static void GetObjCImageInfo(Module &M, unsigned &Version, unsigned &Flags,
66  StringRef &Section) {
68  M.getModuleFlagsMetadata(ModuleFlags);
69 
70  for (const auto &MFE: ModuleFlags) {
71  // Ignore flags with 'Require' behaviour.
72  if (MFE.Behavior == Module::Require)
73  continue;
74 
75  StringRef Key = MFE.Key->getString();
76  if (Key == "Objective-C Image Info Version") {
77  Version = mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
78  } else if (Key == "Objective-C Garbage Collection" ||
79  Key == "Objective-C GC Only" ||
80  Key == "Objective-C Is Simulated" ||
81  Key == "Objective-C Class Properties" ||
82  Key == "Objective-C Image Swift Version") {
83  Flags |= mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
84  } else if (Key == "Objective-C Image Info Section") {
85  Section = cast<MDString>(MFE.Val)->getString();
86  }
87  }
88 }
89 
90 //===----------------------------------------------------------------------===//
91 // ELF
92 //===----------------------------------------------------------------------===//
93 
95  const TargetMachine &TgtM) {
97  TM = &TgtM;
98 
99  CodeModel::Model CM = TgtM.getCodeModel();
100 
101  switch (TgtM.getTargetTriple().getArch()) {
102  case Triple::arm:
103  case Triple::armeb:
104  case Triple::thumb:
105  case Triple::thumbeb:
107  break;
108  // Fallthrough if not using EHABI
110  case Triple::ppc:
111  case Triple::x86:
112  PersonalityEncoding = isPositionIndependent()
117  LSDAEncoding = isPositionIndependent()
120  TTypeEncoding = isPositionIndependent()
124  break;
125  case Triple::x86_64:
126  if (isPositionIndependent()) {
127  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
128  ((CM == CodeModel::Small || CM == CodeModel::Medium)
130  LSDAEncoding = dwarf::DW_EH_PE_pcrel |
131  (CM == CodeModel::Small
134  ((CM == CodeModel::Small || CM == CodeModel::Medium)
135  ? dwarf::DW_EH_PE_sdata8 : dwarf::DW_EH_PE_sdata4);
136  } else {
137  PersonalityEncoding =
138  (CM == CodeModel::Small || CM == CodeModel::Medium)
140  LSDAEncoding = (CM == CodeModel::Small)
142  TTypeEncoding = (CM == CodeModel::Small)
144  }
145  break;
146  case Triple::hexagon:
147  PersonalityEncoding = dwarf::DW_EH_PE_absptr;
148  LSDAEncoding = dwarf::DW_EH_PE_absptr;
149  TTypeEncoding = dwarf::DW_EH_PE_absptr;
150  if (isPositionIndependent()) {
151  PersonalityEncoding |= dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel;
152  LSDAEncoding |= dwarf::DW_EH_PE_pcrel;
154  }
155  break;
156  case Triple::aarch64:
157  case Triple::aarch64_be:
158  case Triple::aarch64_32:
159  // The small model guarantees static code/data size < 4GB, but not where it
160  // will be in memory. Most of these could end up >2GB away so even a signed
161  // pc-relative 32-bit address is insufficient, theoretically.
162  if (isPositionIndependent()) {
163  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
168  } else {
169  PersonalityEncoding = dwarf::DW_EH_PE_absptr;
170  LSDAEncoding = dwarf::DW_EH_PE_absptr;
171  TTypeEncoding = dwarf::DW_EH_PE_absptr;
172  }
173  break;
174  case Triple::lanai:
175  LSDAEncoding = dwarf::DW_EH_PE_absptr;
176  PersonalityEncoding = dwarf::DW_EH_PE_absptr;
177  TTypeEncoding = dwarf::DW_EH_PE_absptr;
178  break;
179  case Triple::mips:
180  case Triple::mipsel:
181  case Triple::mips64:
182  case Triple::mips64el:
183  // MIPS uses indirect pointer to refer personality functions and types, so
184  // that the eh_frame section can be read-only. DW.ref.personality will be
185  // generated for relocation.
186  PersonalityEncoding = dwarf::DW_EH_PE_indirect;
187  // FIXME: The N64 ABI probably ought to use DW_EH_PE_sdata8 but we can't
188  // identify N64 from just a triple.
191  // We don't support PC-relative LSDA references in GAS so we use the default
192  // DW_EH_PE_absptr for those.
193 
194  // FreeBSD must be explicit about the data size and using pcrel since it's
195  // assembler/linker won't do the automatic conversion that the Linux tools
196  // do.
197  if (TgtM.getTargetTriple().isOSFreeBSD()) {
198  PersonalityEncoding |= dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
200  }
201  break;
202  case Triple::ppc64:
203  case Triple::ppc64le:
204  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
209  break;
210  case Triple::sparcel:
211  case Triple::sparc:
212  if (isPositionIndependent()) {
214  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
218  } else {
219  LSDAEncoding = dwarf::DW_EH_PE_absptr;
220  PersonalityEncoding = dwarf::DW_EH_PE_absptr;
221  TTypeEncoding = dwarf::DW_EH_PE_absptr;
222  }
223  CallSiteEncoding = dwarf::DW_EH_PE_udata4;
224  break;
225  case Triple::riscv32:
226  case Triple::riscv64:
228  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
232  CallSiteEncoding = dwarf::DW_EH_PE_udata4;
233  break;
234  case Triple::sparcv9:
236  if (isPositionIndependent()) {
237  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
241  } else {
242  PersonalityEncoding = dwarf::DW_EH_PE_absptr;
243  TTypeEncoding = dwarf::DW_EH_PE_absptr;
244  }
245  break;
246  case Triple::systemz:
247  // All currently-defined code models guarantee that 4-byte PC-relative
248  // values will be in range.
249  if (isPositionIndependent()) {
250  PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
255  } else {
256  PersonalityEncoding = dwarf::DW_EH_PE_absptr;
257  LSDAEncoding = dwarf::DW_EH_PE_absptr;
258  TTypeEncoding = dwarf::DW_EH_PE_absptr;
259  }
260  break;
261  default:
262  break;
263  }
264 }
265 
267  Module &M) const {
268  auto &C = getContext();
269 
270  if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
271  auto *S = C.getELFSection(".linker-options", ELF::SHT_LLVM_LINKER_OPTIONS,
273 
274  Streamer.SwitchSection(S);
275 
276  for (const auto &Operand : LinkerOptions->operands()) {
277  if (cast<MDNode>(Operand)->getNumOperands() != 2)
278  report_fatal_error("invalid llvm.linker.options");
279  for (const auto &Option : cast<MDNode>(Operand)->operands()) {
280  Streamer.EmitBytes(cast<MDString>(Option)->getString());
281  Streamer.EmitIntValue(0, 1);
282  }
283  }
284  }
285 
286  if (NamedMDNode *DependentLibraries = M.getNamedMetadata("llvm.dependent-libraries")) {
287  auto *S = C.getELFSection(".deplibs", ELF::SHT_LLVM_DEPENDENT_LIBRARIES,
289 
290  Streamer.SwitchSection(S);
291 
292  for (const auto &Operand : DependentLibraries->operands()) {
293  Streamer.EmitBytes(
294  cast<MDString>(cast<MDNode>(Operand)->getOperand(0))->getString());
295  Streamer.EmitIntValue(0, 1);
296  }
297  }
298 
299  unsigned Version = 0;
300  unsigned Flags = 0;
302 
303  GetObjCImageInfo(M, Version, Flags, Section);
304  if (!Section.empty()) {
305  auto *S = C.getELFSection(Section, ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
306  Streamer.SwitchSection(S);
307  Streamer.EmitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
308  Streamer.EmitIntValue(Version, 4);
309  Streamer.EmitIntValue(Flags, 4);
310  Streamer.AddBlankLine();
311  }
312 
314  M.getModuleFlagsMetadata(ModuleFlags);
315 
316  MDNode *CFGProfile = nullptr;
317 
318  for (const auto &MFE : ModuleFlags) {
319  StringRef Key = MFE.Key->getString();
320  if (Key == "CG Profile") {
321  CFGProfile = cast<MDNode>(MFE.Val);
322  break;
323  }
324  }
325 
326  if (!CFGProfile)
327  return;
328 
329  auto GetSym = [this](const MDOperand &MDO) -> MCSymbol * {
330  if (!MDO)
331  return nullptr;
332  auto V = cast<ValueAsMetadata>(MDO);
333  const Function *F = cast<Function>(V->getValue());
334  return TM->getSymbol(F);
335  };
336 
337  for (const auto &Edge : CFGProfile->operands()) {
338  MDNode *E = cast<MDNode>(Edge);
339  const MCSymbol *From = GetSym(E->getOperand(0));
340  const MCSymbol *To = GetSym(E->getOperand(1));
341  // Skip null functions. This can happen if functions are dead stripped after
342  // the CGProfile pass has been run.
343  if (!From || !To)
344  continue;
345  uint64_t Count = cast<ConstantAsMetadata>(E->getOperand(2))
346  ->getValue()
347  ->getUniqueInteger()
348  .getZExtValue();
349  Streamer.emitCGProfileEntry(
352  }
353 }
354 
356  const GlobalValue *GV, const TargetMachine &TM,
357  MachineModuleInfo *MMI) const {
358  unsigned Encoding = getPersonalityEncoding();
359  if ((Encoding & 0x80) == DW_EH_PE_indirect)
360  return getContext().getOrCreateSymbol(StringRef("DW.ref.") +
361  TM.getSymbol(GV)->getName());
362  if ((Encoding & 0x70) == DW_EH_PE_absptr)
363  return TM.getSymbol(GV);
364  report_fatal_error("We do not support this DWARF encoding yet!");
365 }
366 
368  MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym) const {
369  SmallString<64> NameData("DW.ref.");
370  NameData += Sym->getName();
371  MCSymbolELF *Label =
372  cast<MCSymbolELF>(getContext().getOrCreateSymbol(NameData));
373  Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
374  Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
375  unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
376  MCSection *Sec = getContext().getELFNamedSection(".data", Label->getName(),
377  ELF::SHT_PROGBITS, Flags, 0);
378  unsigned Size = DL.getPointerSize();
379  Streamer.SwitchSection(Sec);
381  Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
382  const MCExpr *E = MCConstantExpr::create(Size, getContext());
383  Streamer.emitELFSize(Label, E);
384  Streamer.EmitLabel(Label);
385 
386  Streamer.EmitSymbolValue(Sym, Size);
387 }
388 
390  const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
391  MachineModuleInfo *MMI, MCStreamer &Streamer) const {
392  if (Encoding & DW_EH_PE_indirect) {
394 
395  MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", TM);
396 
397  // Add information about the stub reference to ELFMMI so that the stub
398  // gets emitted by the asmprinter.
399  MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
400  if (!StubSym.getPointer()) {
401  MCSymbol *Sym = TM.getSymbol(GV);
403  }
404 
406  getTTypeReference(MCSymbolRefExpr::create(SSym, getContext()),
407  Encoding & ~DW_EH_PE_indirect, Streamer);
408  }
409 
411  MMI, Streamer);
412 }
413 
415  // N.B.: The defaults used in here are not the same ones used in MC.
416  // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
417  // both gas and MC will produce a section with no flags. Given
418  // section(".eh_frame") gcc will produce:
419  //
420  // .section .eh_frame,"a",@progbits
421 
422  if (Name == getInstrProfSectionName(IPSK_covmap, Triple::ELF,
423  /*AddSegmentInfo=*/false))
424  return SectionKind::getMetadata();
425 
426  if (Name.empty() || Name[0] != '.') return K;
427 
428  // Default implementation based on some magic section names.
429  if (Name == ".bss" ||
430  Name.startswith(".bss.") ||
431  Name.startswith(".gnu.linkonce.b.") ||
432  Name.startswith(".llvm.linkonce.b.") ||
433  Name == ".sbss" ||
434  Name.startswith(".sbss.") ||
435  Name.startswith(".gnu.linkonce.sb.") ||
436  Name.startswith(".llvm.linkonce.sb."))
437  return SectionKind::getBSS();
438 
439  if (Name == ".tdata" ||
440  Name.startswith(".tdata.") ||
441  Name.startswith(".gnu.linkonce.td.") ||
442  Name.startswith(".llvm.linkonce.td."))
444 
445  if (Name == ".tbss" ||
446  Name.startswith(".tbss.") ||
447  Name.startswith(".gnu.linkonce.tb.") ||
448  Name.startswith(".llvm.linkonce.tb."))
449  return SectionKind::getThreadBSS();
450 
451  return K;
452 }
453 
455  // Use SHT_NOTE for section whose name starts with ".note" to allow
456  // emitting ELF notes from C variable declaration.
457  // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77609
458  if (Name.startswith(".note"))
459  return ELF::SHT_NOTE;
460 
461  if (Name == ".init_array")
462  return ELF::SHT_INIT_ARRAY;
463 
464  if (Name == ".fini_array")
465  return ELF::SHT_FINI_ARRAY;
466 
467  if (Name == ".preinit_array")
468  return ELF::SHT_PREINIT_ARRAY;
469 
470  if (K.isBSS() || K.isThreadBSS())
471  return ELF::SHT_NOBITS;
472 
473  return ELF::SHT_PROGBITS;
474 }
475 
476 static unsigned getELFSectionFlags(SectionKind K) {
477  unsigned Flags = 0;
478 
479  if (!K.isMetadata())
480  Flags |= ELF::SHF_ALLOC;
481 
482  if (K.isText())
483  Flags |= ELF::SHF_EXECINSTR;
484 
485  if (K.isExecuteOnly())
486  Flags |= ELF::SHF_ARM_PURECODE;
487 
488  if (K.isWriteable())
489  Flags |= ELF::SHF_WRITE;
490 
491  if (K.isThreadLocal())
492  Flags |= ELF::SHF_TLS;
493 
494  if (K.isMergeableCString() || K.isMergeableConst())
495  Flags |= ELF::SHF_MERGE;
496 
497  if (K.isMergeableCString())
498  Flags |= ELF::SHF_STRINGS;
499 
500  return Flags;
501 }
502 
503 static const Comdat *getELFComdat(const GlobalValue *GV) {
504  const Comdat *C = GV->getComdat();
505  if (!C)
506  return nullptr;
507 
508  if (C->getSelectionKind() != Comdat::Any)
509  report_fatal_error("ELF COMDATs only support SelectionKind::Any, '" +
510  C->getName() + "' cannot be lowered.");
511 
512  return C;
513 }
514 
516  const TargetMachine &TM) {
517  MDNode *MD = GO->getMetadata(LLVMContext::MD_associated);
518  if (!MD)
519  return nullptr;
520 
521  const MDOperand &Op = MD->getOperand(0);
522  if (!Op.get())
523  return nullptr;
524 
525  auto *VM = dyn_cast<ValueAsMetadata>(Op);
526  if (!VM)
527  report_fatal_error("MD_associated operand is not ValueAsMetadata");
528 
529  auto *OtherGV = dyn_cast<GlobalValue>(VM->getValue());
530  return OtherGV ? dyn_cast<MCSymbolELF>(TM.getSymbol(OtherGV)) : nullptr;
531 }
532 
534  if (Kind.isMergeable1ByteCString())
535  return 1;
536  else if (Kind.isMergeable2ByteCString())
537  return 2;
538  else if (Kind.isMergeable4ByteCString())
539  return 4;
540  else if (Kind.isMergeableConst4())
541  return 4;
542  else if (Kind.isMergeableConst8())
543  return 8;
544  else if (Kind.isMergeableConst16())
545  return 16;
546  else if (Kind.isMergeableConst32())
547  return 32;
548  else {
549  // We shouldn't have mergeable C strings or mergeable constants that we
550  // didn't handle above.
551  assert(!Kind.isMergeableCString() && "unknown string width");
552  assert(!Kind.isMergeableConst() && "unknown data width");
553  return 0;
554  }
555 }
556 
558  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
560 
561  // Check if '#pragma clang section' name is applicable.
562  // Note that pragma directive overrides -ffunction-section, -fdata-section
563  // and so section name is exactly as user specified and not uniqued.
564  const GlobalVariable *GV = dyn_cast<GlobalVariable>(GO);
565  if (GV && GV->hasImplicitSection()) {
566  auto Attrs = GV->getAttributes();
567  if (Attrs.hasAttribute("bss-section") && Kind.isBSS()) {
568  SectionName = Attrs.getAttribute("bss-section").getValueAsString();
569  } else if (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly()) {
570  SectionName = Attrs.getAttribute("rodata-section").getValueAsString();
571  } else if (Attrs.hasAttribute("data-section") && Kind.isData()) {
572  SectionName = Attrs.getAttribute("data-section").getValueAsString();
573  }
574  }
575  const Function *F = dyn_cast<Function>(GO);
576  if (F && F->hasFnAttribute("implicit-section-name")) {
577  SectionName = F->getFnAttribute("implicit-section-name").getValueAsString();
578  }
579 
580  // Infer section flags from the section name if we can.
581  Kind = getELFKindForNamedSection(SectionName, Kind);
582 
583  StringRef Group = "";
584  unsigned Flags = getELFSectionFlags(Kind);
585  if (const Comdat *C = getELFComdat(GO)) {
586  Group = C->getName();
587  Flags |= ELF::SHF_GROUP;
588  }
589 
590  // A section can have at most one associated section. Put each global with
591  // MD_associated in a unique section.
592  unsigned UniqueID = MCContext::GenericSectionID;
593  const MCSymbolELF *AssociatedSymbol = getAssociatedSymbol(GO, TM);
594  if (AssociatedSymbol) {
595  UniqueID = NextUniqueID++;
596  Flags |= ELF::SHF_LINK_ORDER;
597  }
598 
599  MCSectionELF *Section = getContext().getELFSection(
600  SectionName, getELFSectionType(SectionName, Kind), Flags,
601  getEntrySizeForKind(Kind), Group, UniqueID, AssociatedSymbol);
602  // Make sure that we did not get some other section with incompatible sh_link.
603  // This should not be possible due to UniqueID code above.
604  assert(Section->getAssociatedSymbol() == AssociatedSymbol &&
605  "Associated symbol mismatch between sections");
606  return Section;
607 }
608 
609 /// Return the section prefix name used by options FunctionsSections and
610 /// DataSections.
612  if (Kind.isText())
613  return ".text";
614  if (Kind.isReadOnly())
615  return ".rodata";
616  if (Kind.isBSS())
617  return ".bss";
618  if (Kind.isThreadData())
619  return ".tdata";
620  if (Kind.isThreadBSS())
621  return ".tbss";
622  if (Kind.isData())
623  return ".data";
624  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
625  return ".data.rel.ro";
626 }
627 
629  MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
630  const TargetMachine &TM, bool EmitUniqueSection, unsigned Flags,
631  unsigned *NextUniqueID, const MCSymbolELF *AssociatedSymbol) {
632 
633  StringRef Group = "";
634  if (const Comdat *C = getELFComdat(GO)) {
635  Flags |= ELF::SHF_GROUP;
636  Group = C->getName();
637  }
638 
639  // Get the section entry size based on the kind.
640  unsigned EntrySize = getEntrySizeForKind(Kind);
641 
643  if (Kind.isMergeableCString()) {
644  // We also need alignment here.
645  // FIXME: this is getting the alignment of the character, not the
646  // alignment of the global!
648  cast<GlobalVariable>(GO));
649 
650  std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
651  Name = SizeSpec + utostr(Align);
652  } else if (Kind.isMergeableConst()) {
653  Name = ".rodata.cst";
654  Name += utostr(EntrySize);
655  } else {
656  Name = getSectionPrefixForGlobal(Kind);
657  }
658 
659  if (const auto *F = dyn_cast<Function>(GO)) {
660  const auto &OptionalPrefix = F->getSectionPrefix();
661  if (OptionalPrefix)
662  Name += *OptionalPrefix;
663  }
664 
665  unsigned UniqueID = MCContext::GenericSectionID;
666  if (EmitUniqueSection) {
667  if (TM.getUniqueSectionNames()) {
668  Name.push_back('.');
669  TM.getNameWithPrefix(Name, GO, Mang, true /*MayAlwaysUsePrivate*/);
670  } else {
671  UniqueID = *NextUniqueID;
672  (*NextUniqueID)++;
673  }
674  }
675  // Use 0 as the unique ID for execute-only text.
676  if (Kind.isExecuteOnly())
677  UniqueID = 0;
678  return Ctx.getELFSection(Name, getELFSectionType(Name, Kind), Flags,
679  EntrySize, Group, UniqueID, AssociatedSymbol);
680 }
681 
683  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
684  unsigned Flags = getELFSectionFlags(Kind);
685 
686  // If we have -ffunction-section or -fdata-section then we should emit the
687  // global value to a uniqued section specifically for it.
688  bool EmitUniqueSection = false;
689  if (!(Flags & ELF::SHF_MERGE) && !Kind.isCommon()) {
690  if (Kind.isText())
691  EmitUniqueSection = TM.getFunctionSections();
692  else
693  EmitUniqueSection = TM.getDataSections();
694  }
695  EmitUniqueSection |= GO->hasComdat();
696 
697  const MCSymbolELF *AssociatedSymbol = getAssociatedSymbol(GO, TM);
698  if (AssociatedSymbol) {
699  EmitUniqueSection = true;
700  Flags |= ELF::SHF_LINK_ORDER;
701  }
702 
704  getContext(), GO, Kind, getMangler(), TM, EmitUniqueSection, Flags,
705  &NextUniqueID, AssociatedSymbol);
706  assert(Section->getAssociatedSymbol() == AssociatedSymbol);
707  return Section;
708 }
709 
711  const Function &F, const TargetMachine &TM) const {
712  // If the function can be removed, produce a unique section so that
713  // the table doesn't prevent the removal.
714  const Comdat *C = F.getComdat();
715  bool EmitUniqueSection = TM.getFunctionSections() || C;
716  if (!EmitUniqueSection)
717  return ReadOnlySection;
718 
719  return selectELFSectionForGlobal(getContext(), &F, SectionKind::getReadOnly(),
720  getMangler(), TM, EmitUniqueSection,
721  ELF::SHF_ALLOC, &NextUniqueID,
722  /* AssociatedSymbol */ nullptr);
723 }
724 
726  bool UsesLabelDifference, const Function &F) const {
727  // We can always create relative relocations, so use another section
728  // that can be marked non-executable.
729  return false;
730 }
731 
732 /// Given a mergeable constant with the specified size and relocation
733 /// information, return a section that it should be placed in.
735  const DataLayout &DL, SectionKind Kind, const Constant *C,
736  unsigned &Align) const {
737  if (Kind.isMergeableConst4() && MergeableConst4Section)
738  return MergeableConst4Section;
739  if (Kind.isMergeableConst8() && MergeableConst8Section)
740  return MergeableConst8Section;
741  if (Kind.isMergeableConst16() && MergeableConst16Section)
742  return MergeableConst16Section;
743  if (Kind.isMergeableConst32() && MergeableConst32Section)
744  return MergeableConst32Section;
745  if (Kind.isReadOnly())
746  return ReadOnlySection;
747 
748  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
749  return DataRelROSection;
750 }
751 
752 static MCSectionELF *getStaticStructorSection(MCContext &Ctx, bool UseInitArray,
753  bool IsCtor, unsigned Priority,
754  const MCSymbol *KeySym) {
755  std::string Name;
756  unsigned Type;
757  unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE;
758  StringRef COMDAT = KeySym ? KeySym->getName() : "";
759 
760  if (KeySym)
761  Flags |= ELF::SHF_GROUP;
762 
763  if (UseInitArray) {
764  if (IsCtor) {
765  Type = ELF::SHT_INIT_ARRAY;
766  Name = ".init_array";
767  } else {
768  Type = ELF::SHT_FINI_ARRAY;
769  Name = ".fini_array";
770  }
771  if (Priority != 65535) {
772  Name += '.';
773  Name += utostr(Priority);
774  }
775  } else {
776  // The default scheme is .ctor / .dtor, so we have to invert the priority
777  // numbering.
778  if (IsCtor)
779  Name = ".ctors";
780  else
781  Name = ".dtors";
782  if (Priority != 65535)
783  raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
784  Type = ELF::SHT_PROGBITS;
785  }
786 
787  return Ctx.getELFSection(Name, Type, Flags, 0, COMDAT);
788 }
789 
791  unsigned Priority, const MCSymbol *KeySym) const {
792  return getStaticStructorSection(getContext(), UseInitArray, true, Priority,
793  KeySym);
794 }
795 
797  unsigned Priority, const MCSymbol *KeySym) const {
798  return getStaticStructorSection(getContext(), UseInitArray, false, Priority,
799  KeySym);
800 }
801 
803  const GlobalValue *LHS, const GlobalValue *RHS,
804  const TargetMachine &TM) const {
805  // We may only use a PLT-relative relocation to refer to unnamed_addr
806  // functions.
807  if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
808  return nullptr;
809 
810  // Basic sanity checks.
811  if (LHS->getType()->getPointerAddressSpace() != 0 ||
812  RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
813  RHS->isThreadLocal())
814  return nullptr;
815 
817  MCSymbolRefExpr::create(TM.getSymbol(LHS), PLTRelativeVariantKind,
818  getContext()),
819  MCSymbolRefExpr::create(TM.getSymbol(RHS), getContext()), getContext());
820 }
821 
823  // Use ".GCC.command.line" since this feature is to support clang's
824  // -frecord-gcc-switches which in turn attempts to mimic GCC's switch of the
825  // same name.
826  return getContext().getELFSection(".GCC.command.line", ELF::SHT_PROGBITS,
828 }
829 
830 void
832  UseInitArray = UseInitArray_;
833  MCContext &Ctx = getContext();
834  if (!UseInitArray) {
835  StaticCtorSection = Ctx.getELFSection(".ctors", ELF::SHT_PROGBITS,
837 
838  StaticDtorSection = Ctx.getELFSection(".dtors", ELF::SHT_PROGBITS,
840  return;
841  }
842 
843  StaticCtorSection = Ctx.getELFSection(".init_array", ELF::SHT_INIT_ARRAY,
845  StaticDtorSection = Ctx.getELFSection(".fini_array", ELF::SHT_FINI_ARRAY,
847 }
848 
849 //===----------------------------------------------------------------------===//
850 // MachO
851 //===----------------------------------------------------------------------===//
852 
856 }
857 
859  const TargetMachine &TM) {
861  if (TM.getRelocationModel() == Reloc::Static) {
862  StaticCtorSection = Ctx.getMachOSection("__TEXT", "__constructor", 0,
864  StaticDtorSection = Ctx.getMachOSection("__TEXT", "__destructor", 0,
866  } else {
867  StaticCtorSection = Ctx.getMachOSection("__DATA", "__mod_init_func",
870  StaticDtorSection = Ctx.getMachOSection("__DATA", "__mod_term_func",
873  }
874 
878  TTypeEncoding =
880 }
881 
883  Module &M) const {
884  // Emit the linker options if present.
885  if (auto *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
886  for (const auto &Option : LinkerOptions->operands()) {
887  SmallVector<std::string, 4> StrOptions;
888  for (const auto &Piece : cast<MDNode>(Option)->operands())
889  StrOptions.push_back(cast<MDString>(Piece)->getString());
890  Streamer.EmitLinkerOptions(StrOptions);
891  }
892  }
893 
894  unsigned VersionVal = 0;
895  unsigned ImageInfoFlags = 0;
896  StringRef SectionVal;
897 
898  GetObjCImageInfo(M, VersionVal, ImageInfoFlags, SectionVal);
899 
900  // The section is mandatory. If we don't have it, then we don't have GC info.
901  if (SectionVal.empty())
902  return;
903 
904  StringRef Segment, Section;
905  unsigned TAA = 0, StubSize = 0;
906  bool TAAParsed;
907  std::string ErrorCode =
908  MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section,
909  TAA, TAAParsed, StubSize);
910  if (!ErrorCode.empty())
911  // If invalid, report the error with report_fatal_error.
912  report_fatal_error("Invalid section specifier '" + Section + "': " +
913  ErrorCode + ".");
914 
915  // Get the section.
917  Segment, Section, TAA, StubSize, SectionKind::getData());
918  Streamer.SwitchSection(S);
919  Streamer.EmitLabel(getContext().
920  getOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
921  Streamer.EmitIntValue(VersionVal, 4);
922  Streamer.EmitIntValue(ImageInfoFlags, 4);
923  Streamer.AddBlankLine();
924 }
925 
926 static void checkMachOComdat(const GlobalValue *GV) {
927  const Comdat *C = GV->getComdat();
928  if (!C)
929  return;
930 
931  report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() +
932  "' cannot be lowered.");
933 }
934 
936  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
937  // Parse the section specifier and create it if valid.
938  StringRef Segment, Section;
939  unsigned TAA = 0, StubSize = 0;
940  bool TAAParsed;
941 
942  checkMachOComdat(GO);
943 
944  std::string ErrorCode =
946  TAA, TAAParsed, StubSize);
947  if (!ErrorCode.empty()) {
948  // If invalid, report the error with report_fatal_error.
949  report_fatal_error("Global variable '" + GO->getName() +
950  "' has an invalid section specifier '" +
951  GO->getSection() + "': " + ErrorCode + ".");
952  }
953 
954  // Get the section.
955  MCSectionMachO *S =
956  getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
957 
958  // If TAA wasn't set by ParseSectionSpecifier() above,
959  // use the value returned by getMachOSection() as a default.
960  if (!TAAParsed)
961  TAA = S->getTypeAndAttributes();
962 
963  // Okay, now that we got the section, verify that the TAA & StubSize agree.
964  // If the user declared multiple globals with different section flags, we need
965  // to reject it here.
966  if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
967  // If invalid, report the error with report_fatal_error.
968  report_fatal_error("Global variable '" + GO->getName() +
969  "' section type or attributes does not match previous"
970  " section specifier");
971  }
972 
973  return S;
974 }
975 
977  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
978  checkMachOComdat(GO);
979 
980  // Handle thread local data.
981  if (Kind.isThreadBSS()) return TLSBSSSection;
982  if (Kind.isThreadData()) return TLSDataSection;
983 
984  if (Kind.isText())
986 
987  // If this is weak/linkonce, put this in a coalescable section, either in text
988  // or data depending on if it is writable.
989  if (GO->isWeakForLinker()) {
990  if (Kind.isReadOnly())
991  return ConstTextCoalSection;
992  if (Kind.isReadOnlyWithRel())
993  return ConstDataCoalSection;
994  return DataCoalSection;
995  }
996 
997  // FIXME: Alignment check should be handled by section classifier.
998  if (Kind.isMergeable1ByteCString() &&
1000  cast<GlobalVariable>(GO)) < 32)
1001  return CStringSection;
1002 
1003  // Do not put 16-bit arrays in the UString section if they have an
1004  // externally visible label, this runs into issues with certain linker
1005  // versions.
1006  if (Kind.isMergeable2ByteCString() && !GO->hasExternalLinkage() &&
1008  cast<GlobalVariable>(GO)) < 32)
1009  return UStringSection;
1010 
1011  // With MachO only variables whose corresponding symbol starts with 'l' or
1012  // 'L' can be merged, so we only try merging GVs with private linkage.
1013  if (GO->hasPrivateLinkage() && Kind.isMergeableConst()) {
1014  if (Kind.isMergeableConst4())
1015  return FourByteConstantSection;
1016  if (Kind.isMergeableConst8())
1017  return EightByteConstantSection;
1018  if (Kind.isMergeableConst16())
1020  }
1021 
1022  // Otherwise, if it is readonly, but not something we can specially optimize,
1023  // just drop it in .const.
1024  if (Kind.isReadOnly())
1025  return ReadOnlySection;
1026 
1027  // If this is marked const, put it into a const section. But if the dynamic
1028  // linker needs to write to it, put it in the data segment.
1029  if (Kind.isReadOnlyWithRel())
1030  return ConstDataSection;
1031 
1032  // Put zero initialized globals with strong external linkage in the
1033  // DATA, __common section with the .zerofill directive.
1034  if (Kind.isBSSExtern())
1035  return DataCommonSection;
1036 
1037  // Put zero initialized globals with local linkage in __DATA,__bss directive
1038  // with the .zerofill directive (aka .lcomm).
1039  if (Kind.isBSSLocal())
1040  return DataBSSSection;
1041 
1042  // Otherwise, just drop the variable in the normal data section.
1043  return DataSection;
1044 }
1045 
1047  const DataLayout &DL, SectionKind Kind, const Constant *C,
1048  unsigned &Align) const {
1049  // If this constant requires a relocation, we have to put it in the data
1050  // segment, not in the text segment.
1051  if (Kind.isData() || Kind.isReadOnlyWithRel())
1052  return ConstDataSection;
1053 
1054  if (Kind.isMergeableConst4())
1055  return FourByteConstantSection;
1056  if (Kind.isMergeableConst8())
1057  return EightByteConstantSection;
1058  if (Kind.isMergeableConst16())
1060  return ReadOnlySection; // .const
1061 }
1062 
1064  const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
1065  MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1066  // The mach-o version of this method defaults to returning a stub reference.
1067 
1068  if (Encoding & DW_EH_PE_indirect) {
1069  MachineModuleInfoMachO &MachOMMI =
1071 
1072  MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
1073 
1074  // Add information about the stub reference to MachOMMI so that the stub
1075  // gets emitted by the asmprinter.
1076  MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
1077  if (!StubSym.getPointer()) {
1078  MCSymbol *Sym = TM.getSymbol(GV);
1079  StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
1080  }
1081 
1084  Encoding & ~DW_EH_PE_indirect, Streamer);
1085  }
1086 
1087  return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM,
1088  MMI, Streamer);
1089 }
1090 
1092  const GlobalValue *GV, const TargetMachine &TM,
1093  MachineModuleInfo *MMI) const {
1094  // The mach-o version of this method defaults to returning a stub reference.
1095  MachineModuleInfoMachO &MachOMMI =
1097 
1098  MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
1099 
1100  // Add information about the stub reference to MachOMMI so that the stub
1101  // gets emitted by the asmprinter.
1102  MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
1103  if (!StubSym.getPointer()) {
1104  MCSymbol *Sym = TM.getSymbol(GV);
1105  StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
1106  }
1107 
1108  return SSym;
1109 }
1110 
1112  const GlobalValue *GV, const MCSymbol *Sym, const MCValue &MV,
1113  int64_t Offset, MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1114  // Although MachO 32-bit targets do not explicitly have a GOTPCREL relocation
1115  // as 64-bit do, we replace the GOT equivalent by accessing the final symbol
1116  // through a non_lazy_ptr stub instead. One advantage is that it allows the
1117  // computation of deltas to final external symbols. Example:
1118  //
1119  // _extgotequiv:
1120  // .long _extfoo
1121  //
1122  // _delta:
1123  // .long _extgotequiv-_delta
1124  //
1125  // is transformed to:
1126  //
1127  // _delta:
1128  // .long L_extfoo$non_lazy_ptr-(_delta+0)
1129  //
1130  // .section __IMPORT,__pointers,non_lazy_symbol_pointers
1131  // L_extfoo$non_lazy_ptr:
1132  // .indirect_symbol _extfoo
1133  // .long 0
1134  //
1135  // The indirect symbol table (and sections of non_lazy_symbol_pointers type)
1136  // may point to both local (same translation unit) and global (other
1137  // translation units) symbols. Example:
1138  //
1139  // .section __DATA,__pointers,non_lazy_symbol_pointers
1140  // L1:
1141  // .indirect_symbol _myGlobal
1142  // .long 0
1143  // L2:
1144  // .indirect_symbol _myLocal
1145  // .long _myLocal
1146  //
1147  // If the symbol is local, instead of the symbol's index, the assembler
1148  // places the constant INDIRECT_SYMBOL_LOCAL into the indirect symbol table.
1149  // Then the linker will notice the constant in the table and will look at the
1150  // content of the symbol.
1151  MachineModuleInfoMachO &MachOMMI =
1153  MCContext &Ctx = getContext();
1154 
1155  // The offset must consider the original displacement from the base symbol
1156  // since 32-bit targets don't have a GOTPCREL to fold the PC displacement.
1157  Offset = -MV.getConstant();
1158  const MCSymbol *BaseSym = &MV.getSymB()->getSymbol();
1159 
1160  // Access the final symbol via sym$non_lazy_ptr and generate the appropriated
1161  // non_lazy_ptr stubs.
1163  StringRef Suffix = "$non_lazy_ptr";
1164  Name += MMI->getModule()->getDataLayout().getPrivateGlobalPrefix();
1165  Name += Sym->getName();
1166  Name += Suffix;
1167  MCSymbol *Stub = Ctx.getOrCreateSymbol(Name);
1168 
1169  MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Stub);
1170 
1171  if (!StubSym.getPointer())
1172  StubSym = MachineModuleInfoImpl::StubValueTy(const_cast<MCSymbol *>(Sym),
1173  !GV->hasLocalLinkage());
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$X" << (IsCtor ? "C" : "T") <<
1523  (Priority < 200 ? 'A' : 'T') << format("%05u", Priority);
1524  MCSectionCOFF *Sec = Ctx.getCOFFSection(
1527  return Ctx.getAssociativeCOFFSection(Sec, KeySym, 0);
1528  }
1529 
1530  std::string Name = IsCtor ? ".ctors" : ".dtors";
1531  if (Priority != 65535)
1532  raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
1533 
1534  return Ctx.getAssociativeCOFFSection(
1539  KeySym, 0);
1540 }
1541 
1543  unsigned Priority, const MCSymbol *KeySym) const {
1545  Priority, KeySym,
1546  cast<MCSectionCOFF>(StaticCtorSection));
1547 }
1548 
1550  unsigned Priority, const MCSymbol *KeySym) const {
1552  Priority, KeySym,
1553  cast<MCSectionCOFF>(StaticDtorSection));
1554 }
1555 
1557  raw_ostream &OS, const GlobalValue *GV) const {
1559 }
1560 
1562  raw_ostream &OS, const GlobalValue *GV) const {
1564 }
1565 
1567  const GlobalValue *LHS, const GlobalValue *RHS,
1568  const TargetMachine &TM) const {
1569  const Triple &T = TM.getTargetTriple();
1570  if (T.isOSCygMing())
1571  return nullptr;
1572 
1573  // Our symbols should exist in address space zero, cowardly no-op if
1574  // otherwise.
1575  if (LHS->getType()->getPointerAddressSpace() != 0 ||
1576  RHS->getType()->getPointerAddressSpace() != 0)
1577  return nullptr;
1578 
1579  // Both ptrtoint instructions must wrap global objects:
1580  // - Only global variables are eligible for image relative relocations.
1581  // - The subtrahend refers to the special symbol __ImageBase, a GlobalVariable.
1582  // We expect __ImageBase to be a global variable without a section, externally
1583  // defined.
1584  //
1585  // It should look something like this: @__ImageBase = external constant i8
1586  if (!isa<GlobalObject>(LHS) || !isa<GlobalVariable>(RHS) ||
1587  LHS->isThreadLocal() || RHS->isThreadLocal() ||
1588  RHS->getName() != "__ImageBase" || !RHS->hasExternalLinkage() ||
1589  cast<GlobalVariable>(RHS)->hasInitializer() || RHS->hasSection())
1590  return nullptr;
1591 
1592  return MCSymbolRefExpr::create(TM.getSymbol(LHS),
1594  getContext());
1595 }
1596 
1597 static std::string APIntToHexString(const APInt &AI) {
1598  unsigned Width = (AI.getBitWidth() / 8) * 2;
1599  std::string HexString = AI.toString(16, /*Signed=*/false);
1600  transform(HexString.begin(), HexString.end(), HexString.begin(), tolower);
1601  unsigned Size = HexString.size();
1602  assert(Width >= Size && "hex string is too large!");
1603  HexString.insert(HexString.begin(), Width - Size, '0');
1604 
1605  return HexString;
1606 }
1607 
1608 static std::string scalarConstantToHexString(const Constant *C) {
1609  Type *Ty = C->getType();
1610  if (isa<UndefValue>(C)) {
1612  } else if (const auto *CFP = dyn_cast<ConstantFP>(C)) {
1613  return APIntToHexString(CFP->getValueAPF().bitcastToAPInt());
1614  } else if (const auto *CI = dyn_cast<ConstantInt>(C)) {
1615  return APIntToHexString(CI->getValue());
1616  } else {
1617  unsigned NumElements;
1618  if (isa<VectorType>(Ty))
1619  NumElements = Ty->getVectorNumElements();
1620  else
1621  NumElements = Ty->getArrayNumElements();
1622  std::string HexString;
1623  for (int I = NumElements - 1, E = -1; I != E; --I)
1625  return HexString;
1626  }
1627 }
1628 
1630  const DataLayout &DL, SectionKind Kind, const Constant *C,
1631  unsigned &Align) const {
1632  if (Kind.isMergeableConst() && C &&
1634  // This creates comdat sections with the given symbol name, but unless
1635  // AsmPrinter::GetCPISymbol actually makes the symbol global, the symbol
1636  // will be created with a null storage class, which makes GNU binutils
1637  // error out.
1641  std::string COMDATSymName;
1642  if (Kind.isMergeableConst4()) {
1643  if (Align <= 4) {
1644  COMDATSymName = "__real@" + scalarConstantToHexString(C);
1645  Align = 4;
1646  }
1647  } else if (Kind.isMergeableConst8()) {
1648  if (Align <= 8) {
1649  COMDATSymName = "__real@" + scalarConstantToHexString(C);
1650  Align = 8;
1651  }
1652  } else if (Kind.isMergeableConst16()) {
1653  // FIXME: These may not be appropriate for non-x86 architectures.
1654  if (Align <= 16) {
1655  COMDATSymName = "__xmm@" + scalarConstantToHexString(C);
1656  Align = 16;
1657  }
1658  } else if (Kind.isMergeableConst32()) {
1659  if (Align <= 32) {
1660  COMDATSymName = "__ymm@" + scalarConstantToHexString(C);
1661  Align = 32;
1662  }
1663  }
1664 
1665  if (!COMDATSymName.empty())
1666  return getContext().getCOFFSection(".rdata", Characteristics, Kind,
1667  COMDATSymName,
1669  }
1670 
1671  return TargetLoweringObjectFile::getSectionForConstant(DL, Kind, C, Align);
1672 }
1673 
1674 
1675 //===----------------------------------------------------------------------===//
1676 // Wasm
1677 //===----------------------------------------------------------------------===//
1678 
1679 static const Comdat *getWasmComdat(const GlobalValue *GV) {
1680  const Comdat *C = GV->getComdat();
1681  if (!C)
1682  return nullptr;
1683 
1684  if (C->getSelectionKind() != Comdat::Any)
1685  report_fatal_error("WebAssembly COMDATs only support "
1686  "SelectionKind::Any, '" + C->getName() + "' cannot be "
1687  "lowered.");
1688 
1689  return C;
1690 }
1691 
1693  // If we're told we have function data, then use that.
1694  if (K.isText())
1695  return SectionKind::getText();
1696 
1697  // Otherwise, ignore whatever section type the generic impl detected and use
1698  // a plain data section.
1699  return SectionKind::getData();
1700 }
1701 
1703  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1704  // We don't support explict section names for functions in the wasm object
1705  // format. Each function has to be in its own unique section.
1706  if (isa<Function>(GO)) {
1707  return SelectSectionForGlobal(GO, Kind, TM);
1708  }
1709 
1710  StringRef Name = GO->getSection();
1711 
1712  Kind = getWasmKindForNamedSection(Name, Kind);
1713 
1714  StringRef Group = "";
1715  if (const Comdat *C = getWasmComdat(GO)) {
1716  Group = C->getName();
1717  }
1718 
1720  getContext().getWasmSection(Name, Kind, Group,
1722 
1723  return Section;
1724 }
1725 
1727  MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
1728  const TargetMachine &TM, bool EmitUniqueSection, unsigned *NextUniqueID) {
1729  StringRef Group = "";
1730  if (const Comdat *C = getWasmComdat(GO)) {
1731  Group = C->getName();
1732  }
1733 
1734  bool UniqueSectionNames = TM.getUniqueSectionNames();
1736 
1737  if (const auto *F = dyn_cast<Function>(GO)) {
1738  const auto &OptionalPrefix = F->getSectionPrefix();
1739  if (OptionalPrefix)
1740  Name += *OptionalPrefix;
1741  }
1742 
1743  if (EmitUniqueSection && UniqueSectionNames) {
1744  Name.push_back('.');
1745  TM.getNameWithPrefix(Name, GO, Mang, true);
1746  }
1747  unsigned UniqueID = MCContext::GenericSectionID;
1748  if (EmitUniqueSection && !UniqueSectionNames) {
1749  UniqueID = *NextUniqueID;
1750  (*NextUniqueID)++;
1751  }
1752 
1753  return Ctx.getWasmSection(Name, Kind, Group, UniqueID);
1754 }
1755 
1757  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1758 
1759  if (Kind.isCommon())
1760  report_fatal_error("mergable sections not supported yet on wasm");
1761 
1762  // If we have -ffunction-section or -fdata-section then we should emit the
1763  // global value to a uniqued section specifically for it.
1764  bool EmitUniqueSection = false;
1765  if (Kind.isText())
1766  EmitUniqueSection = TM.getFunctionSections();
1767  else
1768  EmitUniqueSection = TM.getDataSections();
1769  EmitUniqueSection |= GO->hasComdat();
1770 
1771  return selectWasmSectionForGlobal(getContext(), GO, Kind, getMangler(), TM,
1772  EmitUniqueSection, &NextUniqueID);
1773 }
1774 
1776  bool UsesLabelDifference, const Function &F) const {
1777  // We can always create relative relocations, so use another section
1778  // that can be marked non-executable.
1779  return false;
1780 }
1781 
1783  const GlobalValue *LHS, const GlobalValue *RHS,
1784  const TargetMachine &TM) const {
1785  // We may only use a PLT-relative relocation to refer to unnamed_addr
1786  // functions.
1787  if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
1788  return nullptr;
1789 
1790  // Basic sanity checks.
1791  if (LHS->getType()->getPointerAddressSpace() != 0 ||
1792  RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
1793  RHS->isThreadLocal())
1794  return nullptr;
1795 
1796  return MCBinaryExpr::createSub(
1798  getContext()),
1800 }
1801 
1804  getContext().getWasmSection(".init_array", SectionKind::getData());
1805 
1806  // We don't use PersonalityEncoding and LSDAEncoding because we don't emit
1807  // .cfi directives. We use TTypeEncoding to encode typeinfo global variables.
1809 }
1810 
1812  unsigned Priority, const MCSymbol *KeySym) const {
1813  return Priority == UINT16_MAX ?
1815  getContext().getWasmSection(".init_array." + utostr(Priority),
1817 }
1818 
1820  unsigned Priority, const MCSymbol *KeySym) const {
1821  llvm_unreachable("@llvm.global_dtors should have been lowered already");
1822  return nullptr;
1823 }
1824 
1825 //===----------------------------------------------------------------------===//
1826 // XCOFF
1827 //===----------------------------------------------------------------------===//
1829  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1830  report_fatal_error("XCOFF explicit sections not yet implemented.");
1831 }
1832 
1834  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1835  assert(!TM.getFunctionSections() && !TM.getDataSections() &&
1836  "XCOFF unique sections not yet implemented.");
1837 
1838  // Common symbols go into a csect with matching name which will get mapped
1839  // into the .bss section.
1840  if (Kind.isBSSLocal() || Kind.isCommon()) {
1842  getNameWithPrefix(Name, GO, TM);
1845  return getContext().getXCOFFSection(
1847  SC, Kind, /* BeginSymbolName */ nullptr);
1848  }
1849 
1850  if (Kind.isText())
1851  return TextSection;
1852 
1853  if (Kind.isData())
1854  return DataSection;
1855 
1856  report_fatal_error("XCOFF other section types not yet implemented.");
1857 }
1858 
1860  bool UsesLabelDifference, const Function &F) const {
1861  report_fatal_error("TLOF XCOFF not yet implemented.");
1862 }
1863 
1865  const TargetMachine &TgtM) {
1867  TTypeEncoding = 0;
1868  PersonalityEncoding = 0;
1869  LSDAEncoding = 0;
1870 }
1871 
1873  unsigned Priority, const MCSymbol *KeySym) const {
1874  report_fatal_error("XCOFF ctor section not yet implemented.");
1875 }
1876 
1878  unsigned Priority, const MCSymbol *KeySym) const {
1879  report_fatal_error("XCOFF dtor section not yet implemented.");
1880 }
1881 
1883  const GlobalValue *LHS, const GlobalValue *RHS,
1884  const TargetMachine &TM) const {
1885  report_fatal_error("XCOFF not yet implemented.");
1886 }
1887 
1889  const GlobalObject *GO) {
1890  switch (GO->getLinkage()) {
1892  return XCOFF::C_HIDEXT;
1895  return XCOFF::C_EXT;
1897  return XCOFF::C_WEAKEXT;
1898  default:
1900  "Unhandled linkage when mapping linkage to StorageClass.");
1901  }
1902 }
const MCExpr * lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS, const TargetMachine &TM) const override
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:318
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:94
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:39
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:111
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
bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const override
MCSection * getStaticCtorSection(unsigned Priority, const MCSymbol *KeySym) const override
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:327
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:165
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:317
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:332
MCSection * getStaticDtorSection(unsigned Priority, const MCSymbol *KeySym) const override
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:270
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:124
MCSymbol * getCFIPersonalitySymbol(const GlobalValue *GV, const TargetMachine &TM, MachineModuleInfo *MMI) const override
MCSectionWasm * getWasmSection(const Twine &Section, SectionKind K)
Definition: MCContext.h:487
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM...
void Initialize(MCContext &Ctx, const TargetMachine &TM) override
This method must be called before any actual lowering is done.
Externally visible function.
Definition: GlobalValue.h:48
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:530
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
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
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
Read Write Data.
Definition: XCOFF.h:42
MCSection * getSectionForJumpTable(const Function &F, const TargetMachine &TM) const override
MCSection * getStaticCtorSection(unsigned Priority, const MCSymbol *KeySym) const override
unsigned getPointerABIAlignment(unsigned AS) const
Layout pointer alignment.
Definition: DataLayout.cpp:633
static bool isThumb(const MCSubtargetInfo &STI)
Tentative definitions.
Definition: GlobalValue.h:58
unsigned getTypeAndAttributes() const
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1517
MCSectionCOFF * getCOFFSection(StringRef Section, unsigned Characteristics, SectionKind Kind, StringRef COMDATSymName, int Selection, unsigned UniqueID=GenericSectionID, const char *BeginSymName=nullptr)
Definition: MCContext.cpp:434
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:474
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:480
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:140
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:65
bool hasExternalLinkage() const
Definition: GlobalValue.h:431
Key
PAL metadata keys.
bool isText() const
Definition: SectionKind.h:118
StorageClass
Definition: XCOFF.h:76
MCSectionXCOFF * getXCOFFSection(StringRef Section, XCOFF::StorageMappingClass MappingClass, XCOFF::SymbolType CSectType, XCOFF::StorageClass StorageClass, SectionKind K, const char *BeginSymName=nullptr)
Definition: MCContext.cpp:538
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
const MCExpr * getIndirectSymViaGOTPCRel(const GlobalValue *GV, const MCSymbol *Sym, const MCValue &MV, int64_t Offset, MachineModuleInfo *MMI, MCStreamer &Streamer) const override
Get MachO PC relative GOT entry relocation.
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:550
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:285
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.
LinkageTypes getLinkage() const
Definition: GlobalValue.h:460
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:465
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:130
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
Common csect definition. For uninitialized storage.
Definition: XCOFF.h:148
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:359
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...
ExternalWeak linkage description.
Definition: GlobalValue.h:57
.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:190
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:651
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
Pass this value as the UniqueID during section creation to get the generic section with the given nam...
Definition: MCContext.h:407
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)
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.
S_ATTR_NO_DEAD_STRIP - No dead stripping.
Definition: MachO.h:189
const MCExpr * lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS, const TargetMachine &TM) const override
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:40
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)
BSS class (uninitialized static internal)
Definition: XCOFF.h:48
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:340
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
CHAIN = SC CHAIN, Imm128 - System call.
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.
const Comdat * getComdat() const
Definition: Globals.cpp:175
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:104
bool isReadOnly() const
Definition: SectionKind.h:122
MachineModuleInfoELF - This is a MachineModuleInfoImpl implementation for ELF targets.
const Comdat * getComdat() const
Definition: GlobalObject.h:105
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:448
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
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
Rename collisions when linking (static functions).
Definition: GlobalValue.h:55
const Module * getModule() const
MachineModuleInfoMachO - This is a MachineModuleInfoImpl implementation for MachO targets...
OutputIt transform(R &&Range, OutputIt d_first, UnaryPredicate P)
Wrapper function around std::transform to apply a function to a range and store the result elsewhere...
Definition: STLExtras.h:1247
const GlobalObject * getBaseObject() const
Definition: Globals.cpp:286
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:503
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:424
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:265
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:399
ExceptionHandling getExceptionHandlingType() const
Definition: MCAsmInfo.h:584
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:761
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
void toString(SmallVectorImpl< char > &Str, unsigned Radix, bool Signed, bool formatAsCLiteral=false) const
Converts an APInt to a string and append it to Str.
Definition: APInt.cpp:2103
const uint64_t Version
Definition: InstrProf.h:984
static unsigned getELFSectionType(StringRef Name, SectionKind K)
static XCOFF::StorageClass getStorageClassForGlobal(const GlobalObject *GO)
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:277
This class contains meta information specific to a module.
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...
SelectionKind getSelectionKind() const
Definition: Comdat.h:44
static SectionKind getText()
Definition: SectionKind.h:179
bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const override