LLVM 24.0.0git
MCObjectFileInfo.cpp
Go to the documentation of this file.
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
16#include "llvm/MC/MCAsmInfo.h"
17#include "llvm/MC/MCContext.h"
19#include "llvm/MC/MCSection.h"
29#include "llvm/MC/SectionKind.h"
31
32using namespace llvm;
33
34static bool useCompactUnwind(const Triple &T) {
35 // Only on darwin.
36 if (!T.isOSDarwin())
37 return false;
38
39 // aarch64 always has it.
40 if (T.getArch() == Triple::aarch64 || T.getArch() == Triple::aarch64_32)
41 return true;
42
43 // armv7k always has it.
44 if (T.isWatchABI())
45 return true;
46
47 // Use it on newer version of OS X.
48 if (T.isMacOSX() && !T.isMacOSXVersionLT(10, 6))
49 return true;
50
51 // And the iOS simulator.
52 if (T.isiOS() && T.isX86())
53 return true;
54
55 // The rest of the simulators always have it.
56 if (T.isSimulatorEnvironment())
57 return true;
58
59 // XROS always has it.
60 if (T.isXROS())
61 return true;
62
63 return false;
64}
65
66void MCObjectFileInfo::initMachOMCObjectFileInfo(const Triple &T) {
67 EHFrameSection = Ctx->getMachOSection(
68 "__TEXT", "__eh_frame",
72
73 if (T.isOSDarwin() &&
74 (T.getArch() == Triple::aarch64 || T.getArch() == Triple::aarch64_32 ||
75 T.isSimulatorEnvironment()))
77
78 switch (Ctx->emitDwarfUnwindInfo()) {
82 break;
85 break;
89 break;
90 }
91
93
94 TextSection // .text
95 = Ctx->getMachOSection("__TEXT", "__text",
98 DataSection // .data
99 = Ctx->getMachOSection("__DATA", "__data", 0, SectionKind::getData());
100
101 // BSSSection might not be expected initialized on msvc.
102 BSSSection = nullptr;
103
104 TLSDataSection // .tdata
105 = Ctx->getMachOSection("__DATA", "__thread_data",
108 TLSBSSSection // .tbss
109 = Ctx->getMachOSection("__DATA", "__thread_bss",
112
113 // TODO: Verify datarel below.
114 TLSTLVSection // .tlv
115 = Ctx->getMachOSection("__DATA", "__thread_vars",
118
119 TLSThreadInitSection = Ctx->getMachOSection(
120 "__DATA", "__thread_init", MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS,
122
123 CStringSection // .cstring
124 = Ctx->getMachOSection("__TEXT", "__cstring",
128 = Ctx->getMachOSection("__TEXT","__ustring", 0,
130 FourByteConstantSection // .literal4
131 = Ctx->getMachOSection("__TEXT", "__literal4",
134 EightByteConstantSection // .literal8
135 = Ctx->getMachOSection("__TEXT", "__literal8",
138
139 SixteenByteConstantSection // .literal16
140 = Ctx->getMachOSection("__TEXT", "__literal16",
143
144 ReadOnlySection // .const
145 = Ctx->getMachOSection("__TEXT", "__const", 0,
147
148 // If the target is not powerpc, map the coal sections to the non-coal
149 // sections.
150 //
151 // "__TEXT/__textcoal_nt" => section "__TEXT/__text"
152 // "__TEXT/__const_coal" => section "__TEXT/__const"
153 // "__DATA/__datacoal_nt" => section "__DATA/__data"
154 Triple::ArchType ArchTy = T.getArch();
155
156 ConstDataSection // .const_data
157 = Ctx->getMachOSection("__DATA", "__const", 0,
159
160 if (ArchTy == Triple::ppc || ArchTy == Triple::ppc64) {
162 = Ctx->getMachOSection("__TEXT", "__textcoal_nt",
167 = Ctx->getMachOSection("__TEXT", "__const_coal",
170 DataCoalSection = Ctx->getMachOSection(
171 "__DATA", "__datacoal_nt", MachO::S_COALESCED, SectionKind::getData());
173 } else {
178 }
179
181 = Ctx->getMachOSection("__DATA","__common",
185 = Ctx->getMachOSection("__DATA","__bss", MachO::S_ZEROFILL,
187
188
190 = Ctx->getMachOSection("__DATA", "__la_symbol_ptr",
194 = Ctx->getMachOSection("__DATA", "__nl_symbol_ptr",
197
199 = Ctx->getMachOSection("__DATA", "__thread_ptr",
202
203 AddrSigSection = Ctx->getMachOSection("__DATA", "__llvm_addrsig", 0,
205
206 // Exception Handling.
207 LSDASection = Ctx->getMachOSection("__TEXT", "__gcc_except_tab", 0,
209
210 COFFDebugSymbolsSection = nullptr;
211 COFFDebugTypesSection = nullptr;
213
214 if (useCompactUnwind(T)) {
216 Ctx->getMachOSection("__LD", "__compact_unwind", MachO::S_ATTR_DEBUG,
218
219 if (T.isX86())
220 CompactUnwindDwarfEHFrameOnly = 0x04000000; // UNWIND_X86_64_MODE_DWARF
221 else if (T.getArch() == Triple::aarch64 || T.getArch() == Triple::aarch64_32)
222 CompactUnwindDwarfEHFrameOnly = 0x03000000; // UNWIND_ARM64_MODE_DWARF
223 else if (T.getArch() == Triple::arm || T.getArch() == Triple::thumb)
224 CompactUnwindDwarfEHFrameOnly = 0x04000000; // UNWIND_ARM_MODE_DWARF
225 }
226
227 // Debug Information.
229 Ctx->getMachOSection("__DWARF", "__debug_names", MachO::S_ATTR_DEBUG,
230 SectionKind::getMetadata(), "debug_names_begin");
232 Ctx->getMachOSection("__DWARF", "__apple_names", MachO::S_ATTR_DEBUG,
233 SectionKind::getMetadata(), "names_begin");
235 Ctx->getMachOSection("__DWARF", "__apple_objc", MachO::S_ATTR_DEBUG,
236 SectionKind::getMetadata(), "objc_begin");
237 // 16 character section limit...
239 Ctx->getMachOSection("__DWARF", "__apple_namespac", MachO::S_ATTR_DEBUG,
240 SectionKind::getMetadata(), "namespac_begin");
242 Ctx->getMachOSection("__DWARF", "__apple_types", MachO::S_ATTR_DEBUG,
243 SectionKind::getMetadata(), "types_begin");
244
246 Ctx->getMachOSection("__DWARF", "__swift_ast", MachO::S_ATTR_DEBUG,
248
250 Ctx->getMachOSection("__DWARF", "__debug_abbrev", MachO::S_ATTR_DEBUG,
251 SectionKind::getMetadata(), "section_abbrev");
253 Ctx->getMachOSection("__DWARF", "__debug_info", MachO::S_ATTR_DEBUG,
254 SectionKind::getMetadata(), "section_info");
256 Ctx->getMachOSection("__DWARF", "__debug_line", MachO::S_ATTR_DEBUG,
257 SectionKind::getMetadata(), "section_line");
259 Ctx->getMachOSection("__DWARF", "__debug_line_str", MachO::S_ATTR_DEBUG,
260 SectionKind::getMetadata(), "section_line_str");
262 Ctx->getMachOSection("__DWARF", "__debug_frame", MachO::S_ATTR_DEBUG,
263 SectionKind::getMetadata(), "section_frame");
265 Ctx->getMachOSection("__DWARF", "__debug_pubnames", MachO::S_ATTR_DEBUG,
268 Ctx->getMachOSection("__DWARF", "__debug_pubtypes", MachO::S_ATTR_DEBUG,
271 Ctx->getMachOSection("__DWARF", "__debug_gnu_pubn", MachO::S_ATTR_DEBUG,
274 Ctx->getMachOSection("__DWARF", "__debug_gnu_pubt", MachO::S_ATTR_DEBUG,
277 Ctx->getMachOSection("__DWARF", "__debug_str", MachO::S_ATTR_DEBUG,
278 SectionKind::getMetadata(), "info_string");
280 Ctx->getMachOSection("__DWARF", "__debug_str_offs", MachO::S_ATTR_DEBUG,
281 SectionKind::getMetadata(), "section_str_off");
283 Ctx->getMachOSection("__DWARF", "__debug_addr", MachO::S_ATTR_DEBUG,
284 SectionKind::getMetadata(), "section_info");
286 Ctx->getMachOSection("__DWARF", "__debug_loc", MachO::S_ATTR_DEBUG,
287 SectionKind::getMetadata(), "section_debug_loc");
289 Ctx->getMachOSection("__DWARF", "__debug_loclists", MachO::S_ATTR_DEBUG,
290 SectionKind::getMetadata(), "section_debug_loc");
291
293 Ctx->getMachOSection("__DWARF", "__debug_aranges", MachO::S_ATTR_DEBUG,
296 Ctx->getMachOSection("__DWARF", "__debug_ranges", MachO::S_ATTR_DEBUG,
297 SectionKind::getMetadata(), "debug_range");
299 Ctx->getMachOSection("__DWARF", "__debug_rnglists", MachO::S_ATTR_DEBUG,
300 SectionKind::getMetadata(), "debug_range");
302 Ctx->getMachOSection("__DWARF", "__debug_macinfo", MachO::S_ATTR_DEBUG,
303 SectionKind::getMetadata(), "debug_macinfo");
305 Ctx->getMachOSection("__DWARF", "__debug_macro", MachO::S_ATTR_DEBUG,
306 SectionKind::getMetadata(), "debug_macro");
308 Ctx->getMachOSection("__DWARF", "__debug_inlined", MachO::S_ATTR_DEBUG,
311 Ctx->getMachOSection("__DWARF", "__debug_cu_index", MachO::S_ATTR_DEBUG,
314 Ctx->getMachOSection("__DWARF", "__debug_tu_index", MachO::S_ATTR_DEBUG,
316 StackMapSection = Ctx->getMachOSection("__LLVM_STACKMAPS", "__llvm_stackmaps",
318
319 FaultMapSection = Ctx->getMachOSection("__LLVM_FAULTMAPS", "__llvm_faultmaps",
321
322 RemarksSection = Ctx->getMachOSection(
323 "__LLVM", "__remarks", MachO::S_ATTR_DEBUG, SectionKind::getMetadata());
324
325 // Emit the pseudoprobe sections in the __LLVM segment. Current ld ignores the
326 // __LLVM and __DWARF segment, so the probe metadata is dropped from the final
327 // linked image on every toolchain.
328 PseudoProbeSection = Ctx->getMachOSection(
329 "__LLVM", "__probes", MachO::S_ATTR_DEBUG | MachO::S_ATTR_NO_DEAD_STRIP,
332 Ctx->getMachOSection("__LLVM", "__probe_descs",
335
336 // The architecture of dsymutil makes it very difficult to copy the Swift
337 // reflection metadata sections into the __TEXT segment, so dsymutil creates
338 // these sections in the __DWARF segment instead.
339 if (!Ctx->getSwift5ReflectionSegmentName().empty()) {
340#define HANDLE_SWIFT_SECTION(KIND, MACHO, ELF, COFF) \
341 Swift5ReflectionSections \
342 [llvm::binaryformat::Swift5ReflectionSectionKind::KIND] = \
343 Ctx->getMachOSection(Ctx->getSwift5ReflectionSegmentName().data(), \
344 MACHO, 0, SectionKind::getMetadata());
345#include "llvm/BinaryFormat/Swift.def"
346 }
347
349}
350
351void MCObjectFileInfo::initELFMCObjectFileInfo(const Triple &T, bool Large) {
352 switch (T.getArch()) {
353 case Triple::mips:
354 case Triple::mipsel:
355 case Triple::mips64:
356 case Triple::mips64el:
357 case Triple::nanomips:
358 // We cannot use DW_EH_PE_sdata8 for the large PositionIndependent case
359 // since there is no R_MIPS_PC64 relocation (only a 32-bit version).
360 // In fact DW_EH_PE_sdata4 is enough for us now, and GNU ld doesn't
361 // support pcrel|sdata8 well. Let's use sdata4 for now.
362 if (PositionIndependent)
364 else
365 FDECFIEncoding = Ctx->getAsmInfo().getCodePointerSize() == 4
368 break;
369 case Triple::ppc64:
370 case Triple::ppc64le:
371 case Triple::aarch64:
373 case Triple::x86_64:
375 ((Large || Ctx->getTargetOptions().LargeEHEncoding)
378 break;
379 case Triple::bpfel:
380 case Triple::bpfeb:
382 break;
383 case Triple::hexagon:
385 PositionIndependent ? dwarf::DW_EH_PE_pcrel : dwarf::DW_EH_PE_absptr;
386 break;
387 case Triple::xtensa:
389 break;
390 default:
392 break;
393 }
394
395 unsigned EHSectionType = T.getArch() == Triple::x86_64
398 switch (T.getArch()) {
399 case Triple::x86_64:
400 SFrameABIArch = sframe::ABI::AMD64EndianLittle;
401 break;
402 case Triple::aarch64:
403 SFrameABIArch = sframe::ABI::AArch64EndianLittle;
404 break;
406 SFrameABIArch = sframe::ABI::AArch64EndianBig;
407 break;
408 default:
409 break;
410 }
411
412 // Solaris requires different flags for .eh_frame to seemingly every other
413 // platform.
414 unsigned EHSectionFlags = ELF::SHF_ALLOC;
415 if (T.isOSSolaris() && T.getArch() != Triple::x86_64)
416 EHSectionFlags |= ELF::SHF_WRITE;
417
418 // ELF
419 BSSSection = Ctx->getELFSection(".bss", ELF::SHT_NOBITS,
421
422 TextSection = Ctx->getELFSection(".text", ELF::SHT_PROGBITS,
424
425 DataSection = Ctx->getELFSection(".data", ELF::SHT_PROGBITS,
427
429 Ctx->getELFSection(".rodata", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
430
432 Ctx->getELFSection(".tdata", ELF::SHT_PROGBITS,
434
435 TLSBSSSection = Ctx->getELFSection(
437
438 DataRelROSection = Ctx->getELFSection(".data.rel.ro", ELF::SHT_PROGBITS,
440
441 MergeableConst4Section = Ctx->getELFSection(
442 ".rodata.cst4", ELF::SHT_PROGBITS, ELF::SHF_ALLOC | ELF::SHF_MERGE, 4);
443
444 MergeableConst8Section = Ctx->getELFSection(
445 ".rodata.cst8", ELF::SHT_PROGBITS, ELF::SHF_ALLOC | ELF::SHF_MERGE, 8);
446
447 MergeableConst16Section = Ctx->getELFSection(
448 ".rodata.cst16", ELF::SHT_PROGBITS, ELF::SHF_ALLOC | ELF::SHF_MERGE, 16);
449
450 MergeableConst32Section = Ctx->getELFSection(
451 ".rodata.cst32", ELF::SHT_PROGBITS, ELF::SHF_ALLOC | ELF::SHF_MERGE, 32);
452
453 // Exception Handling Sections.
454
455 // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
456 // it contains relocatable pointers. In PIC mode, this is probably a big
457 // runtime hit for C++ apps. Either the contents of the LSDA need to be
458 // adjusted or this should be a data section.
459 LSDASection = Ctx->getELFSection(".gcc_except_table", ELF::SHT_PROGBITS,
461
462 COFFDebugSymbolsSection = nullptr;
463 COFFDebugTypesSection = nullptr;
464
465 unsigned DebugSecType = ELF::SHT_PROGBITS;
466
467 // MIPS .debug_* sections should have SHT_MIPS_DWARF section type
468 // to distinguish among sections contain DWARF and ECOFF debug formats.
469 // Sections with ECOFF debug format are obsoleted and marked by SHT_PROGBITS.
470 if (T.isMIPS())
471 DebugSecType = ELF::SHT_MIPS_DWARF;
472
473 // Debug Info Sections.
475 Ctx->getELFSection(".debug_abbrev", DebugSecType, 0);
476 DwarfInfoSection = Ctx->getELFSection(".debug_info", DebugSecType, 0);
477 DwarfLineSection = Ctx->getELFSection(".debug_line", DebugSecType, 0);
479 Ctx->getELFSection(".debug_line_str", DebugSecType,
481 DwarfFrameSection = Ctx->getELFSection(".debug_frame", DebugSecType, 0);
483 Ctx->getELFSection(".debug_pubnames", DebugSecType, 0);
485 Ctx->getELFSection(".debug_pubtypes", DebugSecType, 0);
487 Ctx->getELFSection(".debug_gnu_pubnames", DebugSecType, 0);
489 Ctx->getELFSection(".debug_gnu_pubtypes", DebugSecType, 0);
491 Ctx->getELFSection(".debug_str", DebugSecType,
493 DwarfLocSection = Ctx->getELFSection(".debug_loc", DebugSecType, 0);
495 Ctx->getELFSection(".debug_aranges", DebugSecType, 0);
497 Ctx->getELFSection(".debug_ranges", DebugSecType, 0);
499 Ctx->getELFSection(".debug_macinfo", DebugSecType, 0);
500 DwarfMacroSection = Ctx->getELFSection(".debug_macro", DebugSecType, 0);
501
502 // DWARF5 Experimental Debug Info
503
504 // Accelerator Tables
506 Ctx->getELFSection(".debug_names", ELF::SHT_PROGBITS, 0);
508 Ctx->getELFSection(".apple_names", ELF::SHT_PROGBITS, 0);
510 Ctx->getELFSection(".apple_objc", ELF::SHT_PROGBITS, 0);
512 Ctx->getELFSection(".apple_namespaces", ELF::SHT_PROGBITS, 0);
514 Ctx->getELFSection(".apple_types", ELF::SHT_PROGBITS, 0);
515
516 // String Offset and Address Sections
518 Ctx->getELFSection(".debug_str_offsets", DebugSecType, 0);
519 DwarfAddrSection = Ctx->getELFSection(".debug_addr", DebugSecType, 0);
520 DwarfRnglistsSection = Ctx->getELFSection(".debug_rnglists", DebugSecType, 0);
521 DwarfLoclistsSection = Ctx->getELFSection(".debug_loclists", DebugSecType, 0);
522
523 // Fission Sections
525 Ctx->getELFSection(".debug_info.dwo", DebugSecType, ELF::SHF_EXCLUDE);
527 Ctx->getELFSection(".debug_types.dwo", DebugSecType, ELF::SHF_EXCLUDE);
529 Ctx->getELFSection(".debug_abbrev.dwo", DebugSecType, ELF::SHF_EXCLUDE);
530 DwarfStrDWOSection = Ctx->getELFSection(
531 ".debug_str.dwo", DebugSecType,
534 Ctx->getELFSection(".debug_line.dwo", DebugSecType, ELF::SHF_EXCLUDE);
536 Ctx->getELFSection(".debug_loc.dwo", DebugSecType, ELF::SHF_EXCLUDE);
537 DwarfStrOffDWOSection = Ctx->getELFSection(".debug_str_offsets.dwo",
538 DebugSecType, ELF::SHF_EXCLUDE);
540 Ctx->getELFSection(".debug_rnglists.dwo", DebugSecType, ELF::SHF_EXCLUDE);
542 Ctx->getELFSection(".debug_macinfo.dwo", DebugSecType, ELF::SHF_EXCLUDE);
544 Ctx->getELFSection(".debug_macro.dwo", DebugSecType, ELF::SHF_EXCLUDE);
545
547 Ctx->getELFSection(".debug_loclists.dwo", DebugSecType, ELF::SHF_EXCLUDE);
548
549 // DWP Sections
551 Ctx->getELFSection(".debug_cu_index", DebugSecType, 0);
553 Ctx->getELFSection(".debug_tu_index", DebugSecType, 0);
554
556 Ctx->getELFSection(".llvm_stackmaps", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
557
559 Ctx->getELFSection(".llvm_faultmaps", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
560
562 Ctx->getELFSection(".eh_frame", EHSectionType, EHSectionFlags);
563
565 Ctx->getELFSection(".sframe", ELF::SHT_GNU_SFRAME, ELF::SHF_ALLOC);
566
567 StackSizesSection = Ctx->getELFSection(".stack_sizes", ELF::SHT_PROGBITS, 0);
568
569 PseudoProbeSection = Ctx->getELFSection(".pseudo_probe", DebugSecType, 0);
571 Ctx->getELFSection(".pseudo_probe_desc", DebugSecType, 0);
572
573 LLVMStatsSection = Ctx->getELFSection(".llvm_stats", ELF::SHT_PROGBITS, 0);
574}
575
576void MCObjectFileInfo::initGOFFMCObjectFileInfo(const Triple &T) {
577 MCSectionGOFF *RootSDSection = Ctx->getGOFFSection(
580
581 MCSectionGOFF *ADAEDSection = Ctx->getGOFFSection(
583 GOFF::EDAttr{false, GOFF::ESD_RMODE_64, GOFF::ESD_NS_Parts,
586 RootSDSection);
587 ADAEDSection->setAlignment(Align(16)); // Quadword
588 ADASection = Ctx->getGOFFSection(
589 SectionKind::getData(), "#S",
590 GOFF::PRAttr{false, GOFF::ESD_EXE_DATA, GOFF::ESD_BST_Strong,
592 ADAEDSection);
593
594 TextSection = Ctx->getGOFFSection(
599 RootSDSection);
600 TextSection->setAlignment(Align(8)); // Doubleword
601
602 MCSectionGOFF *PPA2ListEDSection = Ctx->getGOFFSection(
604 GOFF::EDAttr{true, GOFF::ESD_RMODE_64, GOFF::ESD_NS_Parts,
607 RootSDSection);
608 PPA2ListEDSection->setAlignment(Align(8)); // Doubleword
609 PPA2ListSection = Ctx->getGOFFSection(
610 SectionKind::getData(), ".&ppa2",
611 GOFF::PRAttr{true, GOFF::ESD_EXE_DATA, GOFF::ESD_BST_Strong,
613 PPA2ListEDSection);
614
615 IDRLSection = Ctx->getGOFFSection(
616 SectionKind::getData(), "B_IDRL",
620 RootSDSection);
621 IDRLSection->setAlignment(Align(8)); // Doubleword
622
623 // Debug Info Sections. The ED name is the same used by the XL compiler.
624 auto InitDebugSection = [this,
625 RootSDSection](StringRef EDName,
626 StringRef LDName) -> MCSectionGOFF * {
627 MCSectionGOFF *ED = Ctx->getGOFFSection(
628 SectionKind::getMetadata(), EDName,
629 GOFF::EDAttr{false, GOFF::ESD_RMODE_64, GOFF::ESD_NS_Parts,
632 RootSDSection);
633 ED->setAlignment(Align(8)); // Doubleword
634 // At least for llc, this function is called twice! (See function
635 // compileModule() in llc.cpp). Since the context is not cleared, the
636 // already allocated section is returned above. We only add the begin symbol
637 // if it is not yet set to avoid an assertion.
638 MCSymbolGOFF *LD = static_cast<MCSymbolGOFF *>(ED->getBeginSymbol());
639 if (!LD) {
640 LD = static_cast<MCSymbolGOFF *>(getContext().getOrCreateSymbol(LDName));
641 LD->setCodeData(GOFF::ESD_EXE_DATA);
642 LD->setWeak(false);
643 LD->setLinkage(GOFF::ESD_LT_XPLink);
644 LD->setExternal(false);
645 LD->setADA(ED);
646 ED->setBeginSymbol(LD);
647 } else
648 assert(LD->getName() == LDName && "Wrong label name");
649 return ED;
650 };
651 DwarfAbbrevSection = InitDebugSection("D_ABREV", ".debug_abbrev");
652 DwarfInfoSection = InitDebugSection("D_INFO", ".debug_info");
653 DwarfLineSection = InitDebugSection("D_LINE", ".debug_line");
654 DwarfFrameSection = InitDebugSection("D_FRAME", ".debug_frame");
655 DwarfPubNamesSection = InitDebugSection("D_PBNMS", ".debug_pubnames");
656 DwarfPubTypesSection = InitDebugSection("D_PTYPES", ".debug_pubtypes");
657 DwarfStrSection = InitDebugSection("D_STR", ".debug_str");
658 DwarfLocSection = InitDebugSection("D_LOC", ".debug_loc");
659 DwarfARangesSection = InitDebugSection("D_ARNGE", ".debug_aranges");
660 DwarfRangesSection = InitDebugSection("D_RNGES", ".debug_ranges");
661 DwarfMacinfoSection = InitDebugSection("D_MACIN", ".debug_macinfo");
662
663 // DWARF 5 sections.
664 DwarfDebugNamesSection = InitDebugSection("D_NAMES", ".debug_names");
665 DwarfStrOffSection = InitDebugSection("D_STROFFS", ".debug_str_offsets");
666 DwarfAddrSection = InitDebugSection("D_ADDR", ".debug_addr");
667 DwarfRnglistsSection = InitDebugSection("D_RNGLISTS", ".debug_rnglists");
668 DwarfLoclistsSection = InitDebugSection("D_LOCLISTS", ".debug_loclists");
669 DwarfLineStrSection = InitDebugSection("D_LINESTR", ".debug_line_str");
670
671 // Special GNU sections.
672 DwarfGnuPubNamesSection = InitDebugSection("D_GPBNMS", ".debug_gnu_pubnames");
674 InitDebugSection("D_GPTYPES", ".debug_gnu_pubtypes");
675
676 // Accelerator Tables.
677 DwarfAccelNamesSection = InitDebugSection("D_APPLNMS", ".apple_names");
679 InitDebugSection("D_APPLNMSP", ".apple_namespaces");
680 DwarfAccelTypesSection = InitDebugSection("D_APPLTYPS", ".apple_types");
681 DwarfAccelObjCSection = InitDebugSection("D_APPLOBJC", ".apple_objc");
682
683 // Fission Sections
684 DwarfInfoDWOSection = InitDebugSection("D_INFO_DWO", ".debug_info.dwo");
685 DwarfTypesDWOSection = InitDebugSection("D_TYPES_DWO", ".debug_types.dwo");
686 DwarfAbbrevDWOSection = InitDebugSection("D_ABREV_DWO", ".debug_abbrev.dwo");
687 DwarfStrDWOSection = InitDebugSection("D_STR_DWO", ".debug_str.dwo");
688 DwarfLineDWOSection = InitDebugSection("D_LINE_DWO", ".debug_line.dwo");
689 DwarfLocDWOSection = InitDebugSection("D_LOC_DWO", ".debug_loc.dwo");
691 InitDebugSection("D_STROFFS_DWO", ".debug_str_offsets.dwo");
693 InitDebugSection("D_RNGLISTS_DWO", ".debug_rnglists.dwo");
695 InitDebugSection("D_MACINFO_DWO", ".debug_macinfo.dwo");
696 DwarfMacroDWOSection = InitDebugSection("D_MACRO_DWO", ".debug_macro.dwo");
698 InitDebugSection("D_LOCLISTS_DWO", ".debug_loclists.dwo");
699}
700
701void MCObjectFileInfo::initCOFFMCObjectFileInfo(const Triple &T) {
703 Ctx->getCOFFSection(".eh_frame", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
705
706 // Set the `IMAGE_SCN_MEM_16BIT` flag when compiling for thumb mode. This is
707 // used to indicate to the linker that the text segment contains thumb instructions
708 // and to set the ISA selection bit for calls accordingly.
709 const bool IsThumb = T.getArch() == Triple::thumb;
710
711 // COFF
712 BSSSection = Ctx->getCOFFSection(
715 TextSection = Ctx->getCOFFSection(
716 ".text",
720 DataSection = Ctx->getCOFFSection(
724 Ctx->getCOFFSection(".rdata", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
726
727 if (T.getArch() == Triple::x86_64 || T.getArch() == Triple::aarch64 ||
728 T.getArch() == Triple::arm || T.getArch() == Triple::thumb) {
729 // On Windows with SEH, the LSDA is emitted into the .xdata section
730 LSDASection = nullptr;
731 } else {
732 LSDASection = Ctx->getCOFFSection(".gcc_except_table",
735 }
736
737 if (T.getArch() == Triple::aarch64) {
739 Ctx->getCOFFSection(".impcall", COFF::IMAGE_SCN_LNK_INFO);
740 } else if (T.getArch() == Triple::x86_64) {
741 // Import Call Optimization on x64 leverages the same metadata as the
742 // retpoline mitigation, hence the unusual section name.
744 Ctx->getCOFFSection(".retplne", COFF::IMAGE_SCN_LNK_INFO);
745 }
746
747 // Debug info.
749 Ctx->getCOFFSection(".debug$S", (COFF::IMAGE_SCN_MEM_DISCARDABLE |
753 Ctx->getCOFFSection(".debug$T", (COFF::IMAGE_SCN_MEM_DISCARDABLE |
757 Ctx->getCOFFSection(".debug$H", (COFF::IMAGE_SCN_MEM_DISCARDABLE |
760
761 DwarfAbbrevSection = Ctx->getCOFFSection(
762 ".debug_abbrev", COFF::IMAGE_SCN_MEM_DISCARDABLE |
765 DwarfInfoSection = Ctx->getCOFFSection(
766 ".debug_info", COFF::IMAGE_SCN_MEM_DISCARDABLE |
769 DwarfLineSection = Ctx->getCOFFSection(
770 ".debug_line", COFF::IMAGE_SCN_MEM_DISCARDABLE |
773 DwarfLineStrSection = Ctx->getCOFFSection(
774 ".debug_line_str", COFF::IMAGE_SCN_MEM_DISCARDABLE |
777 DwarfFrameSection = Ctx->getCOFFSection(
778 ".debug_frame", COFF::IMAGE_SCN_MEM_DISCARDABLE |
781 DwarfPubNamesSection = Ctx->getCOFFSection(
782 ".debug_pubnames", COFF::IMAGE_SCN_MEM_DISCARDABLE |
785 DwarfPubTypesSection = Ctx->getCOFFSection(
786 ".debug_pubtypes", COFF::IMAGE_SCN_MEM_DISCARDABLE |
789 DwarfGnuPubNamesSection = Ctx->getCOFFSection(
790 ".debug_gnu_pubnames", COFF::IMAGE_SCN_MEM_DISCARDABLE |
793 DwarfGnuPubTypesSection = Ctx->getCOFFSection(
794 ".debug_gnu_pubtypes", COFF::IMAGE_SCN_MEM_DISCARDABLE |
797 DwarfStrSection = Ctx->getCOFFSection(
798 ".debug_str", COFF::IMAGE_SCN_MEM_DISCARDABLE |
801 DwarfStrOffSection = Ctx->getCOFFSection(
802 ".debug_str_offsets", COFF::IMAGE_SCN_MEM_DISCARDABLE |
805 DwarfLocSection = Ctx->getCOFFSection(
806 ".debug_loc", COFF::IMAGE_SCN_MEM_DISCARDABLE |
809 DwarfLoclistsSection = Ctx->getCOFFSection(
810 ".debug_loclists", COFF::IMAGE_SCN_MEM_DISCARDABLE |
813 DwarfARangesSection = Ctx->getCOFFSection(
814 ".debug_aranges", COFF::IMAGE_SCN_MEM_DISCARDABLE |
817 DwarfRangesSection = Ctx->getCOFFSection(
818 ".debug_ranges", COFF::IMAGE_SCN_MEM_DISCARDABLE |
821 DwarfRnglistsSection = Ctx->getCOFFSection(
822 ".debug_rnglists", COFF::IMAGE_SCN_MEM_DISCARDABLE |
825 DwarfMacinfoSection = Ctx->getCOFFSection(
826 ".debug_macinfo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
829 DwarfMacroSection = Ctx->getCOFFSection(
830 ".debug_macro", COFF::IMAGE_SCN_MEM_DISCARDABLE |
833 DwarfMacinfoDWOSection = Ctx->getCOFFSection(
834 ".debug_macinfo.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
838 DwarfMacroDWOSection = Ctx->getCOFFSection(
839 ".debug_macro.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
843 DwarfInfoDWOSection = Ctx->getCOFFSection(
844 ".debug_info.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
848 DwarfTypesDWOSection = Ctx->getCOFFSection(
849 ".debug_types.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
853 DwarfAbbrevDWOSection = Ctx->getCOFFSection(
854 ".debug_abbrev.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
858 DwarfStrDWOSection = Ctx->getCOFFSection(
859 ".debug_str.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
863 DwarfLineDWOSection = Ctx->getCOFFSection(
864 ".debug_line.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
868 DwarfLocDWOSection = Ctx->getCOFFSection(
869 ".debug_loc.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
873 DwarfLoclistsDWOSection = Ctx->getCOFFSection(
874 ".debug_loclists.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
878 DwarfStrOffDWOSection = Ctx->getCOFFSection(
879 ".debug_str_offsets.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
883 DwarfRnglistsDWOSection = Ctx->getCOFFSection(
884 ".debug_rnglists.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
888 DwarfAddrSection = Ctx->getCOFFSection(
889 ".debug_addr", COFF::IMAGE_SCN_MEM_DISCARDABLE |
892 DwarfCUIndexSection = Ctx->getCOFFSection(
893 ".debug_cu_index", COFF::IMAGE_SCN_MEM_DISCARDABLE |
896 DwarfTUIndexSection = Ctx->getCOFFSection(
897 ".debug_tu_index", COFF::IMAGE_SCN_MEM_DISCARDABLE |
900 DwarfDebugNamesSection = Ctx->getCOFFSection(
901 ".debug_names", COFF::IMAGE_SCN_MEM_DISCARDABLE |
904 DwarfAccelNamesSection = Ctx->getCOFFSection(
905 ".apple_names", COFF::IMAGE_SCN_MEM_DISCARDABLE |
908 DwarfAccelNamespaceSection = Ctx->getCOFFSection(
909 ".apple_namespaces", COFF::IMAGE_SCN_MEM_DISCARDABLE |
912 DwarfAccelTypesSection = Ctx->getCOFFSection(
913 ".apple_types", COFF::IMAGE_SCN_MEM_DISCARDABLE |
916 DwarfAccelObjCSection = Ctx->getCOFFSection(
917 ".apple_objc", COFF::IMAGE_SCN_MEM_DISCARDABLE |
920
921 DrectveSection = Ctx->getCOFFSection(
923
925 Ctx->getCOFFSection(".pdata", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
927
929 Ctx->getCOFFSection(".xdata", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
931
932 SXDataSection = Ctx->getCOFFSection(".sxdata", COFF::IMAGE_SCN_LNK_INFO);
933
935 Ctx->getCOFFSection(".gehcont$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
937
939 Ctx->getCOFFSection(".gfids$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
941
943 Ctx->getCOFFSection(".giats$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
945
947 Ctx->getCOFFSection(".gljmp$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
949
950 TLSDataSection = Ctx->getCOFFSection(
953
954 StackMapSection = Ctx->getCOFFSection(".llvm_stackmaps",
957
958 // Set IMAGE_SCN_MEM_DISCARDABLE so that lld will not truncate section name.
959 PseudoProbeSection = Ctx->getCOFFSection(
960 ".pseudo_probe", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
963 PseudoProbeDescSection = Ctx->getCOFFSection(
964 ".pseudo_probe_desc", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
967}
968
969void MCObjectFileInfo::initSPIRVMCObjectFileInfo(const Triple &T) {
970 // Put everything in a single binary section.
971 TextSection = Ctx->getSPIRVSection();
972}
973
974void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
975 TextSection = Ctx->getWasmSection(".text", SectionKind::getText());
976 DataSection = Ctx->getWasmSection(".data", SectionKind::getData());
977
979 Ctx->getWasmSection(".debug_line", SectionKind::getMetadata());
981 Ctx->getWasmSection(".debug_line_str", SectionKind::getMetadata(),
983 DwarfStrSection = Ctx->getWasmSection(
986 Ctx->getWasmSection(".debug_loc", SectionKind::getMetadata());
988 Ctx->getWasmSection(".debug_abbrev", SectionKind::getMetadata());
989 DwarfARangesSection = Ctx->getWasmSection(".debug_aranges", SectionKind::getMetadata());
991 Ctx->getWasmSection(".debug_ranges", SectionKind::getMetadata());
993 Ctx->getWasmSection(".debug_macinfo", SectionKind::getMetadata());
995 Ctx->getWasmSection(".debug_macro", SectionKind::getMetadata());
996 DwarfCUIndexSection = Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata());
997 DwarfTUIndexSection = Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata());
999 Ctx->getWasmSection(".debug_info", SectionKind::getMetadata());
1000 DwarfFrameSection = Ctx->getWasmSection(".debug_frame", SectionKind::getMetadata());
1001 DwarfPubNamesSection = Ctx->getWasmSection(".debug_pubnames", SectionKind::getMetadata());
1002 DwarfPubTypesSection = Ctx->getWasmSection(".debug_pubtypes", SectionKind::getMetadata());
1004 Ctx->getWasmSection(".debug_gnu_pubnames", SectionKind::getMetadata());
1006 Ctx->getWasmSection(".debug_gnu_pubtypes", SectionKind::getMetadata());
1007
1009 Ctx->getWasmSection(".debug_names", SectionKind::getMetadata());
1011 Ctx->getWasmSection(".debug_str_offsets", SectionKind::getMetadata());
1013 Ctx->getWasmSection(".debug_addr", SectionKind::getMetadata());
1015 Ctx->getWasmSection(".debug_rnglists", SectionKind::getMetadata());
1017 Ctx->getWasmSection(".debug_loclists", SectionKind::getMetadata());
1018
1019 // Fission Sections
1021 Ctx->getWasmSection(".debug_info.dwo", SectionKind::getMetadata());
1023 Ctx->getWasmSection(".debug_types.dwo", SectionKind::getMetadata());
1025 Ctx->getWasmSection(".debug_abbrev.dwo", SectionKind::getMetadata());
1027 Ctx->getWasmSection(".debug_str.dwo", SectionKind::getMetadata(),
1030 Ctx->getWasmSection(".debug_line.dwo", SectionKind::getMetadata());
1032 Ctx->getWasmSection(".debug_loc.dwo", SectionKind::getMetadata());
1034 Ctx->getWasmSection(".debug_str_offsets.dwo", SectionKind::getMetadata());
1036 Ctx->getWasmSection(".debug_rnglists.dwo", SectionKind::getMetadata());
1038 Ctx->getWasmSection(".debug_macinfo.dwo", SectionKind::getMetadata());
1040 Ctx->getWasmSection(".debug_macro.dwo", SectionKind::getMetadata());
1041
1043 Ctx->getWasmSection(".debug_loclists.dwo", SectionKind::getMetadata());
1044
1045 // DWP Sections
1047 Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata());
1049 Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata());
1050
1051 // Wasm use data section for LSDA.
1052 // TODO Consider putting each function's exception table in a separate
1053 // section, as in -function-sections, to facilitate lld's --gc-section.
1054 LSDASection = Ctx->getWasmSection(".rodata.gcc_except_table",
1056
1057 // TODO: Define more sections.
1058}
1059
1060void MCObjectFileInfo::initXCOFFMCObjectFileInfo(const Triple &T) {
1061 // The default csect for program code. Functions without a specified section
1062 // get placed into this csect. The choice of csect name is not a property of
1063 // the ABI or object file format, but various tools rely on the section
1064 // name being empty (considering named symbols to be "user symbol names").
1065 TextSection = Ctx->getXCOFFSection(
1066 "..text..", // Use a non-null name to work around an AIX assembler bug...
1068 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_PR, XCOFF::XTY_SD),
1069 /* MultiSymbolsAllowed*/ true);
1070
1071 // ... but use a null name when generating the symbol table.
1072 MCSectionXCOFF *TS = static_cast<MCSectionXCOFF *>(TextSection);
1074 TS->setSymbolTableName("");
1075
1076 DataSection = Ctx->getXCOFFSection(
1077 ".data", SectionKind::getData(),
1078 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RW, XCOFF::XTY_SD),
1079 /* MultiSymbolsAllowed*/ true);
1080
1081 ReadOnlySection = Ctx->getXCOFFSection(
1082 ".rodata", SectionKind::getReadOnly(),
1083 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD),
1084 /* MultiSymbolsAllowed*/ true);
1085 ReadOnlySection->setAlignment(Align(4));
1086
1087 ReadOnly8Section = Ctx->getXCOFFSection(
1088 ".rodata.8", SectionKind::getReadOnly(),
1089 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD),
1090 /* MultiSymbolsAllowed*/ true);
1091 ReadOnly8Section->setAlignment(Align(8));
1092
1093 ReadOnly16Section = Ctx->getXCOFFSection(
1094 ".rodata.16", SectionKind::getReadOnly(),
1095 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD),
1096 /* MultiSymbolsAllowed*/ true);
1097 ReadOnly16Section->setAlignment(Align(16));
1098
1099 TLSDataSection = Ctx->getXCOFFSection(
1100 ".tdata", SectionKind::getThreadData(),
1101 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_TL, XCOFF::XTY_SD),
1102 /* MultiSymbolsAllowed*/ true);
1103
1104 TOCBaseSection = Ctx->getXCOFFSection(
1105 "TOC", SectionKind::getData(),
1106 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_TC0,
1107 XCOFF::XTY_SD));
1108
1109 // The TOC-base always has 0 size, but 4 byte alignment.
1110 TOCBaseSection->setAlignment(Align(4));
1111
1112 LSDASection = Ctx->getXCOFFSection(
1113 ".gcc_except_table", SectionKind::getReadOnly(),
1114 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO,
1115 XCOFF::XTY_SD));
1116
1117 CompactUnwindSection = Ctx->getXCOFFSection(
1118 ".eh_info_table", SectionKind::getData(),
1119 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RW,
1120 XCOFF::XTY_SD));
1121
1122 // DWARF sections for XCOFF are not csects. They are special STYP_DWARF
1123 // sections, and the individual DWARF sections are distinguished by their
1124 // section subtype.
1125 DwarfAbbrevSection = Ctx->getXCOFFSection(
1126 ".dwabrev", SectionKind::getMetadata(),
1127 /* CsectProperties */ std::nullopt,
1128 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWABREV);
1129
1130 DwarfInfoSection = Ctx->getXCOFFSection(
1131 ".dwinfo", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1132 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWINFO);
1133
1134 DwarfLineSection = Ctx->getXCOFFSection(
1135 ".dwline", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1136 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWLINE);
1137
1138 DwarfFrameSection = Ctx->getXCOFFSection(
1139 ".dwframe", SectionKind::getMetadata(),
1140 /* CsectProperties */ std::nullopt,
1141 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWFRAME);
1142
1143 DwarfPubNamesSection = Ctx->getXCOFFSection(
1144 ".dwpbnms", SectionKind::getMetadata(),
1145 /* CsectProperties */ std::nullopt,
1146 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWPBNMS);
1147
1148 DwarfPubTypesSection = Ctx->getXCOFFSection(
1149 ".dwpbtyp", SectionKind::getMetadata(),
1150 /* CsectProperties */ std::nullopt,
1151 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWPBTYP);
1152
1153 DwarfStrSection = Ctx->getXCOFFSection(
1154 ".dwstr", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1155 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWSTR);
1156
1157 DwarfLocSection = Ctx->getXCOFFSection(
1158 ".dwloc", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1159 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWLOC);
1160
1161 DwarfARangesSection = Ctx->getXCOFFSection(
1162 ".dwarnge", SectionKind::getMetadata(),
1163 /* CsectProperties */ std::nullopt,
1164 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWARNGE);
1165
1166 DwarfRangesSection = Ctx->getXCOFFSection(
1167 ".dwrnges", SectionKind::getMetadata(),
1168 /* CsectProperties */ std::nullopt,
1169 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWRNGES);
1170
1171 DwarfMacinfoSection = Ctx->getXCOFFSection(
1172 ".dwmac", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1173 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWMAC);
1174}
1175
1176void MCObjectFileInfo::initDXContainerObjectFileInfo(const Triple &T) {
1177 // At the moment the DXBC section should end up empty.
1178 TextSection = Ctx->getDXContainerSection("DXBC", SectionKind::getText());
1179}
1180
1182
1184 bool LargeCodeModel) {
1185 PositionIndependent = PIC;
1186 Ctx = &MCCtx;
1187
1188 // Common.
1191
1193
1195
1196 EHFrameSection = nullptr; // Created on demand.
1197 SFrameSection = nullptr; // Created on demand.
1198 CompactUnwindSection = nullptr; // Used only by selected targets.
1199 DwarfAccelNamesSection = nullptr; // Used only by selected targets.
1200 DwarfAccelObjCSection = nullptr; // Used only by selected targets.
1201 DwarfAccelNamespaceSection = nullptr; // Used only by selected targets.
1202 DwarfAccelTypesSection = nullptr; // Used only by selected targets.
1203
1204 const Triple &TheTriple = Ctx->getTargetTriple();
1205 switch (Ctx->getObjectFileType()) {
1206 case MCContext::IsMachO:
1207 initMachOMCObjectFileInfo(TheTriple);
1208 break;
1209 case MCContext::IsCOFF:
1210 initCOFFMCObjectFileInfo(TheTriple);
1211 break;
1212 case MCContext::IsELF:
1213 initELFMCObjectFileInfo(TheTriple, LargeCodeModel);
1214 break;
1215 case MCContext::IsGOFF:
1216 initGOFFMCObjectFileInfo(TheTriple);
1217 break;
1218 case MCContext::IsSPIRV:
1219 initSPIRVMCObjectFileInfo(TheTriple);
1220 break;
1221 case MCContext::IsWasm:
1222 initWasmMCObjectFileInfo(TheTriple);
1223 break;
1224 case MCContext::IsXCOFF:
1225 initXCOFFMCObjectFileInfo(TheTriple);
1226 break;
1228 initDXContainerObjectFileInfo(TheTriple);
1229 break;
1230 }
1231}
1232
1233MCSection *MCObjectFileInfo::getDwarfComdatSection(const char *Name,
1234 uint64_t Hash) const {
1235 switch (Ctx->getTargetTriple().getObjectFormat()) {
1236 case Triple::ELF:
1237 return Ctx->getELFSection(Name, ELF::SHT_PROGBITS, ELF::SHF_GROUP, 0,
1238 utostr(Hash), /*IsComdat=*/true);
1239 case Triple::Wasm:
1240 return Ctx->getWasmSection(Name, SectionKind::getMetadata(), 0,
1242 case Triple::MachO:
1243 case Triple::COFF:
1244 case Triple::GOFF:
1245 case Triple::SPIRV:
1246 case Triple::XCOFF:
1249 report_fatal_error("Cannot get DWARF comdat section for this object file "
1250 "format: not implemented.");
1251 break;
1252 }
1253 llvm_unreachable("Unknown ObjectFormatType");
1254}
1255
1256MCSection *
1258 if (Ctx->getObjectFileType() != MCContext::IsELF)
1259 return nullptr;
1260
1261 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1262 unsigned Flags = ELF::SHF_LINK_ORDER;
1263 StringRef GroupName;
1264 if (const MCSymbol *Group = ElfSec.getGroup()) {
1265 GroupName = Group->getName();
1266 Flags |= ELF::SHF_GROUP;
1267 }
1268
1269 return Ctx->getELFSection(
1270 ".llvm.callgraph", ELF::SHT_LLVM_CALL_GRAPH, Flags, 0, GroupName,
1271 /*IsComdat=*/true, ElfSec.getUniqueID(),
1272 static_cast<const MCSymbolELF *>(TextSec.getBeginSymbol()));
1273}
1274
1275MCSection *
1277 if ((Ctx->getObjectFileType() != MCContext::IsELF) ||
1278 Ctx->getTargetTriple().isPS4())
1279 return StackSizesSection;
1280
1281 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1282 unsigned Flags = ELF::SHF_LINK_ORDER;
1283 StringRef GroupName;
1284 if (const MCSymbol *Group = ElfSec.getGroup()) {
1285 GroupName = Group->getName();
1286 Flags |= ELF::SHF_GROUP;
1287 }
1288
1289 return Ctx->getELFSection(
1290 ".stack_sizes", ELF::SHT_PROGBITS, Flags, 0, GroupName, true,
1291 ElfSec.getUniqueID(),
1292 static_cast<const MCSymbolELF *>(TextSec.getBeginSymbol()));
1293}
1294
1295MCSection *
1297 constexpr StringLiteral Name = ".llvm_bb_addr_map";
1298 if (Ctx->getObjectFileType() == MCContext::IsELF) {
1299 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1300 unsigned Flags = ELF::SHF_LINK_ORDER;
1301 StringRef GroupName;
1302 if (const MCSymbol *Group = ElfSec.getGroup()) {
1303 GroupName = Group->getName();
1304 Flags |= ELF::SHF_GROUP;
1305 }
1306
1307 // Use the text section's begin symbol and unique ID to create a separate
1308 // .llvm_bb_addr_map section associated with every unique text section.
1309 return Ctx->getELFSection(
1310 Name, ELF::SHT_LLVM_BB_ADDR_MAP, Flags, 0, GroupName, true,
1311 ElfSec.getUniqueID(),
1312 static_cast<const MCSymbolELF *>(TextSec.getBeginSymbol()));
1313 } else if (Ctx->getObjectFileType() == MCContext::IsCOFF) {
1314 StringRef COMDATSymName;
1315 int Selection = 0;
1316 unsigned Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1319 const auto &COFFSec = static_cast<const MCSectionCOFF &>(TextSec);
1320 if (const MCSymbol *COMDATSym = COFFSec.getCOMDATSymbol()) {
1321 if (!Ctx->getAsmInfo().hasCOFFAssociativeComdats())
1322 report_fatal_error("BB address map requires associative COMDAT "
1323 "support for COMDAT functions");
1324 COMDATSymName = COMDATSym->getName();
1325 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1327 }
1328 return Ctx->getCOFFSection(Name, Characteristics, COMDATSymName, Selection,
1329 COFFSec.getUniqueID());
1330 }
1331
1332 return nullptr;
1333}
1334
1335MCSection *
1337 if (Ctx->getObjectFileType() != MCContext::IsELF)
1338 return nullptr;
1339
1340 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1341 unsigned Flags = ELF::SHF_LINK_ORDER | ELF::SHF_ALLOC;
1342 StringRef GroupName;
1343 if (const MCSymbol *Group = ElfSec.getGroup()) {
1344 GroupName = Group->getName();
1345 Flags |= ELF::SHF_GROUP;
1346 }
1347
1348 return Ctx->getELFSection(
1349 ".kcfi_traps", ELF::SHT_PROGBITS, Flags, 0, GroupName,
1350 /*IsComdat=*/true, ElfSec.getUniqueID(),
1351 static_cast<const MCSymbolELF *>(TextSec.getBeginSymbol()));
1352}
1353
1354MCSection *
1356 auto ObjFileType = Ctx->getObjectFileType();
1357 if (ObjFileType == MCContext::IsELF) {
1358 const auto &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1359 unsigned Flags = ELF::SHF_LINK_ORDER;
1360 StringRef GroupName;
1361 if (const MCSymbol *Group = ElfSec.getGroup()) {
1362 GroupName = Group->getName();
1363 Flags |= ELF::SHF_GROUP;
1364 }
1365 return Ctx->getELFSection(
1366 PseudoProbeSection->getName(), ELF::SHT_PROGBITS, Flags, 0, GroupName,
1367 true, ElfSec.getUniqueID(),
1368 static_cast<const MCSymbolELF *>(TextSec.getBeginSymbol()));
1369 } else if (ObjFileType == MCContext::IsCOFF) {
1370 StringRef COMDATSymName = "";
1371 int Selection = 0;
1372 unsigned Characteristics =
1373 static_cast<MCSectionCOFF *>(PseudoProbeSection)->getCharacteristics();
1374 const auto &COFFSec = static_cast<const MCSectionCOFF &>(TextSec);
1375 if (const MCSymbol *COMDATSym = COFFSec.getCOMDATSymbol()) {
1376 // Associate .pseudo_probe to its function section.
1377 COMDATSymName = COMDATSym->getName();
1378 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1380 }
1381 return Ctx->getCOFFSection(PseudoProbeSection->getName(), Characteristics,
1382 COMDATSymName, Selection, COFFSec.getUniqueID());
1383 }
1384
1385 return PseudoProbeSection;
1386}
1387
1388MCSection *
1390 uint64_t FuncHash) const {
1391 if (!Ctx->getTargetTriple().supportsCOMDAT() || FuncName.empty())
1393
1394 // Create a separate comdat group for each function's descriptor in order
1395 // for the linker to deduplicate. The duplication, must be from different
1396 // translation unit, can come from:
1397 // 1. Inline functions defined in header files;
1398 // 2. ThinLTO imported functions;
1399 // 3. Weak-linkage definitions.
1400 // Use a concatenation of the section name, function name, and function hash
1401 // as the group name so that descriptors with different hashes (due to user
1402 // code not following ODR or compiler codegen inconsistencies) get separate
1403 // COMDAT sections instead of being silently dropped (ELF) or causing linker
1404 // errors (COFF). Duplicate GUIDs with mismatching hashes are detected
1405 // during descriptor decoding and reported by llvm-profgen.
1406 auto ObjFileType = Ctx->getObjectFileType();
1407 if (ObjFileType == MCContext::IsELF) {
1408 auto *S = static_cast<MCSectionELF *>(PseudoProbeDescSection);
1409 auto Flags = S->getFlags() | ELF::SHF_GROUP;
1410 return Ctx->getELFSection(
1411 S->getName(), S->getType(), Flags, S->getEntrySize(),
1412 S->getName() + "_" + FuncName + "." + Twine::utohexstr(FuncHash),
1413 /*IsComdat=*/true);
1414 } else if (ObjFileType == MCContext::IsCOFF) {
1415 auto *S = static_cast<MCSectionCOFF *>(PseudoProbeDescSection);
1416 unsigned Characteristics =
1417 S->getCharacteristics() | COFF::IMAGE_SCN_LNK_COMDAT;
1418 std::string COMDATSymName =
1419 (S->getName() + "_" + FuncName + "." + Twine::utohexstr(FuncHash))
1420 .str();
1421 return Ctx->getCOFFSection(S->getName(), Characteristics, COMDATSymName,
1423 }
1424
1426}
1427
1431
1433 const MCSection *TextSec) const {
1434 if (Ctx->getObjectFileType() != MCContext::IsELF)
1435 return nullptr;
1436
1437 // SHF_WRITE for relocations, and let user post-process data in-place.
1439
1440 if (!TextSec)
1441 TextSec = getTextSection();
1442
1443 StringRef GroupName;
1444 const auto &ElfSec = static_cast<const MCSectionELF &>(*TextSec);
1445 if (const MCSymbol *Group = ElfSec.getGroup()) {
1446 GroupName = Group->getName();
1447 Flags |= ELF::SHF_GROUP;
1448 }
1449 return Ctx->getELFSection(
1450 Name, ELF::SHT_PROGBITS, Flags, 0, GroupName, true, ElfSec.getUniqueID(),
1451 static_cast<const MCSymbolELF *>(TextSec->getBeginSymbol()));
1452}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
amdgpu AMDGPU DAG DAG Pattern Instruction Selection
static bool useCompactUnwind(const Triple &T)
This file declares the MCSectionGOFF class, which contains all of the necessary machine code sections...
This file contains the MCSymbolGOFF class.
#define T
PassInstrumentationCallbacks PIC
This file contains data-structure definitions and constants to support unwinding based on ....
This file contains some functions that are useful when dealing with strings.
Context object for machine code objects.
Definition MCContext.h:83
LLVM_ABI MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
MCSection * NonLazySymbolPointerSection
MCSection * TLSBSSSection
Section directive for Thread Local uninitialized data.
MCSection * DwarfDebugNamesSection
Accelerator table sections.
const MCSection * TLSThreadInitSection
Section for thread local data initialization functions.
MCSection * DwarfStrOffSection
The DWARF v5 string offset and address table sections.
MCSection * MergeableConst16Section
MCSection * COFFGlobalTypeHashesSection
MCSection * SFrameSection
SFrame section.
MCSection * DwarfGnuPubTypesSection
Section for newer gnu pubtypes.
MCSection * getLLVMStatsSection() const
MCSection * TextSection
Section directive for standard text.
MCSection * TLSDataSection
Section directive for Thread Local data. ELF, MachO, COFF, and Wasm.
MCSection * ThreadLocalPointerSection
MCSection * LSDASection
If exception handling is supported by the target, this is the section the Language Specific Data Area...
MCSection * CompactUnwindSection
If exception handling is supported by the target and the target can support a compact representation ...
MCSection * COFFDebugSymbolsSection
MCSection * getPseudoProbeDescSection(StringRef FuncName, uint64_t FuncHash) const
MCSection * DwarfLoclistsSection
The DWARF v5 locations list section.
MCSection * PseudoProbeSection
Section for pseudo probe information used by AutoFDO.
MCSection * FourByteConstantSection
MCSection * getStackSizesSection(const MCSection &TextSec) const
MCSection * DwarfRnglistsSection
The DWARF v5 range list section.
const MCSection * DwarfDebugInlineSection
MCSection * getBBAddrMapSection(const MCSection &TextSec) const
MCSection * LazySymbolPointerSection
MCSection * RemarksSection
Remarks section.
MCSection * getPseudoProbeSection(const MCSection &TextSec) const
MCSection * TLSExtraDataSection
Extra TLS Variable Data section.
MCSection * EHFrameSection
EH frame section.
bool OmitDwarfIfHaveCompactUnwind
OmitDwarfIfHaveCompactUnwind - True if the target object file supports having some functions with com...
MCSection * DrectveSection
COFF specific sections.
MCSection * FaultMapSection
FaultMap section.
MCSection * getKCFITrapSection(const MCSection &TextSec) const
MCSection * TLSTLVSection
Section for thread local structure information.
void initMCObjectFileInfo(MCContext &MCCtx, bool PIC, bool LargeCodeModel=false)
MCSection * DwarfRnglistsDWOSection
The DWARF v5 range and location list sections for fission.
MCSection * ImportCallSection
If import call optimization is supported by the target, this is the section to emit import call data ...
MCSection * MergeableConst32Section
MCSection * SixteenByteConstantSection
MCSection * getPCSection(StringRef Name, const MCSection *TextSec) const
std::optional< sframe::ABI > SFrameABIArch
SFrame ABI architecture byte.
bool SupportsCompactUnwindWithoutEHFrame
True if the target object file supports emitting a compact unwind section without an associated EH fr...
MCSection * ReadOnlySection
Section that is readonly and can contain arbitrary initialized data.
unsigned FDECFIEncoding
FDE CFI encoding.
MCSection * DwarfLoclistsDWOSection
MCSection * getCallGraphSection(const MCSection &TextSec) const
MCSection * BSSSection
Section that is default initialized to zero.
MCSection * EightByteConstantSection
MCSection * StackSizesSection
Section containing metadata on function stack sizes.
unsigned CompactUnwindDwarfEHFrameOnly
Compact unwind encoding indicating that we should emit only an EH frame.
MCSection * getTextSection() const
MCSection * DwarfGnuPubNamesSection
Section for newer gnu pubnames.
MCSection * StackMapSection
StackMap section.
MCContext & getContext() const
MCSection * DwarfAccelNamespaceSection
MCSection * DataSection
Section directive for standard data.
This represents a section on Windows.
This represents a section on linux, lots of unix variants and some bare metal systems.
unsigned getFlags() const
unsigned getUniqueID() const
const MCSymbolELF * getGroup() const
void setSymbolTableName(StringRef STN)
MCSymbolXCOFF * getQualNameSymbol() const
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition MCSection.h:580
void setAlignment(Align Value)
Definition MCSection.h:665
static constexpr unsigned NonUniqueID
Definition MCSection.h:585
void setBeginSymbol(MCSymbol *Sym)
Definition MCSection.h:657
MCSymbol * getBeginSymbol()
Definition MCSection.h:653
void setSymbolTableName(StringRef STN)
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition MCSymbol.h:42
static SectionKind getThreadData()
static SectionKind getMetadata()
static SectionKind getMergeable2ByteCString()
static SectionKind getMergeableConst4()
static SectionKind getText()
static SectionKind getReadOnlyWithRel()
static SectionKind getData()
static SectionKind getMergeableConst8()
static SectionKind getBSS()
static SectionKind getThreadBSS()
static SectionKind getMergeableConst16()
static SectionKind getMergeable1ByteCString()
static SectionKind getReadOnly()
A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs...
Definition StringRef.h:888
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
constexpr bool empty() const
Check if the string is empty.
Definition StringRef.h:141
Triple - Helper class for working with autoconf configuration names.
Definition Triple.h:48
@ UnknownObjectFormat
Definition Triple.h:424
static Twine utohexstr(uint64_t Val)
Definition Twine.h:385
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
SectionCharacteristics
Definition COFF.h:298
@ IMAGE_SCN_LNK_REMOVE
Definition COFF.h:308
@ IMAGE_SCN_CNT_CODE
Definition COFF.h:303
@ IMAGE_SCN_MEM_READ
Definition COFF.h:336
@ IMAGE_SCN_MEM_EXECUTE
Definition COFF.h:335
@ IMAGE_SCN_CNT_UNINITIALIZED_DATA
Definition COFF.h:305
@ IMAGE_SCN_MEM_DISCARDABLE
Definition COFF.h:331
@ IMAGE_SCN_LNK_INFO
Definition COFF.h:307
@ IMAGE_SCN_MEM_16BIT
Definition COFF.h:312
@ IMAGE_SCN_CNT_INITIALIZED_DATA
Definition COFF.h:304
@ IMAGE_SCN_LNK_COMDAT
Definition COFF.h:309
@ IMAGE_SCN_MEM_WRITE
Definition COFF.h:337
@ IMAGE_COMDAT_SELECT_ASSOCIATIVE
Definition COFF.h:459
@ IMAGE_COMDAT_SELECT_EXACT_MATCH
Definition COFF.h:458
@ SHF_MERGE
Definition ELF.h:1104
@ SHF_STRINGS
Definition ELF.h:1107
@ SHF_EXCLUDE
Definition ELF.h:1132
@ SHF_ALLOC
Definition ELF.h:1098
@ SHF_LINK_ORDER
Definition ELF.h:1113
@ SHF_GROUP
Definition ELF.h:1120
@ SHF_WRITE
Definition ELF.h:1095
@ SHF_TLS
Definition ELF.h:1123
@ SHF_EXECINSTR
Definition ELF.h:1101
@ SHT_PROGBITS
Definition ELF.h:996
@ SHT_NOBITS
Definition ELF.h:1003
@ SHT_LLVM_CALL_GRAPH
Definition ELF.h:1039
@ SHT_MIPS_DWARF
Definition ELF.h:1076
@ SHT_LLVM_BB_ADDR_MAP
Definition ELF.h:1034
@ SHT_GNU_SFRAME
Definition ELF.h:1044
@ SHT_X86_64_UNWIND
Definition ELF.h:1072
@ ESD_LB_Deferred
Definition GOFF.h:129
@ ESD_LB_NoLoad
Definition GOFF.h:130
@ ESD_LB_Initial
Definition GOFF.h:128
constexpr StringLiteral CLASS_WSA
@ ESD_BA_Concatenate
Definition GOFF.h:98
@ ESD_BA_Merge
Definition GOFF.h:99
@ ESD_TS_Structured
Definition GOFF.h:93
@ ESD_TS_ByteOriented
Definition GOFF.h:92
@ ESD_EXE_DATA
Definition GOFF.h:111
@ ESD_RQ_1
Definition GOFF.h:70
@ ESD_RQ_0
Definition GOFF.h:69
constexpr StringLiteral CLASS_PPA2
@ ESD_BSC_Section
Definition GOFF.h:136
@ ESD_LT_OS
Definition GOFF.h:142
@ ESD_LT_XPLink
Definition GOFF.h:142
@ ESD_NS_Parts
Definition GOFF.h:65
@ ESD_NS_NormalName
Definition GOFF.h:63
@ ESD_TA_Rent
Definition GOFF.h:106
constexpr StringLiteral CLASS_CODE
@ ESD_BST_Strong
Definition GOFF.h:123
@ ESD_RMODE_64
Definition GOFF.h:88
constexpr uint32_t S_ATTR_NO_DEAD_STRIP
No dead stripping.
Definition MachO.h:198
@ S_THREAD_LOCAL_VARIABLE_POINTERS
S_THREAD_LOCAL_VARIABLE_POINTERS - Section with pointers to thread local structures.
Definition MachO.h:175
@ S_16BYTE_LITERALS
S_16BYTE_LITERALS - Section with only 16 byte literals.
Definition MachO.h:160
@ S_THREAD_LOCAL_INIT_FUNCTION_POINTERS
S_THREAD_LOCAL_INIT_FUNCTION_POINTERS - Section with thread local variable initialization pointers to...
Definition MachO.h:178
@ S_COALESCED
S_COALESCED - Section contains symbols that are to be coalesced.
Definition MachO.h:152
@ S_THREAD_LOCAL_ZEROFILL
S_THREAD_LOCAL_ZEROFILL - Thread local zerofill section.
Definition MachO.h:169
@ S_LAZY_SYMBOL_POINTERS
S_LAZY_SYMBOL_POINTERS - Section with lazy symbol pointers.
Definition MachO.h:141
@ S_CSTRING_LITERALS
S_CSTRING_LITERALS - Section with literal C strings.
Definition MachO.h:131
@ S_THREAD_LOCAL_REGULAR
S_THREAD_LOCAL_REGULAR - Thread local data section.
Definition MachO.h:167
@ S_ZEROFILL
S_ZEROFILL - Zero fill on demand section.
Definition MachO.h:129
@ S_NON_LAZY_SYMBOL_POINTERS
S_NON_LAZY_SYMBOL_POINTERS - Section with non-lazy symbol pointers.
Definition MachO.h:139
@ S_4BYTE_LITERALS
S_4BYTE_LITERALS - Section with 4 byte literals.
Definition MachO.h:133
@ S_8BYTE_LITERALS
S_8BYTE_LITERALS - Section with 8 byte literals.
Definition MachO.h:135
@ S_THREAD_LOCAL_VARIABLES
S_THREAD_LOCAL_VARIABLES - Section with thread local variable structure data.
Definition MachO.h:172
constexpr uint32_t S_ATTR_STRIP_STATIC_SYMS
Ok to strip static symbols in this section in files with the MY_DYLDLINK flag.
Definition MachO.h:196
constexpr uint32_t S_ATTR_DEBUG
A debug section.
Definition MachO.h:204
constexpr uint32_t S_ATTR_PURE_INSTRUCTIONS
Section contains only true machine instructions.
Definition MachO.h:190
constexpr uint32_t S_ATTR_LIVE_SUPPORT
Blocks are live if they reference live blocks.
Definition MachO.h:200
constexpr uint32_t S_ATTR_NO_TOC
Section contains coalesced symbols that are not to be in a ranlib table of contents.
Definition MachO.h:193
@ SSUBTYP_DWARNGE
DWARF aranges section.
Definition XCOFF.h:160
@ SSUBTYP_DWFRAME
DWARF frame section.
Definition XCOFF.h:165
@ SSUBTYP_DWABREV
DWARF abbrev section.
Definition XCOFF.h:161
@ SSUBTYP_DWINFO
DWARF info section.
Definition XCOFF.h:156
@ SSUBTYP_DWRNGES
DWARF ranges section.
Definition XCOFF.h:163
@ SSUBTYP_DWLOC
DWARF loc section.
Definition XCOFF.h:164
@ SSUBTYP_DWMAC
DWARF macinfo section.
Definition XCOFF.h:166
@ SSUBTYP_DWPBNMS
DWARF pubnames section.
Definition XCOFF.h:158
@ SSUBTYP_DWPBTYP
DWARF pubtypes section.
Definition XCOFF.h:159
@ SSUBTYP_DWLINE
DWARF line section.
Definition XCOFF.h:157
@ SSUBTYP_DWSTR
DWARF str section.
Definition XCOFF.h:162
@ XMC_TC0
TOC Anchor for TOC Addressability.
Definition XCOFF.h:119
@ XMC_RW
Read Write Data.
Definition XCOFF.h:118
@ XMC_TL
Initialized thread-local variable.
Definition XCOFF.h:127
@ XMC_RO
Read Only Constant.
Definition XCOFF.h:107
@ XMC_PR
Program Code.
Definition XCOFF.h:106
@ XTY_SD
Csect definition for initialized storage.
Definition XCOFF.h:243
@ DW_EH_PE_pcrel
Definition Dwarf.h:982
@ DW_EH_PE_sdata4
Definition Dwarf.h:979
@ DW_EH_PE_sdata8
Definition Dwarf.h:980
@ DW_EH_PE_absptr
Definition Dwarf.h:971
@ WASM_SEG_FLAG_STRINGS
Definition Wasm.h:240
This is an optimization pass for GlobalISel generic memory operations.
std::string utostr(uint64_t X, bool isNeg=false)
FuncHash
Definition InstrProf.h:78
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
Definition Error.cpp:163