LLVM  3.7.0
MCObjectFileInfo.cpp
Go to the documentation of this file.
1 //===-- MObjectFileInfo.cpp - Object File Information ---------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
11 #include "llvm/ADT/StringExtras.h"
12 #include "llvm/ADT/Triple.h"
13 #include "llvm/MC/MCAsmInfo.h"
14 #include "llvm/MC/MCContext.h"
15 #include "llvm/MC/MCSection.h"
16 #include "llvm/MC/MCSectionCOFF.h"
17 #include "llvm/MC/MCSectionELF.h"
18 #include "llvm/MC/MCSectionMachO.h"
19 using namespace llvm;
20 
21 static bool useCompactUnwind(const Triple &T) {
22  // Only on darwin.
23  if (!T.isOSDarwin())
24  return false;
25 
26  // aarch64 always has it.
27  if (T.getArch() == Triple::aarch64)
28  return true;
29 
30  // Use it on newer version of OS X.
31  if (T.isMacOSX() && !T.isMacOSXVersionLT(10, 6))
32  return true;
33 
34  // And the iOS simulator.
35  if (T.isiOS() &&
36  (T.getArch() == Triple::x86_64 || T.getArch() == Triple::x86))
37  return true;
38 
39  return false;
40 }
41 
42 void MCObjectFileInfo::initMachOMCObjectFileInfo(Triple T) {
43  // MachO
45 
46  if (T.isOSDarwin() && T.getArch() == Triple::aarch64)
48 
54 
55  // .comm doesn't support alignment before Leopard.
56  if (T.isMacOSX() && T.isMacOSXVersionLT(10, 5))
58 
59  TextSection // .text
60  = Ctx->getMachOSection("__TEXT", "__text",
63  DataSection // .data
64  = Ctx->getMachOSection("__DATA", "__data", 0,
66 
67  // BSSSection might not be expected initialized on msvc.
68  BSSSection = nullptr;
69 
70  TLSDataSection // .tdata
71  = Ctx->getMachOSection("__DATA", "__thread_data",
74  TLSBSSSection // .tbss
75  = Ctx->getMachOSection("__DATA", "__thread_bss",
78 
79  // TODO: Verify datarel below.
80  TLSTLVSection // .tlv
81  = Ctx->getMachOSection("__DATA", "__thread_vars",
84 
86  = Ctx->getMachOSection("__DATA", "__thread_init",
89 
90  CStringSection // .cstring
91  = Ctx->getMachOSection("__TEXT", "__cstring",
95  = Ctx->getMachOSection("__TEXT","__ustring", 0,
97  FourByteConstantSection // .literal4
98  = Ctx->getMachOSection("__TEXT", "__literal4",
101  EightByteConstantSection // .literal8
102  = Ctx->getMachOSection("__TEXT", "__literal8",
105 
106  SixteenByteConstantSection // .literal16
107  = Ctx->getMachOSection("__TEXT", "__literal16",
110 
111  ReadOnlySection // .const
112  = Ctx->getMachOSection("__TEXT", "__const", 0,
114 
116  = Ctx->getMachOSection("__TEXT", "__textcoal_nt",
121  = Ctx->getMachOSection("__TEXT", "__const_coal",
124  ConstDataSection // .const_data
125  = Ctx->getMachOSection("__DATA", "__const", 0,
128  = Ctx->getMachOSection("__DATA","__datacoal_nt",
132  = Ctx->getMachOSection("__DATA","__common",
136  = Ctx->getMachOSection("__DATA","__bss", MachO::S_ZEROFILL,
138 
139 
141  = Ctx->getMachOSection("__DATA", "__la_symbol_ptr",
145  = Ctx->getMachOSection("__DATA", "__nl_symbol_ptr",
148 
149  if (RelocM == Reloc::Static) {
151  = Ctx->getMachOSection("__TEXT", "__constructor", 0,
154  = Ctx->getMachOSection("__TEXT", "__destructor", 0,
156  } else {
158  = Ctx->getMachOSection("__DATA", "__mod_init_func",
162  = Ctx->getMachOSection("__DATA", "__mod_term_func",
165  }
166 
167  // Exception Handling.
168  LSDASection = Ctx->getMachOSection("__TEXT", "__gcc_except_tab", 0,
170 
171  COFFDebugSymbolsSection = nullptr;
172 
173  if (useCompactUnwind(T)) {
175  Ctx->getMachOSection("__LD", "__compact_unwind", MachO::S_ATTR_DEBUG,
177 
178  if (T.getArch() == Triple::x86_64 || T.getArch() == Triple::x86)
179  CompactUnwindDwarfEHFrameOnly = 0x04000000;
180  else if (T.getArch() == Triple::aarch64)
181  CompactUnwindDwarfEHFrameOnly = 0x03000000;
182  }
183 
184  // Debug Information.
186  Ctx->getMachOSection("__DWARF", "__apple_names", MachO::S_ATTR_DEBUG,
187  SectionKind::getMetadata(), "names_begin");
189  Ctx->getMachOSection("__DWARF", "__apple_objc", MachO::S_ATTR_DEBUG,
190  SectionKind::getMetadata(), "objc_begin");
191  // 16 character section limit...
193  Ctx->getMachOSection("__DWARF", "__apple_namespac", MachO::S_ATTR_DEBUG,
194  SectionKind::getMetadata(), "namespac_begin");
196  Ctx->getMachOSection("__DWARF", "__apple_types", MachO::S_ATTR_DEBUG,
197  SectionKind::getMetadata(), "types_begin");
198 
200  Ctx->getMachOSection("__DWARF", "__debug_abbrev", MachO::S_ATTR_DEBUG,
201  SectionKind::getMetadata(), "section_abbrev");
203  Ctx->getMachOSection("__DWARF", "__debug_info", MachO::S_ATTR_DEBUG,
204  SectionKind::getMetadata(), "section_info");
206  Ctx->getMachOSection("__DWARF", "__debug_line", MachO::S_ATTR_DEBUG,
207  SectionKind::getMetadata(), "section_line");
209  Ctx->getMachOSection("__DWARF", "__debug_frame", MachO::S_ATTR_DEBUG,
212  Ctx->getMachOSection("__DWARF", "__debug_pubnames", MachO::S_ATTR_DEBUG,
215  Ctx->getMachOSection("__DWARF", "__debug_pubtypes", MachO::S_ATTR_DEBUG,
218  Ctx->getMachOSection("__DWARF", "__debug_gnu_pubn", MachO::S_ATTR_DEBUG,
221  Ctx->getMachOSection("__DWARF", "__debug_gnu_pubt", MachO::S_ATTR_DEBUG,
224  Ctx->getMachOSection("__DWARF", "__debug_str", MachO::S_ATTR_DEBUG,
225  SectionKind::getMetadata(), "info_string");
227  Ctx->getMachOSection("__DWARF", "__debug_loc", MachO::S_ATTR_DEBUG,
228  SectionKind::getMetadata(), "section_debug_loc");
230  Ctx->getMachOSection("__DWARF", "__debug_aranges", MachO::S_ATTR_DEBUG,
233  Ctx->getMachOSection("__DWARF", "__debug_ranges", MachO::S_ATTR_DEBUG,
234  SectionKind::getMetadata(), "debug_range");
236  Ctx->getMachOSection("__DWARF", "__debug_inlined", MachO::S_ATTR_DEBUG,
238  StackMapSection = Ctx->getMachOSection("__LLVM_STACKMAPS", "__llvm_stackmaps",
240 
241  FaultMapSection = Ctx->getMachOSection("__LLVM_FAULTMAPS", "__llvm_faultmaps",
243 
245 }
246 
247 void MCObjectFileInfo::initELFMCObjectFileInfo(Triple T) {
248  switch (T.getArch()) {
249  case Triple::mips:
250  case Triple::mipsel:
252  break;
253  case Triple::mips64:
254  case Triple::mips64el:
256  break;
257  case Triple::x86_64:
261 
262  break;
263  default:
265  break;
266  }
267 
268  switch (T.getArch()) {
269  case Triple::arm:
270  case Triple::armeb:
271  case Triple::thumb:
272  case Triple::thumbeb:
274  break;
275  // Fallthrough if not using EHABI
276  case Triple::ppc:
277  case Triple::x86:
278  PersonalityEncoding = (RelocM == Reloc::PIC_)
281  LSDAEncoding = (RelocM == Reloc::PIC_)
284  TTypeEncoding = (RelocM == Reloc::PIC_)
287  break;
288  case Triple::x86_64:
289  if (RelocM == Reloc::PIC_) {
291  ((CMModel == CodeModel::Small || CMModel == CodeModel::Medium)
294  (CMModel == CodeModel::Small
297  ((CMModel == CodeModel::Small || CMModel == CodeModel::Medium)
298  ? dwarf::DW_EH_PE_sdata4 : dwarf::DW_EH_PE_sdata8);
299  } else {
301  (CMModel == CodeModel::Small || CMModel == CodeModel::Medium)
303  LSDAEncoding = (CMModel == CodeModel::Small)
305  TTypeEncoding = (CMModel == CodeModel::Small)
307  }
308  break;
309  case Triple::aarch64:
310  case Triple::aarch64_be:
311  // The small model guarantees static code/data size < 4GB, but not where it
312  // will be in memory. Most of these could end up >2GB away so even a signed
313  // pc-relative 32-bit address is insufficient, theoretically.
314  if (RelocM == Reloc::PIC_) {
320  } else {
324  }
325  break;
326  case Triple::mips:
327  case Triple::mipsel:
328  case Triple::mips64:
329  case Triple::mips64el:
330  // MIPS uses indirect pointer to refer personality functions and types, so
331  // that the eh_frame section can be read-only. DW.ref.personality will be
332  // generated for relocation.
334  // FIXME: The N64 ABI probably ought to use DW_EH_PE_sdata8 but we can't
335  // identify N64 from just a triple.
338  // We don't support PC-relative LSDA references in GAS so we use the default
339  // DW_EH_PE_absptr for those.
340  break;
341  case Triple::ppc64:
342  case Triple::ppc64le:
348  break;
349  case Triple::sparcel:
350  case Triple::sparc:
351  if (RelocM == Reloc::PIC_) {
357  } else {
361  }
362  break;
363  case Triple::sparcv9:
365  if (RelocM == Reloc::PIC_) {
370  } else {
373  }
374  break;
375  case Triple::systemz:
376  // All currently-defined code models guarantee that 4-byte PC-relative
377  // values will be in range.
378  if (RelocM == Reloc::PIC_) {
384  } else {
388  }
389  break;
390  default:
391  break;
392  }
393 
394  // Solaris requires different flags for .eh_frame to seemingly every other
395  // platform.
398  if (T.isOSSolaris()) {
399  if (T.getArch() == Triple::x86_64)
401  else
403  }
404 
405 
406  // ELF
409 
412 
415 
418 
420  Ctx->getELFSection(".tdata", ELF::SHT_PROGBITS,
422 
425 
426  DataRelSection = Ctx->getELFSection(".data.rel", ELF::SHT_PROGBITS,
428 
429  DataRelLocalSection = Ctx->getELFSection(".data.rel.local", ELF::SHT_PROGBITS,
431 
432  DataRelROSection = Ctx->getELFSection(".data.rel.ro", ELF::SHT_PROGBITS,
434 
436  ".data.rel.ro.local", ELF::SHT_PROGBITS, ELF::SHF_ALLOC | ELF::SHF_WRITE);
437 
439  Ctx->getELFSection(".rodata.cst4", ELF::SHT_PROGBITS,
440  ELF::SHF_ALLOC | ELF::SHF_MERGE, 4, "");
441 
443  Ctx->getELFSection(".rodata.cst8", ELF::SHT_PROGBITS,
444  ELF::SHF_ALLOC | ELF::SHF_MERGE, 8, "");
445 
447  Ctx->getELFSection(".rodata.cst16", ELF::SHT_PROGBITS,
448  ELF::SHF_ALLOC | ELF::SHF_MERGE, 16, "");
449 
452 
455 
456  // Exception Handling Sections.
457 
458  // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
459  // it contains relocatable pointers. In PIC mode, this is probably a big
460  // runtime hit for C++ apps. Either the contents of the LSDA need to be
461  // adjusted or this should be a data section.
462  LSDASection = Ctx->getELFSection(".gcc_except_table", ELF::SHT_PROGBITS,
464 
465  COFFDebugSymbolsSection = nullptr;
466 
467  // Debug Info Sections.
468  DwarfAbbrevSection = Ctx->getELFSection(".debug_abbrev", ELF::SHT_PROGBITS, 0,
469  "section_abbrev");
471  Ctx->getELFSection(".debug_info", ELF::SHT_PROGBITS, 0, "section_info");
472  DwarfLineSection = Ctx->getELFSection(".debug_line", ELF::SHT_PROGBITS, 0);
473  DwarfFrameSection = Ctx->getELFSection(".debug_frame", ELF::SHT_PROGBITS, 0);
475  Ctx->getELFSection(".debug_pubnames", ELF::SHT_PROGBITS, 0);
477  Ctx->getELFSection(".debug_pubtypes", ELF::SHT_PROGBITS, 0);
479  Ctx->getELFSection(".debug_gnu_pubnames", ELF::SHT_PROGBITS, 0);
481  Ctx->getELFSection(".debug_gnu_pubtypes", ELF::SHT_PROGBITS, 0);
483  Ctx->getELFSection(".debug_str", ELF::SHT_PROGBITS,
485  DwarfLocSection = Ctx->getELFSection(".debug_loc", ELF::SHT_PROGBITS, 0);
487  Ctx->getELFSection(".debug_aranges", ELF::SHT_PROGBITS, 0);
489  Ctx->getELFSection(".debug_ranges", ELF::SHT_PROGBITS, 0, "debug_range");
490 
491  // DWARF5 Experimental Debug Info
492 
493  // Accelerator Tables
495  Ctx->getELFSection(".apple_names", ELF::SHT_PROGBITS, 0, "names_begin");
497  Ctx->getELFSection(".apple_objc", ELF::SHT_PROGBITS, 0, "objc_begin");
499  ".apple_namespaces", ELF::SHT_PROGBITS, 0, "namespac_begin");
501  Ctx->getELFSection(".apple_types", ELF::SHT_PROGBITS, 0, "types_begin");
502 
503  // Fission Sections
505  Ctx->getELFSection(".debug_info.dwo", ELF::SHT_PROGBITS, 0);
507  Ctx->getELFSection(".debug_types.dwo", ELF::SHT_PROGBITS, 0);
509  Ctx->getELFSection(".debug_abbrev.dwo", ELF::SHT_PROGBITS, 0);
511  Ctx->getELFSection(".debug_str.dwo", ELF::SHT_PROGBITS,
514  Ctx->getELFSection(".debug_line.dwo", ELF::SHT_PROGBITS, 0);
516  Ctx->getELFSection(".debug_loc.dwo", ELF::SHT_PROGBITS, 0, "skel_loc");
518  Ctx->getELFSection(".debug_str_offsets.dwo", ELF::SHT_PROGBITS, 0);
520  Ctx->getELFSection(".debug_addr", ELF::SHT_PROGBITS, 0, "addr_sec");
521 
523  Ctx->getELFSection(".llvm_stackmaps", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
524 
526  Ctx->getELFSection(".llvm_faultmaps", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
527 }
528 
529 void MCObjectFileInfo::initCOFFMCObjectFileInfo(Triple T) {
530  bool IsWoA = T.getArch() == Triple::arm || T.getArch() == Triple::thumb;
531 
533 
534  // COFF
535  BSSSection = Ctx->getCOFFSection(
540  ".text",
552 
562  } else {
571  }
572 
573  // FIXME: We're emitting LSDA info into a readonly section on COFF, even
574  // though it contains relocatable pointers. In PIC mode, this is probably a
575  // big runtime hit for C++ apps. Either the contents of the LSDA need to be
576  // adjusted or this should be a data section.
577  assert(T.isOSWindows() && "Windows is the only supported COFF target");
578  if (T.getArch() == Triple::x86_64) {
579  // On Windows 64 with SEH, the LSDA is emitted into the .xdata section
580  LSDASection = 0;
581  } else {
582  LSDASection = Ctx->getCOFFSection(".gcc_except_table",
586  }
587 
588  // Debug info.
594 
596  ".debug_abbrev",
599  SectionKind::getMetadata(), "section_abbrev");
601  ".debug_info",
604  SectionKind::getMetadata(), "section_info");
606  ".debug_line",
609  SectionKind::getMetadata(), "section_line");
610 
612  ".debug_frame",
617  ".debug_pubnames",
622  ".debug_pubtypes",
627  ".debug_gnu_pubnames",
632  ".debug_gnu_pubtypes",
637  ".debug_str",
640  SectionKind::getMetadata(), "info_string");
642  ".debug_loc",
645  SectionKind::getMetadata(), "section_debug_loc");
647  ".debug_aranges",
652  ".debug_ranges",
655  SectionKind::getMetadata(), "debug_range");
657  ".debug_info.dwo",
660  SectionKind::getMetadata(), "section_info_dwo");
662  ".debug_types.dwo",
665  SectionKind::getMetadata(), "section_types_dwo");
667  ".debug_abbrev.dwo",
670  SectionKind::getMetadata(), "section_abbrev_dwo");
672  ".debug_str.dwo",
675  SectionKind::getMetadata(), "skel_string");
677  ".debug_line.dwo",
682  ".debug_loc.dwo",
685  SectionKind::getMetadata(), "skel_loc");
687  ".debug_str_offsets.dwo",
692  ".debug_addr",
695  SectionKind::getMetadata(), "addr_sec");
697  ".apple_names",
700  SectionKind::getMetadata(), "names_begin");
702  ".apple_namespaces",
705  SectionKind::getMetadata(), "namespac_begin");
707  ".apple_types",
710  SectionKind::getMetadata(), "types_begin");
712  ".apple_objc",
715  SectionKind::getMetadata(), "objc_begin");
716 
720 
724 
728 
731 
736 
737  StackMapSection = Ctx->getCOFFSection(".llvm_stackmaps",
741 }
742 
744  Reloc::Model relocm,
745  CodeModel::Model cm,
746  MCContext &ctx) {
747  RelocM = relocm;
748  CMModel = cm;
749  Ctx = &ctx;
750 
751  // Common.
755 
758 
760 
761  EHFrameSection = nullptr; // Created on demand.
762  CompactUnwindSection = nullptr; // Used only by selected targets.
763  DwarfAccelNamesSection = nullptr; // Used only by selected targets.
764  DwarfAccelObjCSection = nullptr; // Used only by selected targets.
765  DwarfAccelNamespaceSection = nullptr; // Used only by selected targets.
766  DwarfAccelTypesSection = nullptr; // Used only by selected targets.
767 
768  TT = TheTriple;
769 
770  Triple::ArchType Arch = TT.getArch();
771  // FIXME: Checking for Arch here to filter out bogus triples such as
772  // cellspu-apple-darwin. Perhaps we should fix in Triple?
773  if ((Arch == Triple::x86 || Arch == Triple::x86_64 ||
774  Arch == Triple::arm || Arch == Triple::thumb ||
775  Arch == Triple::aarch64 ||
776  Arch == Triple::ppc || Arch == Triple::ppc64 ||
777  Arch == Triple::UnknownArch) &&
778  TT.isOSBinFormatMachO()) {
779  Env = IsMachO;
780  initMachOMCObjectFileInfo(TT);
781  } else if ((Arch == Triple::x86 || Arch == Triple::x86_64 ||
782  Arch == Triple::arm || Arch == Triple::thumb) &&
783  (TT.isOSWindows() && TT.getObjectFormat() == Triple::COFF)) {
784  Env = IsCOFF;
785  initCOFFMCObjectFileInfo(TT);
786  } else {
787  Env = IsELF;
788  initELFMCObjectFileInfo(TT);
789  }
790 }
791 
793  CodeModel::Model CM,
794  MCContext &ctx) {
795  InitMCObjectFileInfo(Triple(TT), RM, CM, ctx);
796 }
797 
799  return Ctx->getELFSection(".debug_types", ELF::SHT_PROGBITS, ELF::SHF_GROUP,
800  0, utostr(Hash));
801 }
802 
803 void MCObjectFileInfo::InitEHFrameSection() {
804  if (Env == IsMachO)
806  Ctx->getMachOSection("__TEXT", "__eh_frame",
812  else if (Env == IsELF)
814  Ctx->getELFSection(".eh_frame", EHSectionType, EHSectionFlags);
815  else
817  Ctx->getCOFFSection(".eh_frame",
822 }
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:48
MCSection * MergeableConst4Section
S_NON_LAZY_SYMBOL_POINTERS - Section with non-lazy symbol pointers.
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:225
bool isOSBinFormatMachO() const
Tests whether the environment is MachO.
Definition: Triple.h:489
MCSection * DwarfPubTypesSection
MCSection * DwarfGnuPubTypesSection
Section for newer gnu pubtypes.
MCSection * StackMapSection
StackMap section.
MCSection * SixteenByteConstantSection
MCSectionELF * getELFSection(StringRef Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:311
unsigned PersonalityEncoding
Some encoding values for EH.
MCSection * TextSection
Section directive for standard text.
static SectionKind getDataRel()
Definition: SectionKind.h:227
MCSection * ConstTextCoalSection
MCSection * LazySymbolPointerSection
static SectionKind getMergeableConst8()
Definition: SectionKind.h:219
static SectionKind getMergeableConst16()
Definition: SectionKind.h:220
static SectionKind getMergeable1ByteCString()
Definition: SectionKind.h:209
S_THREAD_LOCAL_VARIABLES - Section with thread local variable structure data.
setjmp/longjmp based exceptions
MCSection * getDwarfTypesSection(uint64_t Hash) const
static SectionKind getMergeableConst4()
Definition: SectionKind.h:218
static bool useCompactUnwind(const Triple &T)
bool isOSWindows() const
Tests whether the OS is Windows.
Definition: Triple.h:464
bool isMacOSX() const
isMacOSX - Is this a Mac OS X triple.
Definition: Triple.h:394
S_4BYTE_LITERALS - Section with 4 byte literals.
static SectionKind getBSS()
Definition: SectionKind.h:223
MCSection * MergeableConst16Section
MCSection * DwarfPubNamesSection
S_8BYTE_LITERALS - Section with 8 byte literals.
MCSection * StaticDtorSection
This section contains the static destructor pointer list.
ObjectFormatType getObjectFormat() const
getFormat - Get the object format for this triple.
Definition: Triple.h:272
MCSection * EightByteConstantSection
S_MOD_TERM_FUNC_POINTERS - Section with only function pointers for termination.
MCSection * TLSDataSection
Section directive for Thread Local data. ELF, MachO and COFF.
Context object for machine code objects.
Definition: MCContext.h:48
unsigned isMacOSXVersionLT(unsigned Major, unsigned Minor=0, unsigned Micro=0) const
isMacOSXVersionLT - Comparison function for checking OS X version compatibility, which handles suppor...
Definition: Triple.h:379
const MCSection * DwarfDebugInlineSection
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:271
MCSection * DrectveSection
COFF specific sections.
static std::string utostr(uint64_t X, bool isNeg=false)
Definition: StringExtras.h:93
MCSection * DwarfAccelNamesSection
DWARF5 Experimental Debug Info Sections DwarfAccelNamesSection, DwarfAccelObjCSection, DwarfAccelNamespaceSection, DwarfAccelTypesSection - If we use the DWARF accelerated hash tables then we want to emit these sections.
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:242
MCSection * DataSection
Section directive for standard data.
bool isiOS() const
Is this an iOS triple.
Definition: Triple.h:399
S_ATTR_STRIP_STATIC_SYMS - Ok to strip static symbols in this section in files with the MY_DYLDLINK f...
S_ATTR_PURE_INSTRUCTIONS - Section contains only true machine instructions.
MCSection * TLSTLVSection
Section for thread local structure information.
S_THREAD_LOCAL_ZEROFILL - Thread local zerofill section.
const MCSection * DataRelLocalSection
MCSection * DwarfAccelNamespaceSection
ExceptionHandling getExceptionHandlingType() const
Definition: MCAsmInfo.h:511
S_THREAD_LOCAL_REGULAR - Thread local data section.
bool SupportsCompactUnwindWithoutEHFrame
True if the target object file supports emitting a compact unwind section without an associated EH fr...
S_CSTRING_LITERALS - Section with literal C strings.
bool CommDirectiveSupportsAlignment
True if .comm supports alignment.
S_ATTR_LIVE_SUPPORT - Blocks are live if they reference live blocks.
MCSection * DataRelROLocalSection
MCSection * StaticCtorSection
This section contains the static constructor pointer list.
bool isOSSolaris() const
Definition: Triple.h:422
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
MCSection * COFFDebugSymbolsSection
MCSection * DwarfAbbrevSection
bool isOSDarwin() const
isOSDarwin - Is this a "Darwin" OS (OS X or iOS).
Definition: Triple.h:404
MCSection * EHFrameSection
EH frame section.
S_LAZY_SYMBOL_POINTERS - Section with lazy symbol pointers.
MCSection * DwarfTypesDWOSection
static SectionKind getThreadBSS()
Definition: SectionKind.h:221
MCSection * DwarfRangesSection
static SectionKind getMetadata()
Definition: SectionKind.h:206
static SectionKind getReadOnlyWithRel()
Definition: SectionKind.h:230
MCSection * DwarfARangesSection
MCSection * CompactUnwindSection
If exception handling is supported by the target and the target can support a compact representation ...
MCSection * DwarfAccelTypesSection
S_THREAD_LOCAL_INIT_FUNCTION_POINTERS - Section with thread local variable initialization pointers to...
MCSection * DwarfStrOffDWOSection
S_16BYTE_LITERALS - Section with only 16 byte literals.
void InitMCObjectFileInfo(const Triple &TT, Reloc::Model RM, CodeModel::Model CM, MCContext &ctx)
MCSection * DwarfGnuPubNamesSection
Section for newer gnu pubnames.
MCSection * DwarfAbbrevDWOSection
MCSection * FaultMapSection
FaultMap section.
MCSection * FourByteConstantSection
static SectionKind getMergeable2ByteCString()
Definition: SectionKind.h:212
MCSection * LSDASection
If exception handling is supported by the target, this is the section the Language Specific Data Area...
MCSection * TLSExtraDataSection
Extra TLS Variable Data section.
unsigned CompactUnwindDwarfEHFrameOnly
Compact unwind encoding indicating that we should emit only an EH frame.
S_ATTR_DEBUG - A debug section.
MCSection * DwarfAccelObjCSection
MCSectionCOFF * getCOFFSection(StringRef Section, unsigned Characteristics, SectionKind Kind, StringRef COMDATSymName, int Selection, const char *BeginSymName=nullptr)
Definition: MCContext.cpp:383
S_COALESCED - Section contains symbols that are to be coalesced.
MCSection * TLSBSSSection
Section directive for Thread Local uninitialized data.
MCSection * NonLazySymbolPointerSection
const MCSection * TLSThreadInitSection
Section for thread local data initialization functions.
unsigned EHSectionType
Section flags for eh_frame.
bool isKnownWindowsMSVCEnvironment() const
Definition: Triple.h:436
bool isWindowsItaniumEnvironment() const
Definition: Triple.h:440
bool SupportsWeakOmittedEHFrame
True if target object file supports a weak_definition of constant 0 for an omitted EH frame...
std::string Hash(const Unit &U)
Definition: FuzzerUtil.cpp:39
MCSection * BSSSection
Section that is default initialized to zero.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
MCSection * ReadOnlySection
Section that is readonly and can contain arbitrary initialized data.
S_ZEROFILL - Zero fill on demand section.
S_MOD_INIT_FUNC_POINTERS - Section with only function pointers for initialization.
static SectionKind getReadOnly()
Definition: SectionKind.h:208
S_ATTR_NO_TOC - Section contains coalesced symbols that are not to be in a ranlib table of contents...
static SectionKind getText()
Definition: SectionKind.h:207
MCSection * MergeableConst8Section