llvm/lib/MC/MCObjectFileInfo.cpp

   1 //===-- MCObjectFileInfo.cpp - Object File Information --------------------===//
   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 #include "llvm/MC/MCObjectFileInfo.h"
  10 #include "llvm/ADT/StringExtras.h"
  11 #include "llvm/BinaryFormat/COFF.h"
  12 #include "llvm/BinaryFormat/ELF.h"
  13 #include "llvm/BinaryFormat/Wasm.h"
  14 #include "llvm/MC/MCAsmInfo.h"
  15 #include "llvm/MC/MCContext.h"
  16 #include "llvm/MC/MCSection.h"
  17 #include "llvm/MC/MCSectionCOFF.h"
  18 #include "llvm/MC/MCSectionDXContainer.h"
  19 #include "llvm/MC/MCSectionELF.h"
  20 #include "llvm/MC/MCSectionGOFF.h"
  21 #include "llvm/MC/MCSectionMachO.h"
  22 #include "llvm/MC/MCSectionSPIRV.h"
  23 #include "llvm/MC/MCSectionWasm.h"
  24 #include "llvm/MC/MCSectionXCOFF.h"
  25 #include "llvm/Support/Casting.h"
  26 #include "llvm/TargetParser/Triple.h"
  27
  28 using namespace llvm;
  29
  30 static bool useCompactUnwind(const Triple &T) {
  31   // Only on darwin.
  32   if (!T.isOSDarwin())
  33     return false;
  34
  35   // aarch64 always has it.
  36   if (T.getArch() == Triple::aarch64 || T.getArch() == Triple::aarch64_32)
  37     return true;
  38
  39   // armv7k always has it.
  40   if (T.isWatchABI())
  41     return true;
  42
  43   // Use it on newer version of OS X.
  44   if (T.isMacOSX() && !T.isMacOSXVersionLT(10, 6))
  45     return true;
  46
  47   // And the iOS simulator.
  48   if (T.isiOS() && T.isX86())
  49     return true;
  50
  51   // The rest of the simulators always have it.
  52   if (T.isSimulatorEnvironment())
  53     return true;
  54
  55   // XROS always has it.
  56   if (T.isXROS())
  57     return true;
  58
  59   return false;
  60 }
  61
  62 void MCObjectFileInfo::initMachOMCObjectFileInfo(const Triple &T) {
  63   // MachO
  64   SupportsWeakOmittedEHFrame = false;
  65
  66   EHFrameSection = Ctx->getMachOSection(
  67       "__TEXT", "__eh_frame",
  68       MachO::S_COALESCED | MachO::S_ATTR_NO_TOC |
  69           MachO::S_ATTR_STRIP_STATIC_SYMS | MachO::S_ATTR_LIVE_SUPPORT,
  70       SectionKind::getReadOnly());
  71
  72   if (T.isOSDarwin() &&
  73       (T.getArch() == Triple::aarch64 || T.getArch() == Triple::aarch64_32 ||
  74       T.isSimulatorEnvironment()))
  75     SupportsCompactUnwindWithoutEHFrame = true;
  76
  77   switch (Ctx->emitDwarfUnwindInfo()) {
  78   case EmitDwarfUnwindType::Always:
  79     OmitDwarfIfHaveCompactUnwind = false;
  80     break;
  81   case EmitDwarfUnwindType::NoCompactUnwind:
  82     OmitDwarfIfHaveCompactUnwind = true;
  83     break;
  84   case EmitDwarfUnwindType::Default:
  85     OmitDwarfIfHaveCompactUnwind =
  86         T.isWatchABI() || SupportsCompactUnwindWithoutEHFrame;
  87     break;
  88   }
  89
  90   FDECFIEncoding = dwarf::DW_EH_PE_pcrel;
  91
  92   TextSection // .text
  93     = Ctx->getMachOSection("__TEXT", "__text",
  94                            MachO::S_ATTR_PURE_INSTRUCTIONS,
  95                            SectionKind::getText());
  96   DataSection // .data
  97       = Ctx->getMachOSection("__DATA", "__data", 0, SectionKind::getData());
  98
  99   // BSSSection might not be expected initialized on msvc.
 100   BSSSection = nullptr;
 101
 102   TLSDataSection // .tdata
 103       = Ctx->getMachOSection("__DATA", "__thread_data",
 104                              MachO::S_THREAD_LOCAL_REGULAR,
 105                              SectionKind::getData());
 106   TLSBSSSection // .tbss
 107     = Ctx->getMachOSection("__DATA", "__thread_bss",
 108                            MachO::S_THREAD_LOCAL_ZEROFILL,
 109                            SectionKind::getThreadBSS());
 110
 111   // TODO: Verify datarel below.
 112   TLSTLVSection // .tlv
 113       = Ctx->getMachOSection("__DATA", "__thread_vars",
 114                              MachO::S_THREAD_LOCAL_VARIABLES,
 115                              SectionKind::getData());
 116
 117   TLSThreadInitSection = Ctx->getMachOSection(
 118       "__DATA", "__thread_init", MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS,
 119       SectionKind::getData());
 120
 121   CStringSection // .cstring
 122     = Ctx->getMachOSection("__TEXT", "__cstring",
 123                            MachO::S_CSTRING_LITERALS,
 124                            SectionKind::getMergeable1ByteCString());
 125   UStringSection
 126     = Ctx->getMachOSection("__TEXT","__ustring", 0,
 127                            SectionKind::getMergeable2ByteCString());
 128   FourByteConstantSection // .literal4
 129     = Ctx->getMachOSection("__TEXT", "__literal4",
 130                            MachO::S_4BYTE_LITERALS,
 131                            SectionKind::getMergeableConst4());
 132   EightByteConstantSection // .literal8
 133     = Ctx->getMachOSection("__TEXT", "__literal8",
 134                            MachO::S_8BYTE_LITERALS,
 135                            SectionKind::getMergeableConst8());
 136
 137   SixteenByteConstantSection // .literal16
 138       = Ctx->getMachOSection("__TEXT", "__literal16",
 139                              MachO::S_16BYTE_LITERALS,
 140                              SectionKind::getMergeableConst16());
 141
 142   ReadOnlySection  // .const
 143     = Ctx->getMachOSection("__TEXT", "__const", 0,
 144                            SectionKind::getReadOnly());
 145
 146   // If the target is not powerpc, map the coal sections to the non-coal
 147   // sections.
 148   //
 149   // "__TEXT/__textcoal_nt" => section "__TEXT/__text"
 150   // "__TEXT/__const_coal"  => section "__TEXT/__const"
 151   // "__DATA/__datacoal_nt" => section "__DATA/__data"
 152   Triple::ArchType ArchTy = T.getArch();
 153
 154   ConstDataSection  // .const_data
 155     = Ctx->getMachOSection("__DATA", "__const", 0,
 156                            SectionKind::getReadOnlyWithRel());
 157
 158   if (ArchTy == Triple::ppc || ArchTy == Triple::ppc64) {
 159     TextCoalSection
 160       = Ctx->getMachOSection("__TEXT", "__textcoal_nt",
 161                              MachO::S_COALESCED |
 162                              MachO::S_ATTR_PURE_INSTRUCTIONS,
 163                              SectionKind::getText());
 164     ConstTextCoalSection
 165       = Ctx->getMachOSection("__TEXT", "__const_coal",
 166                              MachO::S_COALESCED,
 167                              SectionKind::getReadOnly());
 168     DataCoalSection = Ctx->getMachOSection(
 169         "__DATA", "__datacoal_nt", MachO::S_COALESCED, SectionKind::getData());
 170     ConstDataCoalSection = DataCoalSection;
 171   } else {
 172     TextCoalSection = TextSection;
 173     ConstTextCoalSection = ReadOnlySection;
 174     DataCoalSection = DataSection;
 175     ConstDataCoalSection = ConstDataSection;
 176   }
 177
 178   DataCommonSection
 179     = Ctx->getMachOSection("__DATA","__common",
 180                            MachO::S_ZEROFILL,
 181                            SectionKind::getBSS());
 182   DataBSSSection
 183     = Ctx->getMachOSection("__DATA","__bss", MachO::S_ZEROFILL,
 184                            SectionKind::getBSS());
 185
 186
 187   LazySymbolPointerSection
 188     = Ctx->getMachOSection("__DATA", "__la_symbol_ptr",
 189                            MachO::S_LAZY_SYMBOL_POINTERS,
 190                            SectionKind::getMetadata());
 191   NonLazySymbolPointerSection
 192     = Ctx->getMachOSection("__DATA", "__nl_symbol_ptr",
 193                            MachO::S_NON_LAZY_SYMBOL_POINTERS,
 194                            SectionKind::getMetadata());
 195
 196   ThreadLocalPointerSection
 197     = Ctx->getMachOSection("__DATA", "__thread_ptr",
 198                            MachO::S_THREAD_LOCAL_VARIABLE_POINTERS,
 199                            SectionKind::getMetadata());
 200
 201   AddrSigSection = Ctx->getMachOSection("__DATA", "__llvm_addrsig", 0,
 202                                         SectionKind::getData());
 203
 204   // Exception Handling.
 205   LSDASection = Ctx->getMachOSection("__TEXT", "__gcc_except_tab", 0,
 206                                      SectionKind::getReadOnlyWithRel());
 207
 208   COFFDebugSymbolsSection = nullptr;
 209   COFFDebugTypesSection = nullptr;
 210   COFFGlobalTypeHashesSection = nullptr;
 211
 212   if (useCompactUnwind(T)) {
 213     CompactUnwindSection =
 214         Ctx->getMachOSection("__LD", "__compact_unwind", MachO::S_ATTR_DEBUG,
 215                              SectionKind::getReadOnly());
 216
 217     if (T.isX86())
 218       CompactUnwindDwarfEHFrameOnly = 0x04000000;  // UNWIND_X86_64_MODE_DWARF
 219     else if (T.getArch() == Triple::aarch64 || T.getArch() == Triple::aarch64_32)
 220       CompactUnwindDwarfEHFrameOnly = 0x03000000;  // UNWIND_ARM64_MODE_DWARF
 221     else if (T.getArch() == Triple::arm || T.getArch() == Triple::thumb)
 222       CompactUnwindDwarfEHFrameOnly = 0x04000000;  // UNWIND_ARM_MODE_DWARF
 223   }
 224
 225   // Debug Information.
 226   DwarfDebugNamesSection =
 227       Ctx->getMachOSection("__DWARF", "__debug_names", MachO::S_ATTR_DEBUG,
 228                            SectionKind::getMetadata(), "debug_names_begin");
 229   DwarfAccelNamesSection =
 230       Ctx->getMachOSection("__DWARF", "__apple_names", MachO::S_ATTR_DEBUG,
 231                            SectionKind::getMetadata(), "names_begin");
 232   DwarfAccelObjCSection =
 233       Ctx->getMachOSection("__DWARF", "__apple_objc", MachO::S_ATTR_DEBUG,
 234                            SectionKind::getMetadata(), "objc_begin");
 235   // 16 character section limit...
 236   DwarfAccelNamespaceSection =
 237       Ctx->getMachOSection("__DWARF", "__apple_namespac", MachO::S_ATTR_DEBUG,
 238                            SectionKind::getMetadata(), "namespac_begin");
 239   DwarfAccelTypesSection =
 240       Ctx->getMachOSection("__DWARF", "__apple_types", MachO::S_ATTR_DEBUG,
 241                            SectionKind::getMetadata(), "types_begin");
 242
 243   DwarfSwiftASTSection =
 244       Ctx->getMachOSection("__DWARF", "__swift_ast", MachO::S_ATTR_DEBUG,
 245                            SectionKind::getMetadata());
 246
 247   DwarfAbbrevSection =
 248       Ctx->getMachOSection("__DWARF", "__debug_abbrev", MachO::S_ATTR_DEBUG,
 249                            SectionKind::getMetadata(), "section_abbrev");
 250   DwarfInfoSection =
 251       Ctx->getMachOSection("__DWARF", "__debug_info", MachO::S_ATTR_DEBUG,
 252                            SectionKind::getMetadata(), "section_info");
 253   DwarfLineSection =
 254       Ctx->getMachOSection("__DWARF", "__debug_line", MachO::S_ATTR_DEBUG,
 255                            SectionKind::getMetadata(), "section_line");
 256   DwarfLineStrSection =
 257       Ctx->getMachOSection("__DWARF", "__debug_line_str", MachO::S_ATTR_DEBUG,
 258                            SectionKind::getMetadata(), "section_line_str");
 259   DwarfFrameSection =
 260       Ctx->getMachOSection("__DWARF", "__debug_frame", MachO::S_ATTR_DEBUG,
 261                            SectionKind::getMetadata(), "section_frame");
 262   DwarfPubNamesSection =
 263       Ctx->getMachOSection("__DWARF", "__debug_pubnames", MachO::S_ATTR_DEBUG,
 264                            SectionKind::getMetadata());
 265   DwarfPubTypesSection =
 266       Ctx->getMachOSection("__DWARF", "__debug_pubtypes", MachO::S_ATTR_DEBUG,
 267                            SectionKind::getMetadata());
 268   DwarfGnuPubNamesSection =
 269       Ctx->getMachOSection("__DWARF", "__debug_gnu_pubn", MachO::S_ATTR_DEBUG,
 270                            SectionKind::getMetadata());
 271   DwarfGnuPubTypesSection =
 272       Ctx->getMachOSection("__DWARF", "__debug_gnu_pubt", MachO::S_ATTR_DEBUG,
 273                            SectionKind::getMetadata());
 274   DwarfStrSection =
 275       Ctx->getMachOSection("__DWARF", "__debug_str", MachO::S_ATTR_DEBUG,
 276                            SectionKind::getMetadata(), "info_string");
 277   DwarfStrOffSection =
 278       Ctx->getMachOSection("__DWARF", "__debug_str_offs", MachO::S_ATTR_DEBUG,
 279                            SectionKind::getMetadata(), "section_str_off");
 280   DwarfAddrSection =
 281       Ctx->getMachOSection("__DWARF", "__debug_addr", MachO::S_ATTR_DEBUG,
 282                            SectionKind::getMetadata(), "section_info");
 283   DwarfLocSection =
 284       Ctx->getMachOSection("__DWARF", "__debug_loc", MachO::S_ATTR_DEBUG,
 285                            SectionKind::getMetadata(), "section_debug_loc");
 286   DwarfLoclistsSection =
 287       Ctx->getMachOSection("__DWARF", "__debug_loclists", MachO::S_ATTR_DEBUG,
 288                            SectionKind::getMetadata(), "section_debug_loc");
 289
 290   DwarfARangesSection =
 291       Ctx->getMachOSection("__DWARF", "__debug_aranges", MachO::S_ATTR_DEBUG,
 292                            SectionKind::getMetadata());
 293   DwarfRangesSection =
 294       Ctx->getMachOSection("__DWARF", "__debug_ranges", MachO::S_ATTR_DEBUG,
 295                            SectionKind::getMetadata(), "debug_range");
 296   DwarfRnglistsSection =
 297       Ctx->getMachOSection("__DWARF", "__debug_rnglists", MachO::S_ATTR_DEBUG,
 298                            SectionKind::getMetadata(), "debug_range");
 299   DwarfMacinfoSection =
 300       Ctx->getMachOSection("__DWARF", "__debug_macinfo", MachO::S_ATTR_DEBUG,
 301                            SectionKind::getMetadata(), "debug_macinfo");
 302   DwarfMacroSection =
 303       Ctx->getMachOSection("__DWARF", "__debug_macro", MachO::S_ATTR_DEBUG,
 304                            SectionKind::getMetadata(), "debug_macro");
 305   DwarfDebugInlineSection =
 306       Ctx->getMachOSection("__DWARF", "__debug_inlined", MachO::S_ATTR_DEBUG,
 307                            SectionKind::getMetadata());
 308   DwarfCUIndexSection =
 309       Ctx->getMachOSection("__DWARF", "__debug_cu_index", MachO::S_ATTR_DEBUG,
 310                            SectionKind::getMetadata());
 311   DwarfTUIndexSection =
 312       Ctx->getMachOSection("__DWARF", "__debug_tu_index", MachO::S_ATTR_DEBUG,
 313                            SectionKind::getMetadata());
 314   StackMapSection = Ctx->getMachOSection("__LLVM_STACKMAPS", "__llvm_stackmaps",
 315                                          0, SectionKind::getMetadata());
 316
 317   FaultMapSection = Ctx->getMachOSection("__LLVM_FAULTMAPS", "__llvm_faultmaps",
 318                                          0, SectionKind::getMetadata());
 319
 320   RemarksSection = Ctx->getMachOSection(
 321       "__LLVM", "__remarks", MachO::S_ATTR_DEBUG, SectionKind::getMetadata());
 322
 323   // The architecture of dsymutil makes it very difficult to copy the Swift
 324   // reflection metadata sections into the __TEXT segment, so dsymutil creates
 325   // these sections in the __DWARF segment instead.
 326   if (!Ctx->getSwift5ReflectionSegmentName().empty()) {
 327 #define HANDLE_SWIFT_SECTION(KIND, MACHO, ELF, COFF)                           \
 328   Swift5ReflectionSections                                                     \
 329       [llvm::binaryformat::Swift5ReflectionSectionKind::KIND] =                \
 330           Ctx->getMachOSection(Ctx->getSwift5ReflectionSegmentName().data(),   \
 331                                MACHO, 0, SectionKind::getMetadata());
 332 #include "llvm/BinaryFormat/Swift.def"
 333   }
 334
 335   TLSExtraDataSection = TLSTLVSection;
 336 }
 337
 338 void MCObjectFileInfo::initELFMCObjectFileInfo(const Triple &T, bool Large) {
 339   switch (T.getArch()) {
 340   case Triple::mips:
 341   case Triple::mipsel:
 342   case Triple::mips64:
 343   case Triple::mips64el:
 344     // We cannot use DW_EH_PE_sdata8 for the large PositionIndependent case
 345     // since there is no R_MIPS_PC64 relocation (only a 32-bit version).
 346     // In fact DW_EH_PE_sdata4 is enough for us now, and GNU ld doesn't
 347     // support pcrel|sdata8 well. Let's use sdata4 for now.
 348     if (PositionIndependent)
 349       FDECFIEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
 350     else
 351       FDECFIEncoding = Ctx->getAsmInfo()->getCodePointerSize() == 4
 352                            ? dwarf::DW_EH_PE_sdata4
 353                            : dwarf::DW_EH_PE_sdata8;
 354     break;
 355   case Triple::ppc64:
 356   case Triple::ppc64le:
 357   case Triple::aarch64:
 358   case Triple::aarch64_be:
 359   case Triple::x86_64:
 360     FDECFIEncoding = dwarf::DW_EH_PE_pcrel |
 361                      (Large ? dwarf::DW_EH_PE_sdata8 : dwarf::DW_EH_PE_sdata4);
 362     break;
 363   case Triple::bpfel:
 364   case Triple::bpfeb:
 365     FDECFIEncoding = dwarf::DW_EH_PE_sdata8;
 366     break;
 367   case Triple::hexagon:
 368     FDECFIEncoding =
 369         PositionIndependent ? dwarf::DW_EH_PE_pcrel : dwarf::DW_EH_PE_absptr;
 370     break;
 371   case Triple::xtensa:
 372     FDECFIEncoding = dwarf::DW_EH_PE_sdata4;
 373     break;
 374   default:
 375     FDECFIEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
 376     break;
 377   }
 378
 379   unsigned EHSectionType = T.getArch() == Triple::x86_64
 380                                ? ELF::SHT_X86_64_UNWIND
 381                                : ELF::SHT_PROGBITS;
 382
 383   // Solaris requires different flags for .eh_frame to seemingly every other
 384   // platform.
 385   unsigned EHSectionFlags = ELF::SHF_ALLOC;
 386   if (T.isOSSolaris() && T.getArch() != Triple::x86_64)
 387     EHSectionFlags |= ELF::SHF_WRITE;
 388
 389   // ELF
 390   BSSSection = Ctx->getELFSection(".bss", ELF::SHT_NOBITS,
 391                                   ELF::SHF_WRITE | ELF::SHF_ALLOC);
 392
 393   TextSection = Ctx->getELFSection(".text", ELF::SHT_PROGBITS,
 394                                    ELF::SHF_EXECINSTR | ELF::SHF_ALLOC);
 395
 396   DataSection = Ctx->getELFSection(".data", ELF::SHT_PROGBITS,
 397                                    ELF::SHF_WRITE | ELF::SHF_ALLOC);
 398
 399   ReadOnlySection =
 400       Ctx->getELFSection(".rodata", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
 401
 402   TLSDataSection =
 403       Ctx->getELFSection(".tdata", ELF::SHT_PROGBITS,
 404                          ELF::SHF_ALLOC | ELF::SHF_TLS | ELF::SHF_WRITE);
 405
 406   TLSBSSSection = Ctx->getELFSection(
 407       ".tbss", ELF::SHT_NOBITS, ELF::SHF_ALLOC | ELF::SHF_TLS | ELF::SHF_WRITE);
 408
 409   DataRelROSection = Ctx->getELFSection(".data.rel.ro", ELF::SHT_PROGBITS,
 410                                         ELF::SHF_ALLOC | ELF::SHF_WRITE);
 411
 412   MergeableConst4Section =
 413       Ctx->getELFSection(".rodata.cst4", ELF::SHT_PROGBITS,
 414                          ELF::SHF_ALLOC | ELF::SHF_MERGE, 4);
 415
 416   MergeableConst8Section =
 417       Ctx->getELFSection(".rodata.cst8", ELF::SHT_PROGBITS,
 418                          ELF::SHF_ALLOC | ELF::SHF_MERGE, 8);
 419
 420   MergeableConst16Section =
 421       Ctx->getELFSection(".rodata.cst16", ELF::SHT_PROGBITS,
 422                          ELF::SHF_ALLOC | ELF::SHF_MERGE, 16);
 423
 424   MergeableConst32Section =
 425       Ctx->getELFSection(".rodata.cst32", ELF::SHT_PROGBITS,
 426                          ELF::SHF_ALLOC | ELF::SHF_MERGE, 32);
 427
 428   // Exception Handling Sections.
 429
 430   // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
 431   // it contains relocatable pointers.  In PIC mode, this is probably a big
 432   // runtime hit for C++ apps.  Either the contents of the LSDA need to be
 433   // adjusted or this should be a data section.
 434   LSDASection = Ctx->getELFSection(".gcc_except_table", ELF::SHT_PROGBITS,
 435                                    ELF::SHF_ALLOC);
 436
 437   COFFDebugSymbolsSection = nullptr;
 438   COFFDebugTypesSection = nullptr;
 439
 440   unsigned DebugSecType = ELF::SHT_PROGBITS;
 441
 442   // MIPS .debug_* sections should have SHT_MIPS_DWARF section type
 443   // to distinguish among sections contain DWARF and ECOFF debug formats.
 444   // Sections with ECOFF debug format are obsoleted and marked by SHT_PROGBITS.
 445   if (T.isMIPS())
 446     DebugSecType = ELF::SHT_MIPS_DWARF;
 447
 448   // Debug Info Sections.
 449   DwarfAbbrevSection =
 450       Ctx->getELFSection(".debug_abbrev", DebugSecType, 0);
 451   DwarfInfoSection = Ctx->getELFSection(".debug_info", DebugSecType, 0);
 452   DwarfLineSection = Ctx->getELFSection(".debug_line", DebugSecType, 0);
 453   DwarfLineStrSection =
 454       Ctx->getELFSection(".debug_line_str", DebugSecType,
 455                          ELF::SHF_MERGE | ELF::SHF_STRINGS, 1);
 456   DwarfFrameSection = Ctx->getELFSection(".debug_frame", DebugSecType, 0);
 457   DwarfPubNamesSection =
 458       Ctx->getELFSection(".debug_pubnames", DebugSecType, 0);
 459   DwarfPubTypesSection =
 460       Ctx->getELFSection(".debug_pubtypes", DebugSecType, 0);
 461   DwarfGnuPubNamesSection =
 462       Ctx->getELFSection(".debug_gnu_pubnames", DebugSecType, 0);
 463   DwarfGnuPubTypesSection =
 464       Ctx->getELFSection(".debug_gnu_pubtypes", DebugSecType, 0);
 465   DwarfStrSection =
 466       Ctx->getELFSection(".debug_str", DebugSecType,
 467                          ELF::SHF_MERGE | ELF::SHF_STRINGS, 1);
 468   DwarfLocSection = Ctx->getELFSection(".debug_loc", DebugSecType, 0);
 469   DwarfARangesSection =
 470       Ctx->getELFSection(".debug_aranges", DebugSecType, 0);
 471   DwarfRangesSection =
 472       Ctx->getELFSection(".debug_ranges", DebugSecType, 0);
 473   DwarfMacinfoSection =
 474       Ctx->getELFSection(".debug_macinfo", DebugSecType, 0);
 475   DwarfMacroSection = Ctx->getELFSection(".debug_macro", DebugSecType, 0);
 476
 477   // DWARF5 Experimental Debug Info
 478
 479   // Accelerator Tables
 480   DwarfDebugNamesSection =
 481       Ctx->getELFSection(".debug_names", ELF::SHT_PROGBITS, 0);
 482   DwarfAccelNamesSection =
 483       Ctx->getELFSection(".apple_names", ELF::SHT_PROGBITS, 0);
 484   DwarfAccelObjCSection =
 485       Ctx->getELFSection(".apple_objc", ELF::SHT_PROGBITS, 0);
 486   DwarfAccelNamespaceSection =
 487       Ctx->getELFSection(".apple_namespaces", ELF::SHT_PROGBITS, 0);
 488   DwarfAccelTypesSection =
 489       Ctx->getELFSection(".apple_types", ELF::SHT_PROGBITS, 0);
 490
 491   // String Offset and Address Sections
 492   DwarfStrOffSection =
 493       Ctx->getELFSection(".debug_str_offsets", DebugSecType, 0);
 494   DwarfAddrSection = Ctx->getELFSection(".debug_addr", DebugSecType, 0);
 495   DwarfRnglistsSection = Ctx->getELFSection(".debug_rnglists", DebugSecType, 0);
 496   DwarfLoclistsSection = Ctx->getELFSection(".debug_loclists", DebugSecType, 0);
 497
 498   // Fission Sections
 499   DwarfInfoDWOSection =
 500       Ctx->getELFSection(".debug_info.dwo", DebugSecType, ELF::SHF_EXCLUDE);
 501   DwarfTypesDWOSection =
 502       Ctx->getELFSection(".debug_types.dwo", DebugSecType, ELF::SHF_EXCLUDE);
 503   DwarfAbbrevDWOSection =
 504       Ctx->getELFSection(".debug_abbrev.dwo", DebugSecType, ELF::SHF_EXCLUDE);
 505   DwarfStrDWOSection = Ctx->getELFSection(
 506       ".debug_str.dwo", DebugSecType,
 507       ELF::SHF_MERGE | ELF::SHF_STRINGS | ELF::SHF_EXCLUDE, 1);
 508   DwarfLineDWOSection =
 509       Ctx->getELFSection(".debug_line.dwo", DebugSecType, ELF::SHF_EXCLUDE);
 510   DwarfLocDWOSection =
 511       Ctx->getELFSection(".debug_loc.dwo", DebugSecType, ELF::SHF_EXCLUDE);
 512   DwarfStrOffDWOSection = Ctx->getELFSection(".debug_str_offsets.dwo",
 513                                              DebugSecType, ELF::SHF_EXCLUDE);
 514   DwarfRnglistsDWOSection =
 515       Ctx->getELFSection(".debug_rnglists.dwo", DebugSecType, ELF::SHF_EXCLUDE);
 516   DwarfMacinfoDWOSection =
 517       Ctx->getELFSection(".debug_macinfo.dwo", DebugSecType, ELF::SHF_EXCLUDE);
 518   DwarfMacroDWOSection =
 519       Ctx->getELFSection(".debug_macro.dwo", DebugSecType, ELF::SHF_EXCLUDE);
 520
 521   DwarfLoclistsDWOSection =
 522       Ctx->getELFSection(".debug_loclists.dwo", DebugSecType, ELF::SHF_EXCLUDE);
 523
 524   // DWP Sections
 525   DwarfCUIndexSection =
 526       Ctx->getELFSection(".debug_cu_index", DebugSecType, 0);
 527   DwarfTUIndexSection =
 528       Ctx->getELFSection(".debug_tu_index", DebugSecType, 0);
 529
 530   StackMapSection =
 531       Ctx->getELFSection(".llvm_stackmaps", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
 532
 533   FaultMapSection =
 534       Ctx->getELFSection(".llvm_faultmaps", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
 535
 536   EHFrameSection =
 537       Ctx->getELFSection(".eh_frame", EHSectionType, EHSectionFlags);
 538
 539   StackSizesSection = Ctx->getELFSection(".stack_sizes", ELF::SHT_PROGBITS, 0);
 540
 541   PseudoProbeSection = Ctx->getELFSection(".pseudo_probe", DebugSecType, 0);
 542   PseudoProbeDescSection =
 543       Ctx->getELFSection(".pseudo_probe_desc", DebugSecType, 0);
 544
 545   LLVMStatsSection = Ctx->getELFSection(".llvm_stats", ELF::SHT_PROGBITS, 0);
 546 }
 547
 548 void MCObjectFileInfo::initGOFFMCObjectFileInfo(const Triple &T) {
 549   TextSection = Ctx->getGOFFSection(".text", SectionKind::getText(), nullptr);
 550   BSSSection = Ctx->getGOFFSection(".bss", SectionKind::getBSS(), nullptr);
 551   PPA1Section = Ctx->getGOFFSection(".ppa1", SectionKind::getMetadata(),
 552                                     TextSection, GOFF::SK_PPA1);
 553   PPA2Section = Ctx->getGOFFSection(".ppa2", SectionKind::getMetadata(),
 554                                     TextSection, GOFF::SK_PPA2);
 555
 556   PPA2ListSection =
 557       Ctx->getGOFFSection(".ppa2list", SectionKind::getData(), nullptr);
 558
 559   ADASection = Ctx->getGOFFSection(".ada", SectionKind::getData(), nullptr);
 560   IDRLSection = Ctx->getGOFFSection("B_IDRL", SectionKind::getData(), nullptr);
 561 }
 562
 563 void MCObjectFileInfo::initCOFFMCObjectFileInfo(const Triple &T) {
 564   EHFrameSection =
 565       Ctx->getCOFFSection(".eh_frame", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 566                                            COFF::IMAGE_SCN_MEM_READ);
 567
 568   // Set the `IMAGE_SCN_MEM_16BIT` flag when compiling for thumb mode.  This is
 569   // used to indicate to the linker that the text segment contains thumb instructions
 570   // and to set the ISA selection bit for calls accordingly.
 571   const bool IsThumb = T.getArch() == Triple::thumb;
 572
 573   // COFF
 574   BSSSection = Ctx->getCOFFSection(
 575       ".bss", COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
 576                   COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE);
 577   TextSection = Ctx->getCOFFSection(
 578       ".text",
 579       (IsThumb ? COFF::IMAGE_SCN_MEM_16BIT : (COFF::SectionCharacteristics)0) |
 580           COFF::IMAGE_SCN_CNT_CODE | COFF::IMAGE_SCN_MEM_EXECUTE |
 581           COFF::IMAGE_SCN_MEM_READ);
 582   DataSection = Ctx->getCOFFSection(
 583       ".data", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ |
 584                    COFF::IMAGE_SCN_MEM_WRITE);
 585   ReadOnlySection =
 586       Ctx->getCOFFSection(".rdata", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 587                                         COFF::IMAGE_SCN_MEM_READ);
 588
 589   if (T.getArch() == Triple::x86_64 || T.getArch() == Triple::aarch64 ||
 590       T.getArch() == Triple::arm || T.getArch() == Triple::thumb) {
 591     // On Windows with SEH, the LSDA is emitted into the .xdata section
 592     LSDASection = nullptr;
 593   } else {
 594     LSDASection = Ctx->getCOFFSection(".gcc_except_table",
 595                                       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 596                                           COFF::IMAGE_SCN_MEM_READ);
 597   }
 598
 599   // Debug info.
 600   COFFDebugSymbolsSection =
 601       Ctx->getCOFFSection(".debug$S", (COFF::IMAGE_SCN_MEM_DISCARDABLE |
 602                                        COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 603                                        COFF::IMAGE_SCN_MEM_READ));
 604   COFFDebugTypesSection =
 605       Ctx->getCOFFSection(".debug$T", (COFF::IMAGE_SCN_MEM_DISCARDABLE |
 606                                        COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 607                                        COFF::IMAGE_SCN_MEM_READ));
 608   COFFGlobalTypeHashesSection =
 609       Ctx->getCOFFSection(".debug$H", (COFF::IMAGE_SCN_MEM_DISCARDABLE |
 610                                        COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 611                                        COFF::IMAGE_SCN_MEM_READ));
 612
 613   DwarfAbbrevSection = Ctx->getCOFFSection(
 614       ".debug_abbrev", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 615                            COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 616                            COFF::IMAGE_SCN_MEM_READ);
 617   DwarfInfoSection = Ctx->getCOFFSection(
 618       ".debug_info", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 619                          COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 620                          COFF::IMAGE_SCN_MEM_READ);
 621   DwarfLineSection = Ctx->getCOFFSection(
 622       ".debug_line", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 623                          COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 624                          COFF::IMAGE_SCN_MEM_READ);
 625   DwarfLineStrSection = Ctx->getCOFFSection(
 626       ".debug_line_str", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 627                              COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 628                              COFF::IMAGE_SCN_MEM_READ);
 629   DwarfFrameSection = Ctx->getCOFFSection(
 630       ".debug_frame", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 631                           COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 632                           COFF::IMAGE_SCN_MEM_READ);
 633   DwarfPubNamesSection = Ctx->getCOFFSection(
 634       ".debug_pubnames", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 635                              COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 636                              COFF::IMAGE_SCN_MEM_READ);
 637   DwarfPubTypesSection = Ctx->getCOFFSection(
 638       ".debug_pubtypes", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 639                              COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 640                              COFF::IMAGE_SCN_MEM_READ);
 641   DwarfGnuPubNamesSection = Ctx->getCOFFSection(
 642       ".debug_gnu_pubnames", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 643                                  COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 644                                  COFF::IMAGE_SCN_MEM_READ);
 645   DwarfGnuPubTypesSection = Ctx->getCOFFSection(
 646       ".debug_gnu_pubtypes", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 647                                  COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 648                                  COFF::IMAGE_SCN_MEM_READ);
 649   DwarfStrSection = Ctx->getCOFFSection(
 650       ".debug_str", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 651                         COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 652                         COFF::IMAGE_SCN_MEM_READ);
 653   DwarfStrOffSection = Ctx->getCOFFSection(
 654       ".debug_str_offsets", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 655                                 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 656                                 COFF::IMAGE_SCN_MEM_READ);
 657   DwarfLocSection = Ctx->getCOFFSection(
 658       ".debug_loc", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 659                         COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 660                         COFF::IMAGE_SCN_MEM_READ);
 661   DwarfLoclistsSection = Ctx->getCOFFSection(
 662       ".debug_loclists", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 663                              COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 664                              COFF::IMAGE_SCN_MEM_READ);
 665   DwarfARangesSection = Ctx->getCOFFSection(
 666       ".debug_aranges", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 667                             COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 668                             COFF::IMAGE_SCN_MEM_READ);
 669   DwarfRangesSection = Ctx->getCOFFSection(
 670       ".debug_ranges", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 671                            COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 672                            COFF::IMAGE_SCN_MEM_READ);
 673   DwarfRnglistsSection = Ctx->getCOFFSection(
 674       ".debug_rnglists", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 675                              COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 676                              COFF::IMAGE_SCN_MEM_READ);
 677   DwarfMacinfoSection = Ctx->getCOFFSection(
 678       ".debug_macinfo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 679                             COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 680                             COFF::IMAGE_SCN_MEM_READ);
 681   DwarfMacroSection = Ctx->getCOFFSection(
 682       ".debug_macro", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 683                           COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 684                           COFF::IMAGE_SCN_MEM_READ);
 685   DwarfMacinfoDWOSection = Ctx->getCOFFSection(
 686       ".debug_macinfo.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 687                                 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 688                                 COFF::IMAGE_SCN_MEM_READ);
 689   DwarfMacroDWOSection = Ctx->getCOFFSection(
 690       ".debug_macro.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 691                               COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 692                               COFF::IMAGE_SCN_MEM_READ);
 693   DwarfInfoDWOSection = Ctx->getCOFFSection(
 694       ".debug_info.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 695                              COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 696                              COFF::IMAGE_SCN_MEM_READ);
 697   DwarfTypesDWOSection = Ctx->getCOFFSection(
 698       ".debug_types.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 699                               COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 700                               COFF::IMAGE_SCN_MEM_READ);
 701   DwarfAbbrevDWOSection = Ctx->getCOFFSection(
 702       ".debug_abbrev.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 703                                COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 704                                COFF::IMAGE_SCN_MEM_READ);
 705   DwarfStrDWOSection = Ctx->getCOFFSection(
 706       ".debug_str.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 707                             COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 708                             COFF::IMAGE_SCN_MEM_READ);
 709   DwarfLineDWOSection = Ctx->getCOFFSection(
 710       ".debug_line.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 711                              COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 712                              COFF::IMAGE_SCN_MEM_READ);
 713   DwarfLocDWOSection = Ctx->getCOFFSection(
 714       ".debug_loc.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 715                             COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 716                             COFF::IMAGE_SCN_MEM_READ);
 717   DwarfStrOffDWOSection = Ctx->getCOFFSection(
 718       ".debug_str_offsets.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 719                                     COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 720                                     COFF::IMAGE_SCN_MEM_READ);
 721   DwarfAddrSection = Ctx->getCOFFSection(
 722       ".debug_addr", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 723                          COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 724                          COFF::IMAGE_SCN_MEM_READ);
 725   DwarfCUIndexSection = Ctx->getCOFFSection(
 726       ".debug_cu_index", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 727                              COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 728                              COFF::IMAGE_SCN_MEM_READ);
 729   DwarfTUIndexSection = Ctx->getCOFFSection(
 730       ".debug_tu_index", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 731                              COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 732                              COFF::IMAGE_SCN_MEM_READ);
 733   DwarfDebugNamesSection = Ctx->getCOFFSection(
 734       ".debug_names", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 735                           COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 736                           COFF::IMAGE_SCN_MEM_READ);
 737   DwarfAccelNamesSection = Ctx->getCOFFSection(
 738       ".apple_names", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 739                           COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 740                           COFF::IMAGE_SCN_MEM_READ);
 741   DwarfAccelNamespaceSection = Ctx->getCOFFSection(
 742       ".apple_namespaces", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 743                                COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 744                                COFF::IMAGE_SCN_MEM_READ);
 745   DwarfAccelTypesSection = Ctx->getCOFFSection(
 746       ".apple_types", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 747                           COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 748                           COFF::IMAGE_SCN_MEM_READ);
 749   DwarfAccelObjCSection = Ctx->getCOFFSection(
 750       ".apple_objc", COFF::IMAGE_SCN_MEM_DISCARDABLE |
 751                          COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 752                          COFF::IMAGE_SCN_MEM_READ);
 753
 754   DrectveSection = Ctx->getCOFFSection(
 755       ".drectve", COFF::IMAGE_SCN_LNK_INFO | COFF::IMAGE_SCN_LNK_REMOVE);
 756
 757   PDataSection =
 758       Ctx->getCOFFSection(".pdata", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 759                                         COFF::IMAGE_SCN_MEM_READ);
 760
 761   XDataSection =
 762       Ctx->getCOFFSection(".xdata", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 763                                         COFF::IMAGE_SCN_MEM_READ);
 764
 765   SXDataSection = Ctx->getCOFFSection(".sxdata", COFF::IMAGE_SCN_LNK_INFO);
 766
 767   GEHContSection =
 768       Ctx->getCOFFSection(".gehcont$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 769                                             COFF::IMAGE_SCN_MEM_READ);
 770
 771   GFIDsSection =
 772       Ctx->getCOFFSection(".gfids$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 773                                           COFF::IMAGE_SCN_MEM_READ);
 774
 775   GIATsSection =
 776       Ctx->getCOFFSection(".giats$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 777                                           COFF::IMAGE_SCN_MEM_READ);
 778
 779   GLJMPSection =
 780       Ctx->getCOFFSection(".gljmp$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 781                                           COFF::IMAGE_SCN_MEM_READ);
 782
 783   TLSDataSection = Ctx->getCOFFSection(
 784       ".tls$", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ |
 785                    COFF::IMAGE_SCN_MEM_WRITE);
 786
 787   StackMapSection = Ctx->getCOFFSection(".llvm_stackmaps",
 788                                         COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 789                                             COFF::IMAGE_SCN_MEM_READ);
 790 }
 791
 792 void MCObjectFileInfo::initSPIRVMCObjectFileInfo(const Triple &T) {
 793   // Put everything in a single binary section.
 794   TextSection = Ctx->getSPIRVSection();
 795 }
 796
 797 void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
 798   TextSection = Ctx->getWasmSection(".text", SectionKind::getText());
 799   DataSection = Ctx->getWasmSection(".data", SectionKind::getData());
 800
 801   DwarfLineSection =
 802       Ctx->getWasmSection(".debug_line", SectionKind::getMetadata());
 803   DwarfLineStrSection =
 804       Ctx->getWasmSection(".debug_line_str", SectionKind::getMetadata(),
 805                           wasm::WASM_SEG_FLAG_STRINGS);
 806   DwarfStrSection = Ctx->getWasmSection(
 807       ".debug_str", SectionKind::getMetadata(), wasm::WASM_SEG_FLAG_STRINGS);
 808   DwarfLocSection =
 809       Ctx->getWasmSection(".debug_loc", SectionKind::getMetadata());
 810   DwarfAbbrevSection =
 811       Ctx->getWasmSection(".debug_abbrev", SectionKind::getMetadata());
 812   DwarfARangesSection = Ctx->getWasmSection(".debug_aranges", SectionKind::getMetadata());
 813   DwarfRangesSection =
 814       Ctx->getWasmSection(".debug_ranges", SectionKind::getMetadata());
 815   DwarfMacinfoSection =
 816       Ctx->getWasmSection(".debug_macinfo", SectionKind::getMetadata());
 817   DwarfMacroSection =
 818       Ctx->getWasmSection(".debug_macro", SectionKind::getMetadata());
 819   DwarfCUIndexSection = Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata());
 820   DwarfTUIndexSection = Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata());
 821   DwarfInfoSection =
 822       Ctx->getWasmSection(".debug_info", SectionKind::getMetadata());
 823   DwarfFrameSection = Ctx->getWasmSection(".debug_frame", SectionKind::getMetadata());
 824   DwarfPubNamesSection = Ctx->getWasmSection(".debug_pubnames", SectionKind::getMetadata());
 825   DwarfPubTypesSection = Ctx->getWasmSection(".debug_pubtypes", SectionKind::getMetadata());
 826   DwarfGnuPubNamesSection =
 827       Ctx->getWasmSection(".debug_gnu_pubnames", SectionKind::getMetadata());
 828   DwarfGnuPubTypesSection =
 829       Ctx->getWasmSection(".debug_gnu_pubtypes", SectionKind::getMetadata());
 830
 831   DwarfDebugNamesSection =
 832       Ctx->getWasmSection(".debug_names", SectionKind::getMetadata());
 833   DwarfStrOffSection =
 834       Ctx->getWasmSection(".debug_str_offsets", SectionKind::getMetadata());
 835   DwarfAddrSection =
 836       Ctx->getWasmSection(".debug_addr", SectionKind::getMetadata());
 837   DwarfRnglistsSection =
 838       Ctx->getWasmSection(".debug_rnglists", SectionKind::getMetadata());
 839   DwarfLoclistsSection =
 840       Ctx->getWasmSection(".debug_loclists", SectionKind::getMetadata());
 841
 842   // Fission Sections
 843   DwarfInfoDWOSection =
 844       Ctx->getWasmSection(".debug_info.dwo", SectionKind::getMetadata());
 845   DwarfTypesDWOSection =
 846       Ctx->getWasmSection(".debug_types.dwo", SectionKind::getMetadata());
 847   DwarfAbbrevDWOSection =
 848       Ctx->getWasmSection(".debug_abbrev.dwo", SectionKind::getMetadata());
 849   DwarfStrDWOSection =
 850       Ctx->getWasmSection(".debug_str.dwo", SectionKind::getMetadata(),
 851                           wasm::WASM_SEG_FLAG_STRINGS);
 852   DwarfLineDWOSection =
 853       Ctx->getWasmSection(".debug_line.dwo", SectionKind::getMetadata());
 854   DwarfLocDWOSection =
 855       Ctx->getWasmSection(".debug_loc.dwo", SectionKind::getMetadata());
 856   DwarfStrOffDWOSection =
 857       Ctx->getWasmSection(".debug_str_offsets.dwo", SectionKind::getMetadata());
 858   DwarfRnglistsDWOSection =
 859       Ctx->getWasmSection(".debug_rnglists.dwo", SectionKind::getMetadata());
 860   DwarfMacinfoDWOSection =
 861       Ctx->getWasmSection(".debug_macinfo.dwo", SectionKind::getMetadata());
 862   DwarfMacroDWOSection =
 863       Ctx->getWasmSection(".debug_macro.dwo", SectionKind::getMetadata());
 864
 865   DwarfLoclistsDWOSection =
 866       Ctx->getWasmSection(".debug_loclists.dwo", SectionKind::getMetadata());
 867
 868   // DWP Sections
 869   DwarfCUIndexSection =
 870       Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata());
 871   DwarfTUIndexSection =
 872       Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata());
 873
 874   // Wasm use data section for LSDA.
 875   // TODO Consider putting each function's exception table in a separate
 876   // section, as in -function-sections, to facilitate lld's --gc-section.
 877   LSDASection = Ctx->getWasmSection(".rodata.gcc_except_table",
 878                                     SectionKind::getReadOnlyWithRel());
 879
 880   // TODO: Define more sections.
 881 }
 882
 883 void MCObjectFileInfo::initXCOFFMCObjectFileInfo(const Triple &T) {
 884   // The default csect for program code. Functions without a specified section
 885   // get placed into this csect. The choice of csect name is not a property of
 886   // the ABI or object file format, but various tools rely on the section
 887   // name being empty (considering named symbols to be "user symbol names").
 888   TextSection = Ctx->getXCOFFSection(
 889       "..text..", // Use a non-null name to work around an AIX assembler bug...
 890       SectionKind::getText(),
 891       XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_PR, XCOFF::XTY_SD),
 892       /* MultiSymbolsAllowed*/ true);
 893
 894   // ... but use a null name when generating the symbol table.
 895   MCSectionXCOFF *TS = static_cast<MCSectionXCOFF *>(TextSection);
 896   TS->getQualNameSymbol()->setSymbolTableName("");
 897   TS->setSymbolTableName("");
 898
 899   DataSection = Ctx->getXCOFFSection(
 900       ".data", SectionKind::getData(),
 901       XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RW, XCOFF::XTY_SD),
 902       /* MultiSymbolsAllowed*/ true);
 903
 904   ReadOnlySection = Ctx->getXCOFFSection(
 905       ".rodata", SectionKind::getReadOnly(),
 906       XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD),
 907       /* MultiSymbolsAllowed*/ true);
 908   ReadOnlySection->setAlignment(Align(4));
 909
 910   ReadOnly8Section = Ctx->getXCOFFSection(
 911       ".rodata.8", SectionKind::getReadOnly(),
 912       XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD),
 913       /* MultiSymbolsAllowed*/ true);
 914   ReadOnly8Section->setAlignment(Align(8));
 915
 916   ReadOnly16Section = Ctx->getXCOFFSection(
 917       ".rodata.16", SectionKind::getReadOnly(),
 918       XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD),
 919       /* MultiSymbolsAllowed*/ true);
 920   ReadOnly16Section->setAlignment(Align(16));
 921
 922   TLSDataSection = Ctx->getXCOFFSection(
 923       ".tdata", SectionKind::getThreadData(),
 924       XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_TL, XCOFF::XTY_SD),
 925       /* MultiSymbolsAllowed*/ true);
 926
 927   TOCBaseSection = Ctx->getXCOFFSection(
 928       "TOC", SectionKind::getData(),
 929       XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_TC0,
 930                              XCOFF::XTY_SD));
 931
 932   // The TOC-base always has 0 size, but 4 byte alignment.
 933   TOCBaseSection->setAlignment(Align(4));
 934
 935   LSDASection = Ctx->getXCOFFSection(
 936       ".gcc_except_table", SectionKind::getReadOnly(),
 937       XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO,
 938                              XCOFF::XTY_SD));
 939
 940   CompactUnwindSection = Ctx->getXCOFFSection(
 941       ".eh_info_table", SectionKind::getData(),
 942       XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RW,
 943                              XCOFF::XTY_SD));
 944
 945   // DWARF sections for XCOFF are not csects. They are special STYP_DWARF
 946   // sections, and the individual DWARF sections are distinguished by their
 947   // section subtype.
 948   DwarfAbbrevSection = Ctx->getXCOFFSection(
 949       ".dwabrev", SectionKind::getMetadata(),
 950       /* CsectProperties */ std::nullopt,
 951       /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWABREV);
 952
 953   DwarfInfoSection = Ctx->getXCOFFSection(
 954       ".dwinfo", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
 955       /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWINFO);
 956
 957   DwarfLineSection = Ctx->getXCOFFSection(
 958       ".dwline", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
 959       /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWLINE);
 960
 961   DwarfFrameSection = Ctx->getXCOFFSection(
 962       ".dwframe", SectionKind::getMetadata(),
 963       /* CsectProperties */ std::nullopt,
 964       /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWFRAME);
 965
 966   DwarfPubNamesSection = Ctx->getXCOFFSection(
 967       ".dwpbnms", SectionKind::getMetadata(),
 968       /* CsectProperties */ std::nullopt,
 969       /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWPBNMS);
 970
 971   DwarfPubTypesSection = Ctx->getXCOFFSection(
 972       ".dwpbtyp", SectionKind::getMetadata(),
 973       /* CsectProperties */ std::nullopt,
 974       /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWPBTYP);
 975
 976   DwarfStrSection = Ctx->getXCOFFSection(
 977       ".dwstr", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
 978       /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWSTR);
 979
 980   DwarfLocSection = Ctx->getXCOFFSection(
 981       ".dwloc", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
 982       /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWLOC);
 983
 984   DwarfARangesSection = Ctx->getXCOFFSection(
 985       ".dwarnge", SectionKind::getMetadata(),
 986       /* CsectProperties */ std::nullopt,
 987       /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWARNGE);
 988
 989   DwarfRangesSection = Ctx->getXCOFFSection(
 990       ".dwrnges", SectionKind::getMetadata(),
 991       /* CsectProperties */ std::nullopt,
 992       /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWRNGES);
 993
 994   DwarfMacinfoSection = Ctx->getXCOFFSection(
 995       ".dwmac", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
 996       /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWMAC);
 997 }
 998
 999 void MCObjectFileInfo::initDXContainerObjectFileInfo(const Triple &T) {
1000   // At the moment the DXBC section should end up empty.
1001   TextSection = Ctx->getDXContainerSection("DXBC", SectionKind::getText());
1002 }
1003
1004 MCObjectFileInfo::~MCObjectFileInfo() = default;
1005
1006 void MCObjectFileInfo::initMCObjectFileInfo(MCContext &MCCtx, bool PIC,
1007                                             bool LargeCodeModel) {
1008   PositionIndependent = PIC;
1009   Ctx = &MCCtx;
1010
1011   // Common.
1012   SupportsWeakOmittedEHFrame = true;
1013   SupportsCompactUnwindWithoutEHFrame = false;
1014   OmitDwarfIfHaveCompactUnwind = false;
1015
1016   FDECFIEncoding = dwarf::DW_EH_PE_absptr;
1017
1018   CompactUnwindDwarfEHFrameOnly = 0;
1019
1020   EHFrameSection = nullptr;             // Created on demand.
1021   CompactUnwindSection = nullptr;       // Used only by selected targets.
1022   DwarfAccelNamesSection = nullptr;     // Used only by selected targets.
1023   DwarfAccelObjCSection = nullptr;      // Used only by selected targets.
1024   DwarfAccelNamespaceSection = nullptr; // Used only by selected targets.
1025   DwarfAccelTypesSection = nullptr;     // Used only by selected targets.
1026
1027   const Triple &TheTriple = Ctx->getTargetTriple();
1028   switch (Ctx->getObjectFileType()) {
1029   case MCContext::IsMachO:
1030     initMachOMCObjectFileInfo(TheTriple);
1031     break;
1032   case MCContext::IsCOFF:
1033     initCOFFMCObjectFileInfo(TheTriple);
1034     break;
1035   case MCContext::IsELF:
1036     initELFMCObjectFileInfo(TheTriple, LargeCodeModel);
1037     break;
1038   case MCContext::IsGOFF:
1039     initGOFFMCObjectFileInfo(TheTriple);
1040     break;
1041   case MCContext::IsSPIRV:
1042     initSPIRVMCObjectFileInfo(TheTriple);
1043     break;
1044   case MCContext::IsWasm:
1045     initWasmMCObjectFileInfo(TheTriple);
1046     break;
1047   case MCContext::IsXCOFF:
1048     initXCOFFMCObjectFileInfo(TheTriple);
1049     break;
1050   case MCContext::IsDXContainer:
1051     initDXContainerObjectFileInfo(TheTriple);
1052     break;
1053   }
1054 }
1055
1056 MCSection *MCObjectFileInfo::getDwarfComdatSection(const char *Name,
1057                                                    uint64_t Hash) const {
1058   switch (Ctx->getTargetTriple().getObjectFormat()) {
1059   case Triple::ELF:
1060     return Ctx->getELFSection(Name, ELF::SHT_PROGBITS, ELF::SHF_GROUP, 0,
1061                               utostr(Hash), /*IsComdat=*/true);
1062   case Triple::Wasm:
1063     return Ctx->getWasmSection(Name, SectionKind::getMetadata(), 0,
1064                                utostr(Hash), MCContext::GenericSectionID);
1065   case Triple::MachO:
1066   case Triple::COFF:
1067   case Triple::GOFF:
1068   case Triple::SPIRV:
1069   case Triple::XCOFF:
1070   case Triple::DXContainer:
1071   case Triple::UnknownObjectFormat:
1072     report_fatal_error("Cannot get DWARF comdat section for this object file "
1073                        "format: not implemented.");
1074     break;
1075   }
1076   llvm_unreachable("Unknown ObjectFormatType");
1077 }
1078
1079 MCSection *
1080 MCObjectFileInfo::getStackSizesSection(const MCSection &TextSec) const {
1081   if ((Ctx->getObjectFileType() != MCContext::IsELF) ||
1082       Ctx->getTargetTriple().isPS4())
1083     return StackSizesSection;
1084
1085   const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1086   unsigned Flags = ELF::SHF_LINK_ORDER;
1087   StringRef GroupName;
1088   if (const MCSymbol *Group = ElfSec.getGroup()) {
1089     GroupName = Group->getName();
1090     Flags |= ELF::SHF_GROUP;
1091   }
1092
1093   return Ctx->getELFSection(".stack_sizes", ELF::SHT_PROGBITS, Flags, 0,
1094                             GroupName, true, ElfSec.getUniqueID(),
1095                             cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1096 }
1097
1098 MCSection *
1099 MCObjectFileInfo::getBBAddrMapSection(const MCSection &TextSec) const {
1100   if (Ctx->getObjectFileType() != MCContext::IsELF)
1101     return nullptr;
1102
1103   const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1104   unsigned Flags = ELF::SHF_LINK_ORDER;
1105   StringRef GroupName;
1106   if (const MCSymbol *Group = ElfSec.getGroup()) {
1107     GroupName = Group->getName();
1108     Flags |= ELF::SHF_GROUP;
1109   }
1110
1111   // Use the text section's begin symbol and unique ID to create a separate
1112   // .llvm_bb_addr_map section associated with every unique text section.
1113   return Ctx->getELFSection(".llvm_bb_addr_map", ELF::SHT_LLVM_BB_ADDR_MAP,
1114                             Flags, 0, GroupName, true, ElfSec.getUniqueID(),
1115                             cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1116 }
1117
1118 MCSection *
1119 MCObjectFileInfo::getKCFITrapSection(const MCSection &TextSec) const {
1120   if (Ctx->getObjectFileType() != MCContext::IsELF)
1121     return nullptr;
1122
1123   const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1124   unsigned Flags = ELF::SHF_LINK_ORDER | ELF::SHF_ALLOC;
1125   StringRef GroupName;
1126   if (const MCSymbol *Group = ElfSec.getGroup()) {
1127     GroupName = Group->getName();
1128     Flags |= ELF::SHF_GROUP;
1129   }
1130
1131   return Ctx->getELFSection(".kcfi_traps", ELF::SHT_PROGBITS, Flags, 0,
1132                             GroupName,
1133                             /*IsComdat=*/true, ElfSec.getUniqueID(),
1134                             cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1135 }
1136
1137 MCSection *
1138 MCObjectFileInfo::getPseudoProbeSection(const MCSection &TextSec) const {
1139   if (Ctx->getObjectFileType() != MCContext::IsELF)
1140     return PseudoProbeSection;
1141
1142   const auto &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1143   unsigned Flags = ELF::SHF_LINK_ORDER;
1144   StringRef GroupName;
1145   if (const MCSymbol *Group = ElfSec.getGroup()) {
1146     GroupName = Group->getName();
1147     Flags |= ELF::SHF_GROUP;
1148   }
1149
1150   return Ctx->getELFSection(PseudoProbeSection->getName(), ELF::SHT_PROGBITS,
1151                             Flags, 0, GroupName, true, ElfSec.getUniqueID(),
1152                             cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1153 }
1154
1155 MCSection *
1156 MCObjectFileInfo::getPseudoProbeDescSection(StringRef FuncName) const {
1157   if (Ctx->getObjectFileType() == MCContext::IsELF) {
1158     // Create a separate comdat group for each function's descriptor in order
1159     // for the linker to deduplicate. The duplication, must be from different
1160     // tranlation unit, can come from:
1161     //  1. Inline functions defined in header files;
1162     //  2. ThinLTO imported funcions;
1163     //  3. Weak-linkage definitions.
1164     // Use a concatenation of the section name and the function name as the
1165     // group name so that descriptor-only groups won't be folded with groups of
1166     // code.
1167     if (Ctx->getTargetTriple().supportsCOMDAT() && !FuncName.empty()) {
1168       auto *S = static_cast<MCSectionELF *>(PseudoProbeDescSection);
1169       auto Flags = S->getFlags() | ELF::SHF_GROUP;
1170       return Ctx->getELFSection(S->getName(), S->getType(), Flags,
1171                                 S->getEntrySize(),
1172                                 S->getName() + "_" + FuncName,
1173                                 /*IsComdat=*/true);
1174     }
1175   }
1176   return PseudoProbeDescSection;
1177 }
1178
1179 MCSection *MCObjectFileInfo::getLLVMStatsSection() const {
1180   return LLVMStatsSection;
1181 }
1182
1183 MCSection *MCObjectFileInfo::getPCSection(StringRef Name,
1184                                           const MCSection *TextSec) const {
1185   if (Ctx->getObjectFileType() != MCContext::IsELF)
1186     return nullptr;
1187
1188   // SHF_WRITE for relocations, and let user post-process data in-place.
1189   unsigned Flags = ELF::SHF_WRITE | ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER;
1190
1191   if (!TextSec)
1192     TextSec = getTextSection();
1193
1194   StringRef GroupName;
1195   const auto &ElfSec = static_cast<const MCSectionELF &>(*TextSec);
1196   if (const MCSymbol *Group = ElfSec.getGroup()) {
1197     GroupName = Group->getName();
1198     Flags |= ELF::SHF_GROUP;
1199   }
1200   return Ctx->getELFSection(Name, ELF::SHT_PROGBITS, Flags, 0, GroupName, true,
1201                             ElfSec.getUniqueID(),
1202                             cast<MCSymbolELF>(TextSec->getBeginSymbol()));
1203 }