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