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", 615 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 616 COFF::IMAGE_SCN_MEM_READ, 617 "section_abbrev"); 618 DwarfInfoSection = Ctx->getCOFFSection( 619 ".debug_info", 620 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 621 COFF::IMAGE_SCN_MEM_READ, 622 "section_info"); 623 DwarfLineSection = Ctx->getCOFFSection( 624 ".debug_line", 625 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 626 COFF::IMAGE_SCN_MEM_READ, 627 "section_line"); 628 DwarfLineStrSection = Ctx->getCOFFSection( 629 ".debug_line_str", 630 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 631 COFF::IMAGE_SCN_MEM_READ, 632 "section_line_str"); 633 DwarfFrameSection = Ctx->getCOFFSection( 634 ".debug_frame", COFF::IMAGE_SCN_MEM_DISCARDABLE | 635 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 636 COFF::IMAGE_SCN_MEM_READ); 637 DwarfPubNamesSection = Ctx->getCOFFSection( 638 ".debug_pubnames", COFF::IMAGE_SCN_MEM_DISCARDABLE | 639 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 640 COFF::IMAGE_SCN_MEM_READ); 641 DwarfPubTypesSection = Ctx->getCOFFSection( 642 ".debug_pubtypes", COFF::IMAGE_SCN_MEM_DISCARDABLE | 643 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 644 COFF::IMAGE_SCN_MEM_READ); 645 DwarfGnuPubNamesSection = Ctx->getCOFFSection( 646 ".debug_gnu_pubnames", COFF::IMAGE_SCN_MEM_DISCARDABLE | 647 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 648 COFF::IMAGE_SCN_MEM_READ); 649 DwarfGnuPubTypesSection = Ctx->getCOFFSection( 650 ".debug_gnu_pubtypes", COFF::IMAGE_SCN_MEM_DISCARDABLE | 651 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 652 COFF::IMAGE_SCN_MEM_READ); 653 DwarfStrSection = Ctx->getCOFFSection( 654 ".debug_str", 655 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 656 COFF::IMAGE_SCN_MEM_READ, 657 "info_string"); 658 DwarfStrOffSection = Ctx->getCOFFSection( 659 ".debug_str_offsets", 660 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 661 COFF::IMAGE_SCN_MEM_READ, 662 "section_str_off"); 663 DwarfLocSection = Ctx->getCOFFSection( 664 ".debug_loc", 665 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 666 COFF::IMAGE_SCN_MEM_READ, 667 "section_debug_loc"); 668 DwarfLoclistsSection = Ctx->getCOFFSection( 669 ".debug_loclists", 670 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 671 COFF::IMAGE_SCN_MEM_READ, 672 "section_debug_loclists"); 673 DwarfARangesSection = Ctx->getCOFFSection( 674 ".debug_aranges", COFF::IMAGE_SCN_MEM_DISCARDABLE | 675 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 676 COFF::IMAGE_SCN_MEM_READ); 677 DwarfRangesSection = Ctx->getCOFFSection( 678 ".debug_ranges", 679 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 680 COFF::IMAGE_SCN_MEM_READ, 681 "debug_range"); 682 DwarfRnglistsSection = Ctx->getCOFFSection( 683 ".debug_rnglists", 684 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 685 COFF::IMAGE_SCN_MEM_READ, 686 "debug_rnglists"); 687 DwarfMacinfoSection = Ctx->getCOFFSection( 688 ".debug_macinfo", 689 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 690 COFF::IMAGE_SCN_MEM_READ, 691 "debug_macinfo"); 692 DwarfMacroSection = Ctx->getCOFFSection( 693 ".debug_macro", 694 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 695 COFF::IMAGE_SCN_MEM_READ, 696 "debug_macro"); 697 DwarfMacinfoDWOSection = Ctx->getCOFFSection( 698 ".debug_macinfo.dwo", 699 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 700 COFF::IMAGE_SCN_MEM_READ, 701 "debug_macinfo.dwo"); 702 DwarfMacroDWOSection = Ctx->getCOFFSection( 703 ".debug_macro.dwo", 704 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 705 COFF::IMAGE_SCN_MEM_READ, 706 "debug_macro.dwo"); 707 DwarfInfoDWOSection = Ctx->getCOFFSection( 708 ".debug_info.dwo", 709 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 710 COFF::IMAGE_SCN_MEM_READ, 711 "section_info_dwo"); 712 DwarfTypesDWOSection = Ctx->getCOFFSection( 713 ".debug_types.dwo", 714 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 715 COFF::IMAGE_SCN_MEM_READ, 716 "section_types_dwo"); 717 DwarfAbbrevDWOSection = Ctx->getCOFFSection( 718 ".debug_abbrev.dwo", 719 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 720 COFF::IMAGE_SCN_MEM_READ, 721 "section_abbrev_dwo"); 722 DwarfStrDWOSection = Ctx->getCOFFSection( 723 ".debug_str.dwo", 724 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 725 COFF::IMAGE_SCN_MEM_READ, 726 "skel_string"); 727 DwarfLineDWOSection = Ctx->getCOFFSection( 728 ".debug_line.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE | 729 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 730 COFF::IMAGE_SCN_MEM_READ); 731 DwarfLocDWOSection = Ctx->getCOFFSection( 732 ".debug_loc.dwo", 733 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 734 COFF::IMAGE_SCN_MEM_READ, 735 "skel_loc"); 736 DwarfStrOffDWOSection = Ctx->getCOFFSection( 737 ".debug_str_offsets.dwo", 738 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 739 COFF::IMAGE_SCN_MEM_READ, 740 "section_str_off_dwo"); 741 DwarfAddrSection = Ctx->getCOFFSection( 742 ".debug_addr", 743 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 744 COFF::IMAGE_SCN_MEM_READ, 745 "addr_sec"); 746 DwarfCUIndexSection = Ctx->getCOFFSection( 747 ".debug_cu_index", COFF::IMAGE_SCN_MEM_DISCARDABLE | 748 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 749 COFF::IMAGE_SCN_MEM_READ); 750 DwarfTUIndexSection = Ctx->getCOFFSection( 751 ".debug_tu_index", COFF::IMAGE_SCN_MEM_DISCARDABLE | 752 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 753 COFF::IMAGE_SCN_MEM_READ); 754 DwarfDebugNamesSection = Ctx->getCOFFSection( 755 ".debug_names", 756 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 757 COFF::IMAGE_SCN_MEM_READ, 758 "debug_names_begin"); 759 DwarfAccelNamesSection = Ctx->getCOFFSection( 760 ".apple_names", 761 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 762 COFF::IMAGE_SCN_MEM_READ, 763 "names_begin"); 764 DwarfAccelNamespaceSection = Ctx->getCOFFSection( 765 ".apple_namespaces", 766 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 767 COFF::IMAGE_SCN_MEM_READ, 768 "namespac_begin"); 769 DwarfAccelTypesSection = Ctx->getCOFFSection( 770 ".apple_types", 771 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 772 COFF::IMAGE_SCN_MEM_READ, 773 "types_begin"); 774 DwarfAccelObjCSection = Ctx->getCOFFSection( 775 ".apple_objc", 776 COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 777 COFF::IMAGE_SCN_MEM_READ, 778 "objc_begin"); 779 780 DrectveSection = Ctx->getCOFFSection( 781 ".drectve", COFF::IMAGE_SCN_LNK_INFO | COFF::IMAGE_SCN_LNK_REMOVE); 782 783 PDataSection = 784 Ctx->getCOFFSection(".pdata", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 785 COFF::IMAGE_SCN_MEM_READ); 786 787 XDataSection = 788 Ctx->getCOFFSection(".xdata", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 789 COFF::IMAGE_SCN_MEM_READ); 790 791 SXDataSection = Ctx->getCOFFSection(".sxdata", COFF::IMAGE_SCN_LNK_INFO); 792 793 GEHContSection = 794 Ctx->getCOFFSection(".gehcont$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 795 COFF::IMAGE_SCN_MEM_READ); 796 797 GFIDsSection = 798 Ctx->getCOFFSection(".gfids$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 799 COFF::IMAGE_SCN_MEM_READ); 800 801 GIATsSection = 802 Ctx->getCOFFSection(".giats$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 803 COFF::IMAGE_SCN_MEM_READ); 804 805 GLJMPSection = 806 Ctx->getCOFFSection(".gljmp$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 807 COFF::IMAGE_SCN_MEM_READ); 808 809 TLSDataSection = Ctx->getCOFFSection( 810 ".tls$", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ | 811 COFF::IMAGE_SCN_MEM_WRITE); 812 813 StackMapSection = Ctx->getCOFFSection(".llvm_stackmaps", 814 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 815 COFF::IMAGE_SCN_MEM_READ); 816 } 817 818 void MCObjectFileInfo::initSPIRVMCObjectFileInfo(const Triple &T) { 819 // Put everything in a single binary section. 820 TextSection = Ctx->getSPIRVSection(); 821 } 822 823 void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) { 824 TextSection = Ctx->getWasmSection(".text", SectionKind::getText()); 825 DataSection = Ctx->getWasmSection(".data", SectionKind::getData()); 826 827 DwarfLineSection = 828 Ctx->getWasmSection(".debug_line", SectionKind::getMetadata()); 829 DwarfLineStrSection = 830 Ctx->getWasmSection(".debug_line_str", SectionKind::getMetadata(), 831 wasm::WASM_SEG_FLAG_STRINGS); 832 DwarfStrSection = Ctx->getWasmSection( 833 ".debug_str", SectionKind::getMetadata(), wasm::WASM_SEG_FLAG_STRINGS); 834 DwarfLocSection = 835 Ctx->getWasmSection(".debug_loc", SectionKind::getMetadata()); 836 DwarfAbbrevSection = 837 Ctx->getWasmSection(".debug_abbrev", SectionKind::getMetadata()); 838 DwarfARangesSection = Ctx->getWasmSection(".debug_aranges", SectionKind::getMetadata()); 839 DwarfRangesSection = 840 Ctx->getWasmSection(".debug_ranges", SectionKind::getMetadata()); 841 DwarfMacinfoSection = 842 Ctx->getWasmSection(".debug_macinfo", SectionKind::getMetadata()); 843 DwarfMacroSection = 844 Ctx->getWasmSection(".debug_macro", SectionKind::getMetadata()); 845 DwarfCUIndexSection = Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata()); 846 DwarfTUIndexSection = Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata()); 847 DwarfInfoSection = 848 Ctx->getWasmSection(".debug_info", SectionKind::getMetadata()); 849 DwarfFrameSection = Ctx->getWasmSection(".debug_frame", SectionKind::getMetadata()); 850 DwarfPubNamesSection = Ctx->getWasmSection(".debug_pubnames", SectionKind::getMetadata()); 851 DwarfPubTypesSection = Ctx->getWasmSection(".debug_pubtypes", SectionKind::getMetadata()); 852 DwarfGnuPubNamesSection = 853 Ctx->getWasmSection(".debug_gnu_pubnames", SectionKind::getMetadata()); 854 DwarfGnuPubTypesSection = 855 Ctx->getWasmSection(".debug_gnu_pubtypes", SectionKind::getMetadata()); 856 857 DwarfDebugNamesSection = 858 Ctx->getWasmSection(".debug_names", SectionKind::getMetadata()); 859 DwarfStrOffSection = 860 Ctx->getWasmSection(".debug_str_offsets", SectionKind::getMetadata()); 861 DwarfAddrSection = 862 Ctx->getWasmSection(".debug_addr", SectionKind::getMetadata()); 863 DwarfRnglistsSection = 864 Ctx->getWasmSection(".debug_rnglists", SectionKind::getMetadata()); 865 DwarfLoclistsSection = 866 Ctx->getWasmSection(".debug_loclists", SectionKind::getMetadata()); 867 868 // Fission Sections 869 DwarfInfoDWOSection = 870 Ctx->getWasmSection(".debug_info.dwo", SectionKind::getMetadata()); 871 DwarfTypesDWOSection = 872 Ctx->getWasmSection(".debug_types.dwo", SectionKind::getMetadata()); 873 DwarfAbbrevDWOSection = 874 Ctx->getWasmSection(".debug_abbrev.dwo", SectionKind::getMetadata()); 875 DwarfStrDWOSection = 876 Ctx->getWasmSection(".debug_str.dwo", SectionKind::getMetadata(), 877 wasm::WASM_SEG_FLAG_STRINGS); 878 DwarfLineDWOSection = 879 Ctx->getWasmSection(".debug_line.dwo", SectionKind::getMetadata()); 880 DwarfLocDWOSection = 881 Ctx->getWasmSection(".debug_loc.dwo", SectionKind::getMetadata()); 882 DwarfStrOffDWOSection = 883 Ctx->getWasmSection(".debug_str_offsets.dwo", SectionKind::getMetadata()); 884 DwarfRnglistsDWOSection = 885 Ctx->getWasmSection(".debug_rnglists.dwo", SectionKind::getMetadata()); 886 DwarfMacinfoDWOSection = 887 Ctx->getWasmSection(".debug_macinfo.dwo", SectionKind::getMetadata()); 888 DwarfMacroDWOSection = 889 Ctx->getWasmSection(".debug_macro.dwo", SectionKind::getMetadata()); 890 891 DwarfLoclistsDWOSection = 892 Ctx->getWasmSection(".debug_loclists.dwo", SectionKind::getMetadata()); 893 894 // DWP Sections 895 DwarfCUIndexSection = 896 Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata()); 897 DwarfTUIndexSection = 898 Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata()); 899 900 // Wasm use data section for LSDA. 901 // TODO Consider putting each function's exception table in a separate 902 // section, as in -function-sections, to facilitate lld's --gc-section. 903 LSDASection = Ctx->getWasmSection(".rodata.gcc_except_table", 904 SectionKind::getReadOnlyWithRel()); 905 906 // TODO: Define more sections. 907 } 908 909 void MCObjectFileInfo::initXCOFFMCObjectFileInfo(const Triple &T) { 910 // The default csect for program code. Functions without a specified section 911 // get placed into this csect. The choice of csect name is not a property of 912 // the ABI or object file format, but various tools rely on the section 913 // name being empty (considering named symbols to be "user symbol names"). 914 TextSection = Ctx->getXCOFFSection( 915 "..text..", // Use a non-null name to work around an AIX assembler bug... 916 SectionKind::getText(), 917 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_PR, XCOFF::XTY_SD), 918 /* MultiSymbolsAllowed*/ true); 919 920 // ... but use a null name when generating the symbol table. 921 MCSectionXCOFF *TS = static_cast<MCSectionXCOFF *>(TextSection); 922 TS->getQualNameSymbol()->setSymbolTableName(""); 923 TS->setSymbolTableName(""); 924 925 DataSection = Ctx->getXCOFFSection( 926 ".data", SectionKind::getData(), 927 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RW, XCOFF::XTY_SD), 928 /* MultiSymbolsAllowed*/ true); 929 930 ReadOnlySection = Ctx->getXCOFFSection( 931 ".rodata", SectionKind::getReadOnly(), 932 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD), 933 /* MultiSymbolsAllowed*/ true); 934 ReadOnlySection->setAlignment(Align(4)); 935 936 ReadOnly8Section = Ctx->getXCOFFSection( 937 ".rodata.8", SectionKind::getReadOnly(), 938 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD), 939 /* MultiSymbolsAllowed*/ true); 940 ReadOnly8Section->setAlignment(Align(8)); 941 942 ReadOnly16Section = Ctx->getXCOFFSection( 943 ".rodata.16", SectionKind::getReadOnly(), 944 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD), 945 /* MultiSymbolsAllowed*/ true); 946 ReadOnly16Section->setAlignment(Align(16)); 947 948 TLSDataSection = Ctx->getXCOFFSection( 949 ".tdata", SectionKind::getThreadData(), 950 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_TL, XCOFF::XTY_SD), 951 /* MultiSymbolsAllowed*/ true); 952 953 TOCBaseSection = Ctx->getXCOFFSection( 954 "TOC", SectionKind::getData(), 955 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_TC0, 956 XCOFF::XTY_SD)); 957 958 // The TOC-base always has 0 size, but 4 byte alignment. 959 TOCBaseSection->setAlignment(Align(4)); 960 961 LSDASection = Ctx->getXCOFFSection( 962 ".gcc_except_table", SectionKind::getReadOnly(), 963 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, 964 XCOFF::XTY_SD)); 965 966 CompactUnwindSection = Ctx->getXCOFFSection( 967 ".eh_info_table", SectionKind::getData(), 968 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RW, 969 XCOFF::XTY_SD)); 970 971 // DWARF sections for XCOFF are not csects. They are special STYP_DWARF 972 // sections, and the individual DWARF sections are distinguished by their 973 // section subtype. 974 DwarfAbbrevSection = Ctx->getXCOFFSection( 975 ".dwabrev", SectionKind::getMetadata(), 976 /* CsectProperties */ std::nullopt, 977 /* MultiSymbolsAllowed */ true, ".dwabrev", XCOFF::SSUBTYP_DWABREV); 978 979 DwarfInfoSection = Ctx->getXCOFFSection( 980 ".dwinfo", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt, 981 /* MultiSymbolsAllowed */ true, ".dwinfo", XCOFF::SSUBTYP_DWINFO); 982 983 DwarfLineSection = Ctx->getXCOFFSection( 984 ".dwline", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt, 985 /* MultiSymbolsAllowed */ true, ".dwline", XCOFF::SSUBTYP_DWLINE); 986 987 DwarfFrameSection = Ctx->getXCOFFSection( 988 ".dwframe", SectionKind::getMetadata(), 989 /* CsectProperties */ std::nullopt, 990 /* MultiSymbolsAllowed */ true, ".dwframe", XCOFF::SSUBTYP_DWFRAME); 991 992 DwarfPubNamesSection = Ctx->getXCOFFSection( 993 ".dwpbnms", SectionKind::getMetadata(), 994 /* CsectProperties */ std::nullopt, 995 /* MultiSymbolsAllowed */ true, ".dwpbnms", XCOFF::SSUBTYP_DWPBNMS); 996 997 DwarfPubTypesSection = Ctx->getXCOFFSection( 998 ".dwpbtyp", SectionKind::getMetadata(), 999 /* CsectProperties */ std::nullopt, 1000 /* MultiSymbolsAllowed */ true, ".dwpbtyp", XCOFF::SSUBTYP_DWPBTYP); 1001 1002 DwarfStrSection = Ctx->getXCOFFSection( 1003 ".dwstr", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt, 1004 /* MultiSymbolsAllowed */ true, ".dwstr", XCOFF::SSUBTYP_DWSTR); 1005 1006 DwarfLocSection = Ctx->getXCOFFSection( 1007 ".dwloc", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt, 1008 /* MultiSymbolsAllowed */ true, ".dwloc", XCOFF::SSUBTYP_DWLOC); 1009 1010 DwarfARangesSection = Ctx->getXCOFFSection( 1011 ".dwarnge", SectionKind::getMetadata(), 1012 /* CsectProperties */ std::nullopt, 1013 /* MultiSymbolsAllowed */ true, ".dwarnge", XCOFF::SSUBTYP_DWARNGE); 1014 1015 DwarfRangesSection = Ctx->getXCOFFSection( 1016 ".dwrnges", SectionKind::getMetadata(), 1017 /* CsectProperties */ std::nullopt, 1018 /* MultiSymbolsAllowed */ true, ".dwrnges", XCOFF::SSUBTYP_DWRNGES); 1019 1020 DwarfMacinfoSection = Ctx->getXCOFFSection( 1021 ".dwmac", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt, 1022 /* MultiSymbolsAllowed */ true, ".dwmac", XCOFF::SSUBTYP_DWMAC); 1023 } 1024 1025 void MCObjectFileInfo::initDXContainerObjectFileInfo(const Triple &T) { 1026 // At the moment the DXBC section should end up empty. 1027 TextSection = Ctx->getDXContainerSection("DXBC", SectionKind::getText()); 1028 } 1029 1030 MCObjectFileInfo::~MCObjectFileInfo() = default; 1031 1032 void MCObjectFileInfo::initMCObjectFileInfo(MCContext &MCCtx, bool PIC, 1033 bool LargeCodeModel) { 1034 PositionIndependent = PIC; 1035 Ctx = &MCCtx; 1036 1037 // Common. 1038 SupportsWeakOmittedEHFrame = true; 1039 SupportsCompactUnwindWithoutEHFrame = false; 1040 OmitDwarfIfHaveCompactUnwind = false; 1041 1042 FDECFIEncoding = dwarf::DW_EH_PE_absptr; 1043 1044 CompactUnwindDwarfEHFrameOnly = 0; 1045 1046 EHFrameSection = nullptr; // Created on demand. 1047 CompactUnwindSection = nullptr; // Used only by selected targets. 1048 DwarfAccelNamesSection = nullptr; // Used only by selected targets. 1049 DwarfAccelObjCSection = nullptr; // Used only by selected targets. 1050 DwarfAccelNamespaceSection = nullptr; // Used only by selected targets. 1051 DwarfAccelTypesSection = nullptr; // Used only by selected targets. 1052 1053 Triple TheTriple = Ctx->getTargetTriple(); 1054 switch (Ctx->getObjectFileType()) { 1055 case MCContext::IsMachO: 1056 initMachOMCObjectFileInfo(TheTriple); 1057 break; 1058 case MCContext::IsCOFF: 1059 initCOFFMCObjectFileInfo(TheTriple); 1060 break; 1061 case MCContext::IsELF: 1062 initELFMCObjectFileInfo(TheTriple, LargeCodeModel); 1063 break; 1064 case MCContext::IsGOFF: 1065 initGOFFMCObjectFileInfo(TheTriple); 1066 break; 1067 case MCContext::IsSPIRV: 1068 initSPIRVMCObjectFileInfo(TheTriple); 1069 break; 1070 case MCContext::IsWasm: 1071 initWasmMCObjectFileInfo(TheTriple); 1072 break; 1073 case MCContext::IsXCOFF: 1074 initXCOFFMCObjectFileInfo(TheTriple); 1075 break; 1076 case MCContext::IsDXContainer: 1077 initDXContainerObjectFileInfo(TheTriple); 1078 break; 1079 } 1080 } 1081 1082 MCSection *MCObjectFileInfo::getDwarfComdatSection(const char *Name, 1083 uint64_t Hash) const { 1084 switch (Ctx->getTargetTriple().getObjectFormat()) { 1085 case Triple::ELF: 1086 return Ctx->getELFSection(Name, ELF::SHT_PROGBITS, ELF::SHF_GROUP, 0, 1087 utostr(Hash), /*IsComdat=*/true); 1088 case Triple::Wasm: 1089 return Ctx->getWasmSection(Name, SectionKind::getMetadata(), 0, 1090 utostr(Hash), MCContext::GenericSectionID); 1091 case Triple::MachO: 1092 case Triple::COFF: 1093 case Triple::GOFF: 1094 case Triple::SPIRV: 1095 case Triple::XCOFF: 1096 case Triple::DXContainer: 1097 case Triple::UnknownObjectFormat: 1098 report_fatal_error("Cannot get DWARF comdat section for this object file " 1099 "format: not implemented."); 1100 break; 1101 } 1102 llvm_unreachable("Unknown ObjectFormatType"); 1103 } 1104 1105 MCSection * 1106 MCObjectFileInfo::getStackSizesSection(const MCSection &TextSec) const { 1107 if ((Ctx->getObjectFileType() != MCContext::IsELF) || 1108 Ctx->getTargetTriple().isPS4()) 1109 return StackSizesSection; 1110 1111 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec); 1112 unsigned Flags = ELF::SHF_LINK_ORDER; 1113 StringRef GroupName; 1114 if (const MCSymbol *Group = ElfSec.getGroup()) { 1115 GroupName = Group->getName(); 1116 Flags |= ELF::SHF_GROUP; 1117 } 1118 1119 return Ctx->getELFSection(".stack_sizes", ELF::SHT_PROGBITS, Flags, 0, 1120 GroupName, true, ElfSec.getUniqueID(), 1121 cast<MCSymbolELF>(TextSec.getBeginSymbol())); 1122 } 1123 1124 MCSection * 1125 MCObjectFileInfo::getBBAddrMapSection(const MCSection &TextSec) const { 1126 if (Ctx->getObjectFileType() != MCContext::IsELF) 1127 return nullptr; 1128 1129 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec); 1130 unsigned Flags = ELF::SHF_LINK_ORDER; 1131 StringRef GroupName; 1132 if (const MCSymbol *Group = ElfSec.getGroup()) { 1133 GroupName = Group->getName(); 1134 Flags |= ELF::SHF_GROUP; 1135 } 1136 1137 // Use the text section's begin symbol and unique ID to create a separate 1138 // .llvm_bb_addr_map section associated with every unique text section. 1139 return Ctx->getELFSection(".llvm_bb_addr_map", ELF::SHT_LLVM_BB_ADDR_MAP, 1140 Flags, 0, GroupName, true, ElfSec.getUniqueID(), 1141 cast<MCSymbolELF>(TextSec.getBeginSymbol())); 1142 } 1143 1144 MCSection * 1145 MCObjectFileInfo::getKCFITrapSection(const MCSection &TextSec) const { 1146 if (Ctx->getObjectFileType() != MCContext::IsELF) 1147 return nullptr; 1148 1149 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec); 1150 unsigned Flags = ELF::SHF_LINK_ORDER | ELF::SHF_ALLOC; 1151 StringRef GroupName; 1152 if (const MCSymbol *Group = ElfSec.getGroup()) { 1153 GroupName = Group->getName(); 1154 Flags |= ELF::SHF_GROUP; 1155 } 1156 1157 return Ctx->getELFSection(".kcfi_traps", ELF::SHT_PROGBITS, Flags, 0, 1158 GroupName, 1159 /*IsComdat=*/true, ElfSec.getUniqueID(), 1160 cast<MCSymbolELF>(TextSec.getBeginSymbol())); 1161 } 1162 1163 MCSection * 1164 MCObjectFileInfo::getPseudoProbeSection(const MCSection &TextSec) const { 1165 if (Ctx->getObjectFileType() != MCContext::IsELF) 1166 return PseudoProbeSection; 1167 1168 const auto &ElfSec = static_cast<const MCSectionELF &>(TextSec); 1169 unsigned Flags = ELF::SHF_LINK_ORDER; 1170 StringRef GroupName; 1171 if (const MCSymbol *Group = ElfSec.getGroup()) { 1172 GroupName = Group->getName(); 1173 Flags |= ELF::SHF_GROUP; 1174 } 1175 1176 return Ctx->getELFSection(PseudoProbeSection->getName(), ELF::SHT_PROGBITS, 1177 Flags, 0, GroupName, true, ElfSec.getUniqueID(), 1178 cast<MCSymbolELF>(TextSec.getBeginSymbol())); 1179 } 1180 1181 MCSection * 1182 MCObjectFileInfo::getPseudoProbeDescSection(StringRef FuncName) const { 1183 if (Ctx->getObjectFileType() == MCContext::IsELF) { 1184 // Create a separate comdat group for each function's descriptor in order 1185 // for the linker to deduplicate. The duplication, must be from different 1186 // tranlation unit, can come from: 1187 // 1. Inline functions defined in header files; 1188 // 2. ThinLTO imported funcions; 1189 // 3. Weak-linkage definitions. 1190 // Use a concatenation of the section name and the function name as the 1191 // group name so that descriptor-only groups won't be folded with groups of 1192 // code. 1193 if (Ctx->getTargetTriple().supportsCOMDAT() && !FuncName.empty()) { 1194 auto *S = static_cast<MCSectionELF *>(PseudoProbeDescSection); 1195 auto Flags = S->getFlags() | ELF::SHF_GROUP; 1196 return Ctx->getELFSection(S->getName(), S->getType(), Flags, 1197 S->getEntrySize(), 1198 S->getName() + "_" + FuncName, 1199 /*IsComdat=*/true); 1200 } 1201 } 1202 return PseudoProbeDescSection; 1203 } 1204 1205 MCSection *MCObjectFileInfo::getLLVMStatsSection() const { 1206 return LLVMStatsSection; 1207 } 1208 1209 MCSection *MCObjectFileInfo::getPCSection(StringRef Name, 1210 const MCSection *TextSec) const { 1211 if (Ctx->getObjectFileType() != MCContext::IsELF) 1212 return nullptr; 1213 1214 // SHF_WRITE for relocations, and let user post-process data in-place. 1215 unsigned Flags = ELF::SHF_WRITE | ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER; 1216 1217 if (!TextSec) 1218 TextSec = getTextSection(); 1219 1220 StringRef GroupName; 1221 const auto &ElfSec = static_cast<const MCSectionELF &>(*TextSec); 1222 if (const MCSymbol *Group = ElfSec.getGroup()) { 1223 GroupName = Group->getName(); 1224 Flags |= ELF::SHF_GROUP; 1225 } 1226 return Ctx->getELFSection(Name, ELF::SHT_PROGBITS, Flags, 0, GroupName, true, 1227 ElfSec.getUniqueID(), 1228 cast<MCSymbolELF>(TextSec->getBeginSymbol())); 1229 } 1230