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