LLVM 19.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
14#include "llvm/MC/MCAsmInfo.h"
15#include "llvm/MC/MCContext.h"
16#include "llvm/MC/MCSection.h"
27
28using namespace llvm;
29
30static bool useCompactUnwind(const Triple &T) {
31 // Only on darwin.
32 if (!T.isOSDarwin())
33 return false;
34
35 // aarch64 always has it.
36 if (T.getArch() == Triple::aarch64 || T.getArch() == Triple::aarch64_32)
37 return true;
38
39 // armv7k always has it.
40 if (T.isWatchABI())
41 return true;
42
43 // Use it on newer version of OS X.
44 if (T.isMacOSX() && !T.isMacOSXVersionLT(10, 6))
45 return true;
46
47 // And the iOS simulator.
48 if (T.isiOS() && T.isX86())
49 return true;
50
51 // The rest of the simulators always have it.
52 if (T.isSimulatorEnvironment())
53 return true;
54
55 // XROS always has it.
56 if (T.isXROS())
57 return true;
58
59 return false;
60}
61
62void MCObjectFileInfo::initMachOMCObjectFileInfo(const Triple &T) {
63 // MachO
65
67 "__TEXT", "__eh_frame",
71
72 if (T.isOSDarwin() &&
73 (T.getArch() == Triple::aarch64 || T.getArch() == Triple::aarch64_32 ||
74 T.isSimulatorEnvironment()))
76
77 switch (Ctx->emitDwarfUnwindInfo()) {
80 break;
83 break;
87 break;
88 }
89
91
92 TextSection // .text
93 = Ctx->getMachOSection("__TEXT", "__text",
96 DataSection // .data
97 = Ctx->getMachOSection("__DATA", "__data", 0, SectionKind::getData());
98
99 // BSSSection might not be expected initialized on msvc.
100 BSSSection = nullptr;
101
102 TLSDataSection // .tdata
103 = Ctx->getMachOSection("__DATA", "__thread_data",
106 TLSBSSSection // .tbss
107 = Ctx->getMachOSection("__DATA", "__thread_bss",
110
111 // TODO: Verify datarel below.
112 TLSTLVSection // .tlv
113 = Ctx->getMachOSection("__DATA", "__thread_vars",
116
118 "__DATA", "__thread_init", MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS,
120
121 CStringSection // .cstring
122 = Ctx->getMachOSection("__TEXT", "__cstring",
126 = Ctx->getMachOSection("__TEXT","__ustring", 0,
128 FourByteConstantSection // .literal4
129 = Ctx->getMachOSection("__TEXT", "__literal4",
132 EightByteConstantSection // .literal8
133 = Ctx->getMachOSection("__TEXT", "__literal8",
136
137 SixteenByteConstantSection // .literal16
138 = Ctx->getMachOSection("__TEXT", "__literal16",
141
142 ReadOnlySection // .const
143 = Ctx->getMachOSection("__TEXT", "__const", 0,
145
146 // If the target is not powerpc, map the coal sections to the non-coal
147 // sections.
148 //
149 // "__TEXT/__textcoal_nt" => section "__TEXT/__text"
150 // "__TEXT/__const_coal" => section "__TEXT/__const"
151 // "__DATA/__datacoal_nt" => section "__DATA/__data"
152 Triple::ArchType ArchTy = T.getArch();
153
154 ConstDataSection // .const_data
155 = Ctx->getMachOSection("__DATA", "__const", 0,
157
158 if (ArchTy == Triple::ppc || ArchTy == Triple::ppc64) {
160 = Ctx->getMachOSection("__TEXT", "__textcoal_nt",
165 = Ctx->getMachOSection("__TEXT", "__const_coal",
169 "__DATA", "__datacoal_nt", MachO::S_COALESCED, SectionKind::getData());
171 } else {
176 }
177
179 = Ctx->getMachOSection("__DATA","__common",
183 = Ctx->getMachOSection("__DATA","__bss", MachO::S_ZEROFILL,
185
186
188 = Ctx->getMachOSection("__DATA", "__la_symbol_ptr",
192 = Ctx->getMachOSection("__DATA", "__nl_symbol_ptr",
195
197 = Ctx->getMachOSection("__DATA", "__thread_ptr",
200
201 AddrSigSection = Ctx->getMachOSection("__DATA", "__llvm_addrsig", 0,
203
204 // Exception Handling.
205 LSDASection = Ctx->getMachOSection("__TEXT", "__gcc_except_tab", 0,
207
208 COFFDebugSymbolsSection = nullptr;
209 COFFDebugTypesSection = nullptr;
211
212 if (useCompactUnwind(T)) {
214 Ctx->getMachOSection("__LD", "__compact_unwind", MachO::S_ATTR_DEBUG,
216
217 if (T.isX86())
218 CompactUnwindDwarfEHFrameOnly = 0x04000000; // UNWIND_X86_64_MODE_DWARF
219 else if (T.getArch() == Triple::aarch64 || T.getArch() == Triple::aarch64_32)
220 CompactUnwindDwarfEHFrameOnly = 0x03000000; // UNWIND_ARM64_MODE_DWARF
221 else if (T.getArch() == Triple::arm || T.getArch() == Triple::thumb)
222 CompactUnwindDwarfEHFrameOnly = 0x04000000; // UNWIND_ARM_MODE_DWARF
223 }
224
225 // Debug Information.
227 Ctx->getMachOSection("__DWARF", "__debug_names", MachO::S_ATTR_DEBUG,
228 SectionKind::getMetadata(), "debug_names_begin");
230 Ctx->getMachOSection("__DWARF", "__apple_names", MachO::S_ATTR_DEBUG,
231 SectionKind::getMetadata(), "names_begin");
233 Ctx->getMachOSection("__DWARF", "__apple_objc", MachO::S_ATTR_DEBUG,
234 SectionKind::getMetadata(), "objc_begin");
235 // 16 character section limit...
237 Ctx->getMachOSection("__DWARF", "__apple_namespac", MachO::S_ATTR_DEBUG,
238 SectionKind::getMetadata(), "namespac_begin");
240 Ctx->getMachOSection("__DWARF", "__apple_types", MachO::S_ATTR_DEBUG,
241 SectionKind::getMetadata(), "types_begin");
242
244 Ctx->getMachOSection("__DWARF", "__swift_ast", MachO::S_ATTR_DEBUG,
246
248 Ctx->getMachOSection("__DWARF", "__debug_abbrev", MachO::S_ATTR_DEBUG,
249 SectionKind::getMetadata(), "section_abbrev");
251 Ctx->getMachOSection("__DWARF", "__debug_info", MachO::S_ATTR_DEBUG,
252 SectionKind::getMetadata(), "section_info");
254 Ctx->getMachOSection("__DWARF", "__debug_line", MachO::S_ATTR_DEBUG,
255 SectionKind::getMetadata(), "section_line");
257 Ctx->getMachOSection("__DWARF", "__debug_line_str", MachO::S_ATTR_DEBUG,
258 SectionKind::getMetadata(), "section_line_str");
260 Ctx->getMachOSection("__DWARF", "__debug_frame", MachO::S_ATTR_DEBUG,
261 SectionKind::getMetadata(), "section_frame");
263 Ctx->getMachOSection("__DWARF", "__debug_pubnames", MachO::S_ATTR_DEBUG,
266 Ctx->getMachOSection("__DWARF", "__debug_pubtypes", MachO::S_ATTR_DEBUG,
269 Ctx->getMachOSection("__DWARF", "__debug_gnu_pubn", MachO::S_ATTR_DEBUG,
272 Ctx->getMachOSection("__DWARF", "__debug_gnu_pubt", MachO::S_ATTR_DEBUG,
275 Ctx->getMachOSection("__DWARF", "__debug_str", MachO::S_ATTR_DEBUG,
276 SectionKind::getMetadata(), "info_string");
278 Ctx->getMachOSection("__DWARF", "__debug_str_offs", MachO::S_ATTR_DEBUG,
279 SectionKind::getMetadata(), "section_str_off");
281 Ctx->getMachOSection("__DWARF", "__debug_addr", MachO::S_ATTR_DEBUG,
282 SectionKind::getMetadata(), "section_info");
284 Ctx->getMachOSection("__DWARF", "__debug_loc", MachO::S_ATTR_DEBUG,
285 SectionKind::getMetadata(), "section_debug_loc");
287 Ctx->getMachOSection("__DWARF", "__debug_loclists", MachO::S_ATTR_DEBUG,
288 SectionKind::getMetadata(), "section_debug_loc");
289
291 Ctx->getMachOSection("__DWARF", "__debug_aranges", MachO::S_ATTR_DEBUG,
294 Ctx->getMachOSection("__DWARF", "__debug_ranges", MachO::S_ATTR_DEBUG,
295 SectionKind::getMetadata(), "debug_range");
297 Ctx->getMachOSection("__DWARF", "__debug_rnglists", MachO::S_ATTR_DEBUG,
298 SectionKind::getMetadata(), "debug_range");
300 Ctx->getMachOSection("__DWARF", "__debug_macinfo", MachO::S_ATTR_DEBUG,
301 SectionKind::getMetadata(), "debug_macinfo");
303 Ctx->getMachOSection("__DWARF", "__debug_macro", MachO::S_ATTR_DEBUG,
304 SectionKind::getMetadata(), "debug_macro");
306 Ctx->getMachOSection("__DWARF", "__debug_inlined", MachO::S_ATTR_DEBUG,
309 Ctx->getMachOSection("__DWARF", "__debug_cu_index", MachO::S_ATTR_DEBUG,
312 Ctx->getMachOSection("__DWARF", "__debug_tu_index", MachO::S_ATTR_DEBUG,
314 StackMapSection = Ctx->getMachOSection("__LLVM_STACKMAPS", "__llvm_stackmaps",
316
317 FaultMapSection = Ctx->getMachOSection("__LLVM_FAULTMAPS", "__llvm_faultmaps",
319
321 "__LLVM", "__remarks", MachO::S_ATTR_DEBUG, SectionKind::getMetadata());
322
323 // The architecture of dsymutil makes it very difficult to copy the Swift
324 // reflection metadata sections into the __TEXT segment, so dsymutil creates
325 // these sections in the __DWARF segment instead.
327#define HANDLE_SWIFT_SECTION(KIND, MACHO, ELF, COFF) \
328 Swift5ReflectionSections \
329 [llvm::binaryformat::Swift5ReflectionSectionKind::KIND] = \
330 Ctx->getMachOSection(Ctx->getSwift5ReflectionSegmentName().data(), \
331 MACHO, 0, SectionKind::getMetadata());
332#include "llvm/BinaryFormat/Swift.def"
333 }
334
336}
337
338void MCObjectFileInfo::initELFMCObjectFileInfo(const Triple &T, bool Large) {
339 switch (T.getArch()) {
340 case Triple::mips:
341 case Triple::mipsel:
342 case Triple::mips64:
343 case Triple::mips64el:
344 // We cannot use DW_EH_PE_sdata8 for the large PositionIndependent case
345 // since there is no R_MIPS_PC64 relocation (only a 32-bit version).
346 if (PositionIndependent && !Large)
348 else
352 break;
353 case Triple::ppc64:
354 case Triple::ppc64le:
355 case Triple::aarch64:
357 case Triple::x86_64:
360 break;
361 case Triple::bpfel:
362 case Triple::bpfeb:
364 break;
365 case Triple::hexagon:
367 PositionIndependent ? dwarf::DW_EH_PE_pcrel : dwarf::DW_EH_PE_absptr;
368 break;
369 case Triple::xtensa:
371 break;
372 default:
374 break;
375 }
376
377 unsigned EHSectionType = T.getArch() == Triple::x86_64
380
381 // Solaris requires different flags for .eh_frame to seemingly every other
382 // platform.
383 unsigned EHSectionFlags = ELF::SHF_ALLOC;
384 if (T.isOSSolaris() && T.getArch() != Triple::x86_64)
385 EHSectionFlags |= ELF::SHF_WRITE;
386
387 // ELF
390
393
396
399
401 Ctx->getELFSection(".tdata", ELF::SHT_PROGBITS,
403
406
407 DataRelROSection = Ctx->getELFSection(".data.rel.ro", ELF::SHT_PROGBITS,
409
411 Ctx->getELFSection(".rodata.cst4", ELF::SHT_PROGBITS,
413
415 Ctx->getELFSection(".rodata.cst8", ELF::SHT_PROGBITS,
417
419 Ctx->getELFSection(".rodata.cst16", ELF::SHT_PROGBITS,
421
423 Ctx->getELFSection(".rodata.cst32", ELF::SHT_PROGBITS,
425
426 // Exception Handling Sections.
427
428 // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
429 // it contains relocatable pointers. In PIC mode, this is probably a big
430 // runtime hit for C++ apps. Either the contents of the LSDA need to be
431 // adjusted or this should be a data section.
432 LSDASection = Ctx->getELFSection(".gcc_except_table", ELF::SHT_PROGBITS,
434
435 COFFDebugSymbolsSection = nullptr;
436 COFFDebugTypesSection = nullptr;
437
438 unsigned DebugSecType = ELF::SHT_PROGBITS;
439
440 // MIPS .debug_* sections should have SHT_MIPS_DWARF section type
441 // to distinguish among sections contain DWARF and ECOFF debug formats.
442 // Sections with ECOFF debug format are obsoleted and marked by SHT_PROGBITS.
443 if (T.isMIPS())
444 DebugSecType = ELF::SHT_MIPS_DWARF;
445
446 // Debug Info Sections.
448 Ctx->getELFSection(".debug_abbrev", DebugSecType, 0);
449 DwarfInfoSection = Ctx->getELFSection(".debug_info", DebugSecType, 0);
450 DwarfLineSection = Ctx->getELFSection(".debug_line", DebugSecType, 0);
452 Ctx->getELFSection(".debug_line_str", DebugSecType,
454 DwarfFrameSection = Ctx->getELFSection(".debug_frame", DebugSecType, 0);
456 Ctx->getELFSection(".debug_pubnames", DebugSecType, 0);
458 Ctx->getELFSection(".debug_pubtypes", DebugSecType, 0);
460 Ctx->getELFSection(".debug_gnu_pubnames", DebugSecType, 0);
462 Ctx->getELFSection(".debug_gnu_pubtypes", DebugSecType, 0);
464 Ctx->getELFSection(".debug_str", DebugSecType,
466 DwarfLocSection = Ctx->getELFSection(".debug_loc", DebugSecType, 0);
468 Ctx->getELFSection(".debug_aranges", DebugSecType, 0);
470 Ctx->getELFSection(".debug_ranges", DebugSecType, 0);
472 Ctx->getELFSection(".debug_macinfo", DebugSecType, 0);
473 DwarfMacroSection = Ctx->getELFSection(".debug_macro", DebugSecType, 0);
474
475 // DWARF5 Experimental Debug Info
476
477 // Accelerator Tables
479 Ctx->getELFSection(".debug_names", ELF::SHT_PROGBITS, 0);
481 Ctx->getELFSection(".apple_names", ELF::SHT_PROGBITS, 0);
483 Ctx->getELFSection(".apple_objc", ELF::SHT_PROGBITS, 0);
485 Ctx->getELFSection(".apple_namespaces", ELF::SHT_PROGBITS, 0);
487 Ctx->getELFSection(".apple_types", ELF::SHT_PROGBITS, 0);
488
489 // String Offset and Address Sections
491 Ctx->getELFSection(".debug_str_offsets", DebugSecType, 0);
492 DwarfAddrSection = Ctx->getELFSection(".debug_addr", DebugSecType, 0);
493 DwarfRnglistsSection = Ctx->getELFSection(".debug_rnglists", DebugSecType, 0);
494 DwarfLoclistsSection = Ctx->getELFSection(".debug_loclists", DebugSecType, 0);
495
496 // Fission Sections
498 Ctx->getELFSection(".debug_info.dwo", DebugSecType, ELF::SHF_EXCLUDE);
500 Ctx->getELFSection(".debug_types.dwo", DebugSecType, ELF::SHF_EXCLUDE);
502 Ctx->getELFSection(".debug_abbrev.dwo", DebugSecType, ELF::SHF_EXCLUDE);
504 ".debug_str.dwo", DebugSecType,
507 Ctx->getELFSection(".debug_line.dwo", DebugSecType, ELF::SHF_EXCLUDE);
509 Ctx->getELFSection(".debug_loc.dwo", DebugSecType, ELF::SHF_EXCLUDE);
510 DwarfStrOffDWOSection = Ctx->getELFSection(".debug_str_offsets.dwo",
511 DebugSecType, ELF::SHF_EXCLUDE);
513 Ctx->getELFSection(".debug_rnglists.dwo", DebugSecType, ELF::SHF_EXCLUDE);
515 Ctx->getELFSection(".debug_macinfo.dwo", DebugSecType, ELF::SHF_EXCLUDE);
517 Ctx->getELFSection(".debug_macro.dwo", DebugSecType, ELF::SHF_EXCLUDE);
518
520 Ctx->getELFSection(".debug_loclists.dwo", DebugSecType, ELF::SHF_EXCLUDE);
521
522 // DWP Sections
524 Ctx->getELFSection(".debug_cu_index", DebugSecType, 0);
526 Ctx->getELFSection(".debug_tu_index", DebugSecType, 0);
527
529 Ctx->getELFSection(".llvm_stackmaps", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
530
532 Ctx->getELFSection(".llvm_faultmaps", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
533
535 Ctx->getELFSection(".eh_frame", EHSectionType, EHSectionFlags);
536
537 StackSizesSection = Ctx->getELFSection(".stack_sizes", ELF::SHT_PROGBITS, 0);
538
539 PseudoProbeSection = Ctx->getELFSection(".pseudo_probe", DebugSecType, 0);
541 Ctx->getELFSection(".pseudo_probe_desc", DebugSecType, 0);
542
543 LLVMStatsSection = Ctx->getELFSection(".llvm_stats", ELF::SHT_PROGBITS, 0);
544}
545
546void MCObjectFileInfo::initGOFFMCObjectFileInfo(const Triple &T) {
548 Ctx->getGOFFSection(".text", SectionKind::getText(), nullptr, nullptr);
549 BSSSection =
550 Ctx->getGOFFSection(".bss", SectionKind::getBSS(), nullptr, nullptr);
557 ADASection =
558 Ctx->getGOFFSection(".ada", SectionKind::getData(), nullptr, nullptr);
560 Ctx->getGOFFSection("B_IDRL", SectionKind::getData(), nullptr, nullptr);
561}
562
563void MCObjectFileInfo::initCOFFMCObjectFileInfo(const Triple &T) {
568
569 // Set the `IMAGE_SCN_MEM_16BIT` flag when compiling for thumb mode. This is
570 // used to indicate to the linker that the text segment contains thumb instructions
571 // and to set the ISA selection bit for calls accordingly.
572 const bool IsThumb = T.getArch() == Triple::thumb;
573
574 // COFF
580 ".text",
592
593 if (T.getArch() == Triple::x86_64 || T.getArch() == Triple::aarch64 ||
594 T.getArch() == Triple::arm || T.getArch() == Triple::thumb) {
595 // On Windows with SEH, the LSDA is emitted into the .xdata section
596 LSDASection = nullptr;
597 } else {
598 LSDASection = Ctx->getCOFFSection(".gcc_except_table",
602 }
603
604 // Debug info.
616 ".debug$H",
620
622 ".debug_abbrev",
625 SectionKind::getMetadata(), "section_abbrev");
627 ".debug_info",
630 SectionKind::getMetadata(), "section_info");
632 ".debug_line",
635 SectionKind::getMetadata(), "section_line");
637 ".debug_line_str",
640 SectionKind::getMetadata(), "section_line_str");
642 ".debug_frame",
647 ".debug_pubnames",
652 ".debug_pubtypes",
657 ".debug_gnu_pubnames",
662 ".debug_gnu_pubtypes",
667 ".debug_str",
670 SectionKind::getMetadata(), "info_string");
672 ".debug_str_offsets",
675 SectionKind::getMetadata(), "section_str_off");
677 ".debug_loc",
680 SectionKind::getMetadata(), "section_debug_loc");
682 ".debug_loclists",
685 SectionKind::getMetadata(), "section_debug_loclists");
687 ".debug_aranges",
692 ".debug_ranges",
695 SectionKind::getMetadata(), "debug_range");
697 ".debug_rnglists",
700 SectionKind::getMetadata(), "debug_rnglists");
702 ".debug_macinfo",
705 SectionKind::getMetadata(), "debug_macinfo");
707 ".debug_macro",
710 SectionKind::getMetadata(), "debug_macro");
712 ".debug_macinfo.dwo",
715 SectionKind::getMetadata(), "debug_macinfo.dwo");
717 ".debug_macro.dwo",
720 SectionKind::getMetadata(), "debug_macro.dwo");
722 ".debug_info.dwo",
725 SectionKind::getMetadata(), "section_info_dwo");
727 ".debug_types.dwo",
730 SectionKind::getMetadata(), "section_types_dwo");
732 ".debug_abbrev.dwo",
735 SectionKind::getMetadata(), "section_abbrev_dwo");
737 ".debug_str.dwo",
740 SectionKind::getMetadata(), "skel_string");
742 ".debug_line.dwo",
747 ".debug_loc.dwo",
750 SectionKind::getMetadata(), "skel_loc");
752 ".debug_str_offsets.dwo",
755 SectionKind::getMetadata(), "section_str_off_dwo");
757 ".debug_addr",
760 SectionKind::getMetadata(), "addr_sec");
762 ".debug_cu_index",
767 ".debug_tu_index",
772 ".debug_names",
775 SectionKind::getMetadata(), "debug_names_begin");
777 ".apple_names",
780 SectionKind::getMetadata(), "names_begin");
782 ".apple_namespaces",
785 SectionKind::getMetadata(), "namespac_begin");
787 ".apple_types",
790 SectionKind::getMetadata(), "types_begin");
792 ".apple_objc",
795 SectionKind::getMetadata(), "objc_begin");
796
800
804
808
811
812 GEHContSection = Ctx->getCOFFSection(".gehcont$y",
816
817 GFIDsSection = Ctx->getCOFFSection(".gfids$y",
821
822 GIATsSection = Ctx->getCOFFSection(".giats$y",
826
827 GLJMPSection = Ctx->getCOFFSection(".gljmp$y",
831
836
837 StackMapSection = Ctx->getCOFFSection(".llvm_stackmaps",
841}
842
843void MCObjectFileInfo::initSPIRVMCObjectFileInfo(const Triple &T) {
844 // Put everything in a single binary section.
846}
847
848void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
851
853 Ctx->getWasmSection(".debug_line", SectionKind::getMetadata());
855 Ctx->getWasmSection(".debug_line_str", SectionKind::getMetadata(),
860 Ctx->getWasmSection(".debug_loc", SectionKind::getMetadata());
862 Ctx->getWasmSection(".debug_abbrev", SectionKind::getMetadata());
865 Ctx->getWasmSection(".debug_ranges", SectionKind::getMetadata());
867 Ctx->getWasmSection(".debug_macinfo", SectionKind::getMetadata());
869 Ctx->getWasmSection(".debug_macro", SectionKind::getMetadata());
873 Ctx->getWasmSection(".debug_info", SectionKind::getMetadata());
878 Ctx->getWasmSection(".debug_gnu_pubnames", SectionKind::getMetadata());
880 Ctx->getWasmSection(".debug_gnu_pubtypes", SectionKind::getMetadata());
881
883 Ctx->getWasmSection(".debug_names", SectionKind::getMetadata());
885 Ctx->getWasmSection(".debug_str_offsets", SectionKind::getMetadata());
887 Ctx->getWasmSection(".debug_addr", SectionKind::getMetadata());
889 Ctx->getWasmSection(".debug_rnglists", SectionKind::getMetadata());
891 Ctx->getWasmSection(".debug_loclists", SectionKind::getMetadata());
892
893 // Fission Sections
895 Ctx->getWasmSection(".debug_info.dwo", SectionKind::getMetadata());
897 Ctx->getWasmSection(".debug_types.dwo", SectionKind::getMetadata());
899 Ctx->getWasmSection(".debug_abbrev.dwo", SectionKind::getMetadata());
901 Ctx->getWasmSection(".debug_str.dwo", SectionKind::getMetadata(),
904 Ctx->getWasmSection(".debug_line.dwo", SectionKind::getMetadata());
906 Ctx->getWasmSection(".debug_loc.dwo", SectionKind::getMetadata());
908 Ctx->getWasmSection(".debug_str_offsets.dwo", SectionKind::getMetadata());
910 Ctx->getWasmSection(".debug_rnglists.dwo", SectionKind::getMetadata());
912 Ctx->getWasmSection(".debug_macinfo.dwo", SectionKind::getMetadata());
914 Ctx->getWasmSection(".debug_macro.dwo", SectionKind::getMetadata());
915
917 Ctx->getWasmSection(".debug_loclists.dwo", SectionKind::getMetadata());
918
919 // DWP Sections
921 Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata());
923 Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata());
924
925 // Wasm use data section for LSDA.
926 // TODO Consider putting each function's exception table in a separate
927 // section, as in -function-sections, to facilitate lld's --gc-section.
928 LSDASection = Ctx->getWasmSection(".rodata.gcc_except_table",
930
931 // TODO: Define more sections.
932}
933
934void MCObjectFileInfo::initXCOFFMCObjectFileInfo(const Triple &T) {
935 // The default csect for program code. Functions without a specified section
936 // get placed into this csect. The choice of csect name is not a property of
937 // the ABI or object file format, but various tools rely on the section
938 // name being empty (considering named symbols to be "user symbol names").
940 "..text..", // Use a non-null name to work around an AIX assembler bug...
943 /* MultiSymbolsAllowed*/ true);
944
945 // ... but use a null name when generating the symbol table.
946 MCSectionXCOFF *TS = static_cast<MCSectionXCOFF *>(TextSection);
948 TS->setSymbolTableName("");
949
951 ".data", SectionKind::getData(),
953 /* MultiSymbolsAllowed*/ true);
954
956 ".rodata", SectionKind::getReadOnly(),
958 /* MultiSymbolsAllowed*/ true);
960
962 ".rodata.8", SectionKind::getReadOnly(),
964 /* MultiSymbolsAllowed*/ true);
966
968 ".rodata.16", SectionKind::getReadOnly(),
970 /* MultiSymbolsAllowed*/ true);
972
974 ".tdata", SectionKind::getThreadData(),
976 /* MultiSymbolsAllowed*/ true);
977
979 "TOC", SectionKind::getData(),
982
983 // The TOC-base always has 0 size, but 4 byte alignment.
985
987 ".gcc_except_table", SectionKind::getReadOnly(),
990
992 ".eh_info_table", SectionKind::getData(),
995
996 // DWARF sections for XCOFF are not csects. They are special STYP_DWARF
997 // sections, and the individual DWARF sections are distinguished by their
998 // section subtype.
1000 ".dwabrev", SectionKind::getMetadata(),
1001 /* CsectProperties */ std::nullopt,
1002 /* MultiSymbolsAllowed */ true, ".dwabrev", XCOFF::SSUBTYP_DWABREV);
1003
1005 ".dwinfo", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1006 /* MultiSymbolsAllowed */ true, ".dwinfo", XCOFF::SSUBTYP_DWINFO);
1007
1009 ".dwline", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1010 /* MultiSymbolsAllowed */ true, ".dwline", XCOFF::SSUBTYP_DWLINE);
1011
1013 ".dwframe", SectionKind::getMetadata(),
1014 /* CsectProperties */ std::nullopt,
1015 /* MultiSymbolsAllowed */ true, ".dwframe", XCOFF::SSUBTYP_DWFRAME);
1016
1018 ".dwpbnms", SectionKind::getMetadata(),
1019 /* CsectProperties */ std::nullopt,
1020 /* MultiSymbolsAllowed */ true, ".dwpbnms", XCOFF::SSUBTYP_DWPBNMS);
1021
1023 ".dwpbtyp", SectionKind::getMetadata(),
1024 /* CsectProperties */ std::nullopt,
1025 /* MultiSymbolsAllowed */ true, ".dwpbtyp", XCOFF::SSUBTYP_DWPBTYP);
1026
1028 ".dwstr", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1029 /* MultiSymbolsAllowed */ true, ".dwstr", XCOFF::SSUBTYP_DWSTR);
1030
1032 ".dwloc", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1033 /* MultiSymbolsAllowed */ true, ".dwloc", XCOFF::SSUBTYP_DWLOC);
1034
1036 ".dwarnge", SectionKind::getMetadata(),
1037 /* CsectProperties */ std::nullopt,
1038 /* MultiSymbolsAllowed */ true, ".dwarnge", XCOFF::SSUBTYP_DWARNGE);
1039
1041 ".dwrnges", SectionKind::getMetadata(),
1042 /* CsectProperties */ std::nullopt,
1043 /* MultiSymbolsAllowed */ true, ".dwrnges", XCOFF::SSUBTYP_DWRNGES);
1044
1046 ".dwmac", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1047 /* MultiSymbolsAllowed */ true, ".dwmac", XCOFF::SSUBTYP_DWMAC);
1048}
1049
1050void MCObjectFileInfo::initDXContainerObjectFileInfo(const Triple &T) {
1051 // At the moment the DXBC section should end up empty.
1053}
1054
1056
1058 bool LargeCodeModel) {
1059 PositionIndependent = PIC;
1060 Ctx = &MCCtx;
1061
1062 // Common.
1066
1068
1070
1071 EHFrameSection = nullptr; // Created on demand.
1072 CompactUnwindSection = nullptr; // Used only by selected targets.
1073 DwarfAccelNamesSection = nullptr; // Used only by selected targets.
1074 DwarfAccelObjCSection = nullptr; // Used only by selected targets.
1075 DwarfAccelNamespaceSection = nullptr; // Used only by selected targets.
1076 DwarfAccelTypesSection = nullptr; // Used only by selected targets.
1077
1078 Triple TheTriple = Ctx->getTargetTriple();
1079 switch (Ctx->getObjectFileType()) {
1080 case MCContext::IsMachO:
1081 initMachOMCObjectFileInfo(TheTriple);
1082 break;
1083 case MCContext::IsCOFF:
1084 initCOFFMCObjectFileInfo(TheTriple);
1085 break;
1086 case MCContext::IsELF:
1087 initELFMCObjectFileInfo(TheTriple, LargeCodeModel);
1088 break;
1089 case MCContext::IsGOFF:
1090 initGOFFMCObjectFileInfo(TheTriple);
1091 break;
1092 case MCContext::IsSPIRV:
1093 initSPIRVMCObjectFileInfo(TheTriple);
1094 break;
1095 case MCContext::IsWasm:
1096 initWasmMCObjectFileInfo(TheTriple);
1097 break;
1098 case MCContext::IsXCOFF:
1099 initXCOFFMCObjectFileInfo(TheTriple);
1100 break;
1102 initDXContainerObjectFileInfo(TheTriple);
1103 break;
1104 }
1105}
1106
1107MCSection *MCObjectFileInfo::getDwarfComdatSection(const char *Name,
1108 uint64_t Hash) const {
1109 switch (Ctx->getTargetTriple().getObjectFormat()) {
1110 case Triple::ELF:
1112 utostr(Hash), /*IsComdat=*/true);
1113 case Triple::Wasm:
1115 utostr(Hash), MCContext::GenericSectionID);
1116 case Triple::MachO:
1117 case Triple::COFF:
1118 case Triple::GOFF:
1119 case Triple::SPIRV:
1120 case Triple::XCOFF:
1123 report_fatal_error("Cannot get DWARF comdat section for this object file "
1124 "format: not implemented.");
1125 break;
1126 }
1127 llvm_unreachable("Unknown ObjectFormatType");
1128}
1129
1130MCSection *
1132 if ((Ctx->getObjectFileType() != MCContext::IsELF) ||
1133 Ctx->getTargetTriple().isPS4())
1134 return StackSizesSection;
1135
1136 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1137 unsigned Flags = ELF::SHF_LINK_ORDER;
1138 StringRef GroupName;
1139 if (const MCSymbol *Group = ElfSec.getGroup()) {
1140 GroupName = Group->getName();
1141 Flags |= ELF::SHF_GROUP;
1142 }
1143
1144 return Ctx->getELFSection(".stack_sizes", ELF::SHT_PROGBITS, Flags, 0,
1145 GroupName, true, ElfSec.getUniqueID(),
1146 cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1147}
1148
1149MCSection *
1151 if (Ctx->getObjectFileType() != MCContext::IsELF)
1152 return nullptr;
1153
1154 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1155 unsigned Flags = ELF::SHF_LINK_ORDER;
1156 StringRef GroupName;
1157 if (const MCSymbol *Group = ElfSec.getGroup()) {
1158 GroupName = Group->getName();
1159 Flags |= ELF::SHF_GROUP;
1160 }
1161
1162 // Use the text section's begin symbol and unique ID to create a separate
1163 // .llvm_bb_addr_map section associated with every unique text section.
1164 return Ctx->getELFSection(".llvm_bb_addr_map", ELF::SHT_LLVM_BB_ADDR_MAP,
1165 Flags, 0, GroupName, true, ElfSec.getUniqueID(),
1166 cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1167}
1168
1169MCSection *
1171 if (Ctx->getObjectFileType() != MCContext::IsELF)
1172 return nullptr;
1173
1174 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1175 unsigned Flags = ELF::SHF_LINK_ORDER | ELF::SHF_ALLOC;
1176 StringRef GroupName;
1177 if (const MCSymbol *Group = ElfSec.getGroup()) {
1178 GroupName = Group->getName();
1179 Flags |= ELF::SHF_GROUP;
1180 }
1181
1182 return Ctx->getELFSection(".kcfi_traps", ELF::SHT_PROGBITS, Flags, 0,
1183 GroupName,
1184 /*IsComdat=*/true, ElfSec.getUniqueID(),
1185 cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1186}
1187
1188MCSection *
1190 if (Ctx->getObjectFileType() != MCContext::IsELF)
1191 return PseudoProbeSection;
1192
1193 const auto &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1194 unsigned Flags = ELF::SHF_LINK_ORDER;
1195 StringRef GroupName;
1196 if (const MCSymbol *Group = ElfSec.getGroup()) {
1197 GroupName = Group->getName();
1198 Flags |= ELF::SHF_GROUP;
1199 }
1200
1202 Flags, 0, GroupName, true, ElfSec.getUniqueID(),
1203 cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1204}
1205
1206MCSection *
1208 if (Ctx->getObjectFileType() == MCContext::IsELF) {
1209 // Create a separate comdat group for each function's descriptor in order
1210 // for the linker to deduplicate. The duplication, must be from different
1211 // tranlation unit, can come from:
1212 // 1. Inline functions defined in header files;
1213 // 2. ThinLTO imported funcions;
1214 // 3. Weak-linkage definitions.
1215 // Use a concatenation of the section name and the function name as the
1216 // group name so that descriptor-only groups won't be folded with groups of
1217 // code.
1218 if (Ctx->getTargetTriple().supportsCOMDAT() && !FuncName.empty()) {
1219 auto *S = static_cast<MCSectionELF *>(PseudoProbeDescSection);
1220 auto Flags = S->getFlags() | ELF::SHF_GROUP;
1221 return Ctx->getELFSection(S->getName(), S->getType(), Flags,
1222 S->getEntrySize(),
1223 S->getName() + "_" + FuncName,
1224 /*IsComdat=*/true);
1225 }
1226 }
1228}
1229
1231 return LLVMStatsSection;
1232}
1233
1235 const MCSection *TextSec) const {
1236 if (Ctx->getObjectFileType() != MCContext::IsELF)
1237 return nullptr;
1238
1239 // SHF_WRITE for relocations, and let user post-process data in-place.
1241
1242 if (!TextSec)
1243 TextSec = getTextSection();
1244
1245 StringRef GroupName;
1246 const auto &ElfSec = static_cast<const MCSectionELF &>(*TextSec);
1247 if (const MCSymbol *Group = ElfSec.getGroup()) {
1248 GroupName = Group->getName();
1249 Flags |= ELF::SHF_GROUP;
1250 }
1251 return Ctx->getELFSection(Name, ELF::SHT_PROGBITS, Flags, 0, GroupName, true,
1252 ElfSec.getUniqueID(),
1253 cast<MCSymbolELF>(TextSec->getBeginSymbol()));
1254}
std::string Name
static bool useCompactUnwind(const Triple &T)
This file declares the MCSectionGOFF class, which contains all of the necessary machine code sections...
PassInstrumentationCallbacks PIC
This file contains some functions that are useful when dealing with strings.
unsigned getCodePointerSize() const
Get the code pointer size in bytes.
Definition: MCAsmInfo.h:553
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition: MCExpr.cpp:194
Context object for machine code objects.
Definition: MCContext.h:76
MCSectionMachO * getMachOSection(StringRef Segment, StringRef Section, unsigned TypeAndAttributes, unsigned Reserved2, SectionKind K, const char *BeginSymName=nullptr)
Return the MCSection for the specified mach-o section.
Definition: MCContext.cpp:437
Environment getObjectFileType() const
Definition: MCContext.h:429
MCSectionWasm * getWasmSection(const Twine &Section, SectionKind K, unsigned Flags=0)
Definition: MCContext.h:646
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:565
const StringRef & getSwift5ReflectionSegmentName() const
Definition: MCContext.h:431
@ GenericSectionID
Pass this value as the UniqueID during section creation to get the generic section with the given nam...
Definition: MCContext.h:548
MCSectionXCOFF * getXCOFFSection(StringRef Section, SectionKind K, std::optional< XCOFF::CsectProperties > CsectProp=std::nullopt, bool MultiSymbolsAllowed=false, const char *BeginSymName=nullptr, std::optional< XCOFF::DwarfSectionSubtypeFlags > DwarfSubtypeFlags=std::nullopt)
Definition: MCContext.cpp:779
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:446
MCSectionCOFF * getCOFFSection(StringRef Section, unsigned Characteristics, SectionKind Kind, StringRef COMDATSymName, int Selection, unsigned UniqueID=GenericSectionID, const char *BeginSymName=nullptr)
Definition: MCContext.cpp:667
MCSectionDXContainer * getDXContainerSection(StringRef Section, SectionKind K)
Get the section for the provided Section name.
Definition: MCContext.cpp:861
MCSectionSPIRV * getSPIRVSection()
Definition: MCContext.cpp:849
EmitDwarfUnwindType emitDwarfUnwindInfo() const
Definition: MCContext.cpp:928
MCSectionGOFF * getGOFFSection(StringRef Section, SectionKind Kind, MCSection *Parent, const MCExpr *SubsectionId)
Definition: MCContext.cpp:649
const Triple & getTargetTriple() const
Definition: MCContext.h:434
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 * DwarfARangesSection
MCSection * MergeableConst16Section
MCSection * COFFGlobalTypeHashesSection
MCSection * MergeableConst4Section
MCSection * DwarfMacinfoSection
MCSection * DwarfPubNamesSection
MCSection * DwarfGnuPubTypesSection
Section for newer gnu pubtypes.
MCSection * getLLVMStatsSection() const
MCSection * TextSection
Section directive for standard text.
MCSection * ConstDataCoalSection
MCSection * ConstTextCoalSection
MCSection * TLSDataSection
Section directive for Thread Local data. ELF, MachO, COFF, and Wasm.
MCSection * MergeableConst8Section
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) const
MCSection * DwarfLoclistsSection
The DWARF v5 locations list section.
MCSection * PseudoProbeSection
Section for pseudo probe information used by AutoFDO.
MCSection * FourByteConstantSection
MCSection * DwarfAccelNamesSection
MCSection * getStackSizesSection(const MCSection &TextSec) const
MCSection * DwarfRnglistsSection
The DWARF v5 range list section.
const MCSection * DwarfDebugInlineSection
MCSection * DwarfAbbrevDWOSection
MCSection * getBBAddrMapSection(const MCSection &TextSec) const
MCSection * COFFDebugTypesSection
MCSection * LazySymbolPointerSection
MCSection * RemarksSection
Remarks section.
MCSection * getPseudoProbeSection(const MCSection &TextSec) const
MCSection * PseudoProbeDescSection
MCSection * DwarfPubTypesSection
MCSection * DwarfRangesSection
MCSection * DwarfStrOffDWOSection
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 * DwarfAccelObjCSection
MCSection * TLSTLVSection
Section for thread local structure information.
MCSection * DwarfSwiftASTSection
void initMCObjectFileInfo(MCContext &MCCtx, bool PIC, bool LargeCodeModel=false)
MCSection * DwarfRnglistsDWOSection
The DWARF v5 range and location list sections for fission.
MCSection * MergeableConst32Section
MCSection * SixteenByteConstantSection
MCSection * getPCSection(StringRef Name, const MCSection *TextSec) const
MCSection * DwarfLineStrSection
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.
MCSection * DwarfAbbrevSection
unsigned FDECFIEncoding
FDE CFI encoding.
bool SupportsWeakOmittedEHFrame
True if target object file supports a weak_definition of constant 0 for an omitted EH frame.
MCSection * DwarfLoclistsDWOSection
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 * DwarfTypesDWOSection
MCSection * DwarfGnuPubNamesSection
Section for newer gnu pubnames.
MCSection * StackMapSection
StackMap section.
MCSection * DwarfMacroDWOSection
MCSection * DwarfMacinfoDWOSection
MCSection * DwarfAccelNamespaceSection
MCSection * DwarfAccelTypesSection
MCSection * DataSection
Section directive for standard data.
This represents a section on linux, lots of unix variants and some bare metal systems.
Definition: MCSectionELF.h:26
unsigned getUniqueID() const
Definition: MCSectionELF.h:87
const MCSymbolELF * getGroup() const
Definition: MCSectionELF.h:76
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:39
void setAlignment(Align Value)
Definition: MCSection.h:141
StringRef getName() const
Definition: MCSection.h:124
MCSymbol * getBeginSymbol()
Definition: MCSection.h:129
void setSymbolTableName(StringRef STN)
Definition: MCSymbolXCOFF.h:60
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
static SectionKind getThreadData()
Definition: SectionKind.h:207
static SectionKind getMetadata()
Definition: SectionKind.h:188
static SectionKind getMergeable2ByteCString()
Definition: SectionKind.h:196
static SectionKind getMergeableConst4()
Definition: SectionKind.h:202
static SectionKind getText()
Definition: SectionKind.h:190
static SectionKind getReadOnlyWithRel()
Definition: SectionKind.h:214
static SectionKind getData()
Definition: SectionKind.h:213
static SectionKind getMergeableConst8()
Definition: SectionKind.h:203
static SectionKind getBSS()
Definition: SectionKind.h:209
static SectionKind getThreadBSS()
Definition: SectionKind.h:206
static SectionKind getMergeableConst16()
Definition: SectionKind.h:204
static SectionKind getMergeable1ByteCString()
Definition: SectionKind.h:193
static SectionKind getReadOnly()
Definition: SectionKind.h:192
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
bool isPS4() const
Tests whether the target is the PS4 platform.
Definition: Triple.h:736
ObjectFormatType getObjectFormat() const
Get the object format for this triple.
Definition: Triple.h:387
bool supportsCOMDAT() const
Tests whether the target supports comdat.
Definition: Triple.h:1032
@ aarch64_be
Definition: Triple.h:52
@ mips64el
Definition: Triple.h:67
@ aarch64_32
Definition: Triple.h:53
@ DXContainer
Definition: Triple.h:289
@ UnknownObjectFormat
Definition: Triple.h:286
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
SectionCharacteristics
Definition: COFF.h:297
@ IMAGE_SCN_LNK_REMOVE
Definition: COFF.h:307
@ IMAGE_SCN_CNT_CODE
Definition: COFF.h:302
@ IMAGE_SCN_MEM_READ
Definition: COFF.h:335
@ IMAGE_SCN_MEM_EXECUTE
Definition: COFF.h:334
@ IMAGE_SCN_CNT_UNINITIALIZED_DATA
Definition: COFF.h:304
@ IMAGE_SCN_MEM_DISCARDABLE
Definition: COFF.h:330
@ IMAGE_SCN_LNK_INFO
Definition: COFF.h:306
@ IMAGE_SCN_MEM_16BIT
Definition: COFF.h:311
@ IMAGE_SCN_CNT_INITIALIZED_DATA
Definition: COFF.h:303
@ IMAGE_SCN_MEM_WRITE
Definition: COFF.h:336
@ SHF_MERGE
Definition: ELF.h:1160
@ SHF_STRINGS
Definition: ELF.h:1163
@ SHF_EXCLUDE
Definition: ELF.h:1188
@ SHF_ALLOC
Definition: ELF.h:1154
@ SHF_LINK_ORDER
Definition: ELF.h:1169
@ SHF_GROUP
Definition: ELF.h:1176
@ SHF_WRITE
Definition: ELF.h:1151
@ SHF_TLS
Definition: ELF.h:1179
@ SHF_EXECINSTR
Definition: ELF.h:1157
@ SHT_PROGBITS
Definition: ELF.h:1062
@ SHT_NOBITS
Definition: ELF.h:1069
@ SHT_MIPS_DWARF
Definition: ELF.h:1134
@ SHT_LLVM_BB_ADDR_MAP
Definition: ELF.h:1099
@ SHT_X86_64_UNWIND
Definition: ELF.h:1130
@ SK_PPA1
Definition: GOFF.h:169
@ SK_PPA2
Definition: GOFF.h:170
@ 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
@ S_ATTR_DEBUG
S_ATTR_DEBUG - A debug section.
Definition: MachO.h:207
@ S_ATTR_NO_TOC
S_ATTR_NO_TOC - Section contains coalesced symbols that are not to be in a ranlib table of contents.
Definition: MachO.h:195
@ S_ATTR_LIVE_SUPPORT
S_ATTR_LIVE_SUPPORT - Blocks are live if they reference live blocks.
Definition: MachO.h:202
@ S_ATTR_PURE_INSTRUCTIONS
S_ATTR_PURE_INSTRUCTIONS - Section contains only true machine instructions.
Definition: MachO.h:192
@ S_ATTR_STRIP_STATIC_SYMS
S_ATTR_STRIP_STATIC_SYMS - Ok to strip static symbols in this section in files with the MY_DYLDLINK f...
Definition: MachO.h:198
@ SSUBTYP_DWARNGE
DWARF aranges section.
Definition: XCOFF.h:159
@ SSUBTYP_DWFRAME
DWARF frame section.
Definition: XCOFF.h:164
@ SSUBTYP_DWABREV
DWARF abbrev section.
Definition: XCOFF.h:160
@ SSUBTYP_DWINFO
DWARF info section.
Definition: XCOFF.h:155
@ SSUBTYP_DWRNGES
DWARF ranges section.
Definition: XCOFF.h:162
@ SSUBTYP_DWLOC
DWARF loc section.
Definition: XCOFF.h:163
@ SSUBTYP_DWMAC
DWARF macinfo section.
Definition: XCOFF.h:165
@ SSUBTYP_DWPBNMS
DWARF pubnames section.
Definition: XCOFF.h:157
@ SSUBTYP_DWPBTYP
DWARF pubtypes section.
Definition: XCOFF.h:158
@ SSUBTYP_DWLINE
DWARF line section.
Definition: XCOFF.h:156
@ SSUBTYP_DWSTR
DWARF str section.
Definition: XCOFF.h:161
@ XMC_TC0
TOC Anchor for TOC Addressability.
Definition: XCOFF.h:118
@ XMC_RW
Read Write Data.
Definition: XCOFF.h:117
@ XMC_TL
Initialized thread-local variable.
Definition: XCOFF.h:126
@ XMC_RO
Read Only Constant.
Definition: XCOFF.h:106
@ XMC_PR
Program Code.
Definition: XCOFF.h:105
@ XTY_SD
Csect definition for initialized storage.
Definition: XCOFF.h:242
@ DW_EH_PE_pcrel
Definition: Dwarf.h:534
@ DW_EH_PE_sdata4
Definition: Dwarf.h:531
@ DW_EH_PE_sdata8
Definition: Dwarf.h:532
@ DW_EH_PE_absptr
Definition: Dwarf.h:523
@ WASM_SEG_FLAG_STRINGS
Definition: Wasm.h:217
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:156
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39