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 // In fact DW_EH_PE_sdata4 is enough for us now, and GNU ld doesn't
347 // support pcrel|sdata8 well. Let's use sdata4 for now.
348 if (PositionIndependent)
350 else
354 break;
355 case Triple::ppc64:
356 case Triple::ppc64le:
357 case Triple::aarch64:
359 case Triple::x86_64:
362 break;
363 case Triple::bpfel:
364 case Triple::bpfeb:
366 break;
367 case Triple::hexagon:
369 PositionIndependent ? dwarf::DW_EH_PE_pcrel : dwarf::DW_EH_PE_absptr;
370 break;
371 case Triple::xtensa:
373 break;
374 default:
376 break;
377 }
378
379 unsigned EHSectionType = T.getArch() == Triple::x86_64
382
383 // Solaris requires different flags for .eh_frame to seemingly every other
384 // platform.
385 unsigned EHSectionFlags = ELF::SHF_ALLOC;
386 if (T.isOSSolaris() && T.getArch() != Triple::x86_64)
387 EHSectionFlags |= ELF::SHF_WRITE;
388
389 // ELF
392
395
398
401
403 Ctx->getELFSection(".tdata", ELF::SHT_PROGBITS,
405
408
409 DataRelROSection = Ctx->getELFSection(".data.rel.ro", ELF::SHT_PROGBITS,
411
413 Ctx->getELFSection(".rodata.cst4", ELF::SHT_PROGBITS,
415
417 Ctx->getELFSection(".rodata.cst8", ELF::SHT_PROGBITS,
419
421 Ctx->getELFSection(".rodata.cst16", ELF::SHT_PROGBITS,
423
425 Ctx->getELFSection(".rodata.cst32", ELF::SHT_PROGBITS,
427
428 // Exception Handling Sections.
429
430 // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
431 // it contains relocatable pointers. In PIC mode, this is probably a big
432 // runtime hit for C++ apps. Either the contents of the LSDA need to be
433 // adjusted or this should be a data section.
434 LSDASection = Ctx->getELFSection(".gcc_except_table", ELF::SHT_PROGBITS,
436
437 COFFDebugSymbolsSection = nullptr;
438 COFFDebugTypesSection = nullptr;
439
440 unsigned DebugSecType = ELF::SHT_PROGBITS;
441
442 // MIPS .debug_* sections should have SHT_MIPS_DWARF section type
443 // to distinguish among sections contain DWARF and ECOFF debug formats.
444 // Sections with ECOFF debug format are obsoleted and marked by SHT_PROGBITS.
445 if (T.isMIPS())
446 DebugSecType = ELF::SHT_MIPS_DWARF;
447
448 // Debug Info Sections.
450 Ctx->getELFSection(".debug_abbrev", DebugSecType, 0);
451 DwarfInfoSection = Ctx->getELFSection(".debug_info", DebugSecType, 0);
452 DwarfLineSection = Ctx->getELFSection(".debug_line", DebugSecType, 0);
454 Ctx->getELFSection(".debug_line_str", DebugSecType,
456 DwarfFrameSection = Ctx->getELFSection(".debug_frame", DebugSecType, 0);
458 Ctx->getELFSection(".debug_pubnames", DebugSecType, 0);
460 Ctx->getELFSection(".debug_pubtypes", DebugSecType, 0);
462 Ctx->getELFSection(".debug_gnu_pubnames", DebugSecType, 0);
464 Ctx->getELFSection(".debug_gnu_pubtypes", DebugSecType, 0);
466 Ctx->getELFSection(".debug_str", DebugSecType,
468 DwarfLocSection = Ctx->getELFSection(".debug_loc", DebugSecType, 0);
470 Ctx->getELFSection(".debug_aranges", DebugSecType, 0);
472 Ctx->getELFSection(".debug_ranges", DebugSecType, 0);
474 Ctx->getELFSection(".debug_macinfo", DebugSecType, 0);
475 DwarfMacroSection = Ctx->getELFSection(".debug_macro", DebugSecType, 0);
476
477 // DWARF5 Experimental Debug Info
478
479 // Accelerator Tables
481 Ctx->getELFSection(".debug_names", ELF::SHT_PROGBITS, 0);
483 Ctx->getELFSection(".apple_names", ELF::SHT_PROGBITS, 0);
485 Ctx->getELFSection(".apple_objc", ELF::SHT_PROGBITS, 0);
487 Ctx->getELFSection(".apple_namespaces", ELF::SHT_PROGBITS, 0);
489 Ctx->getELFSection(".apple_types", ELF::SHT_PROGBITS, 0);
490
491 // String Offset and Address Sections
493 Ctx->getELFSection(".debug_str_offsets", DebugSecType, 0);
494 DwarfAddrSection = Ctx->getELFSection(".debug_addr", DebugSecType, 0);
495 DwarfRnglistsSection = Ctx->getELFSection(".debug_rnglists", DebugSecType, 0);
496 DwarfLoclistsSection = Ctx->getELFSection(".debug_loclists", DebugSecType, 0);
497
498 // Fission Sections
500 Ctx->getELFSection(".debug_info.dwo", DebugSecType, ELF::SHF_EXCLUDE);
502 Ctx->getELFSection(".debug_types.dwo", DebugSecType, ELF::SHF_EXCLUDE);
504 Ctx->getELFSection(".debug_abbrev.dwo", DebugSecType, ELF::SHF_EXCLUDE);
506 ".debug_str.dwo", DebugSecType,
509 Ctx->getELFSection(".debug_line.dwo", DebugSecType, ELF::SHF_EXCLUDE);
511 Ctx->getELFSection(".debug_loc.dwo", DebugSecType, ELF::SHF_EXCLUDE);
512 DwarfStrOffDWOSection = Ctx->getELFSection(".debug_str_offsets.dwo",
513 DebugSecType, ELF::SHF_EXCLUDE);
515 Ctx->getELFSection(".debug_rnglists.dwo", DebugSecType, ELF::SHF_EXCLUDE);
517 Ctx->getELFSection(".debug_macinfo.dwo", DebugSecType, ELF::SHF_EXCLUDE);
519 Ctx->getELFSection(".debug_macro.dwo", DebugSecType, ELF::SHF_EXCLUDE);
520
522 Ctx->getELFSection(".debug_loclists.dwo", DebugSecType, ELF::SHF_EXCLUDE);
523
524 // DWP Sections
526 Ctx->getELFSection(".debug_cu_index", DebugSecType, 0);
528 Ctx->getELFSection(".debug_tu_index", DebugSecType, 0);
529
531 Ctx->getELFSection(".llvm_stackmaps", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
532
534 Ctx->getELFSection(".llvm_faultmaps", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
535
537 Ctx->getELFSection(".eh_frame", EHSectionType, EHSectionFlags);
538
539 StackSizesSection = Ctx->getELFSection(".stack_sizes", ELF::SHT_PROGBITS, 0);
540
541 PseudoProbeSection = Ctx->getELFSection(".pseudo_probe", DebugSecType, 0);
543 Ctx->getELFSection(".pseudo_probe_desc", DebugSecType, 0);
544
545 LLVMStatsSection = Ctx->getELFSection(".llvm_stats", ELF::SHT_PROGBITS, 0);
546}
547
548void MCObjectFileInfo::initGOFFMCObjectFileInfo(const Triple &T) {
549 TextSection = Ctx->getGOFFSection(".text", SectionKind::getText(), nullptr);
550 BSSSection = Ctx->getGOFFSection(".bss", SectionKind::getBSS(), nullptr);
555
557 Ctx->getGOFFSection(".ppa2list", SectionKind::getData(), nullptr);
558
559 ADASection = Ctx->getGOFFSection(".ada", SectionKind::getData(), nullptr);
560 IDRLSection = Ctx->getGOFFSection("B_IDRL", SectionKind::getData(), nullptr);
561}
562
563void MCObjectFileInfo::initCOFFMCObjectFileInfo(const Triple &T) {
567
568 // Set the `IMAGE_SCN_MEM_16BIT` flag when compiling for thumb mode. This is
569 // used to indicate to the linker that the text segment contains thumb instructions
570 // and to set the ISA selection bit for calls accordingly.
571 const bool IsThumb = T.getArch() == Triple::thumb;
572
573 // COFF
578 ".text",
588
589 if (T.getArch() == Triple::x86_64 || T.getArch() == Triple::aarch64 ||
590 T.getArch() == Triple::arm || T.getArch() == Triple::thumb) {
591 // On Windows with SEH, the LSDA is emitted into the .xdata section
592 LSDASection = nullptr;
593 } else {
594 LSDASection = Ctx->getCOFFSection(".gcc_except_table",
597 }
598
599 // Debug info.
612
614 ".debug_abbrev", COFF::IMAGE_SCN_MEM_DISCARDABLE |
618 ".debug_info", COFF::IMAGE_SCN_MEM_DISCARDABLE |
622 ".debug_line", COFF::IMAGE_SCN_MEM_DISCARDABLE |
626 ".debug_line_str", COFF::IMAGE_SCN_MEM_DISCARDABLE |
630 ".debug_frame", COFF::IMAGE_SCN_MEM_DISCARDABLE |
634 ".debug_pubnames", COFF::IMAGE_SCN_MEM_DISCARDABLE |
638 ".debug_pubtypes", COFF::IMAGE_SCN_MEM_DISCARDABLE |
642 ".debug_gnu_pubnames", COFF::IMAGE_SCN_MEM_DISCARDABLE |
646 ".debug_gnu_pubtypes", COFF::IMAGE_SCN_MEM_DISCARDABLE |
650 ".debug_str", COFF::IMAGE_SCN_MEM_DISCARDABLE |
654 ".debug_str_offsets", COFF::IMAGE_SCN_MEM_DISCARDABLE |
658 ".debug_loc", COFF::IMAGE_SCN_MEM_DISCARDABLE |
662 ".debug_loclists", COFF::IMAGE_SCN_MEM_DISCARDABLE |
666 ".debug_aranges", COFF::IMAGE_SCN_MEM_DISCARDABLE |
670 ".debug_ranges", COFF::IMAGE_SCN_MEM_DISCARDABLE |
674 ".debug_rnglists", COFF::IMAGE_SCN_MEM_DISCARDABLE |
678 ".debug_macinfo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
682 ".debug_macro", COFF::IMAGE_SCN_MEM_DISCARDABLE |
686 ".debug_macinfo.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
690 ".debug_macro.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
694 ".debug_info.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
698 ".debug_types.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
702 ".debug_abbrev.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
706 ".debug_str.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
710 ".debug_line.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
714 ".debug_loc.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
718 ".debug_str_offsets.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
722 ".debug_addr", COFF::IMAGE_SCN_MEM_DISCARDABLE |
726 ".debug_cu_index", COFF::IMAGE_SCN_MEM_DISCARDABLE |
730 ".debug_tu_index", COFF::IMAGE_SCN_MEM_DISCARDABLE |
734 ".debug_names", COFF::IMAGE_SCN_MEM_DISCARDABLE |
738 ".apple_names", COFF::IMAGE_SCN_MEM_DISCARDABLE |
742 ".apple_namespaces", COFF::IMAGE_SCN_MEM_DISCARDABLE |
746 ".apple_types", COFF::IMAGE_SCN_MEM_DISCARDABLE |
750 ".apple_objc", COFF::IMAGE_SCN_MEM_DISCARDABLE |
753
756
760
764
766
770
774
778
782
786
787 StackMapSection = Ctx->getCOFFSection(".llvm_stackmaps",
790}
791
792void MCObjectFileInfo::initSPIRVMCObjectFileInfo(const Triple &T) {
793 // Put everything in a single binary section.
795}
796
797void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
800
802 Ctx->getWasmSection(".debug_line", SectionKind::getMetadata());
804 Ctx->getWasmSection(".debug_line_str", SectionKind::getMetadata(),
809 Ctx->getWasmSection(".debug_loc", SectionKind::getMetadata());
811 Ctx->getWasmSection(".debug_abbrev", SectionKind::getMetadata());
814 Ctx->getWasmSection(".debug_ranges", SectionKind::getMetadata());
816 Ctx->getWasmSection(".debug_macinfo", SectionKind::getMetadata());
818 Ctx->getWasmSection(".debug_macro", SectionKind::getMetadata());
822 Ctx->getWasmSection(".debug_info", SectionKind::getMetadata());
827 Ctx->getWasmSection(".debug_gnu_pubnames", SectionKind::getMetadata());
829 Ctx->getWasmSection(".debug_gnu_pubtypes", SectionKind::getMetadata());
830
832 Ctx->getWasmSection(".debug_names", SectionKind::getMetadata());
834 Ctx->getWasmSection(".debug_str_offsets", SectionKind::getMetadata());
836 Ctx->getWasmSection(".debug_addr", SectionKind::getMetadata());
838 Ctx->getWasmSection(".debug_rnglists", SectionKind::getMetadata());
840 Ctx->getWasmSection(".debug_loclists", SectionKind::getMetadata());
841
842 // Fission Sections
844 Ctx->getWasmSection(".debug_info.dwo", SectionKind::getMetadata());
846 Ctx->getWasmSection(".debug_types.dwo", SectionKind::getMetadata());
848 Ctx->getWasmSection(".debug_abbrev.dwo", SectionKind::getMetadata());
850 Ctx->getWasmSection(".debug_str.dwo", SectionKind::getMetadata(),
853 Ctx->getWasmSection(".debug_line.dwo", SectionKind::getMetadata());
855 Ctx->getWasmSection(".debug_loc.dwo", SectionKind::getMetadata());
857 Ctx->getWasmSection(".debug_str_offsets.dwo", SectionKind::getMetadata());
859 Ctx->getWasmSection(".debug_rnglists.dwo", SectionKind::getMetadata());
861 Ctx->getWasmSection(".debug_macinfo.dwo", SectionKind::getMetadata());
863 Ctx->getWasmSection(".debug_macro.dwo", SectionKind::getMetadata());
864
866 Ctx->getWasmSection(".debug_loclists.dwo", SectionKind::getMetadata());
867
868 // DWP Sections
870 Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata());
872 Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata());
873
874 // Wasm use data section for LSDA.
875 // TODO Consider putting each function's exception table in a separate
876 // section, as in -function-sections, to facilitate lld's --gc-section.
877 LSDASection = Ctx->getWasmSection(".rodata.gcc_except_table",
879
880 // TODO: Define more sections.
881}
882
883void MCObjectFileInfo::initXCOFFMCObjectFileInfo(const Triple &T) {
884 // The default csect for program code. Functions without a specified section
885 // get placed into this csect. The choice of csect name is not a property of
886 // the ABI or object file format, but various tools rely on the section
887 // name being empty (considering named symbols to be "user symbol names").
889 "..text..", // Use a non-null name to work around an AIX assembler bug...
892 /* MultiSymbolsAllowed*/ true);
893
894 // ... but use a null name when generating the symbol table.
895 MCSectionXCOFF *TS = static_cast<MCSectionXCOFF *>(TextSection);
897 TS->setSymbolTableName("");
898
900 ".data", SectionKind::getData(),
902 /* MultiSymbolsAllowed*/ true);
903
905 ".rodata", SectionKind::getReadOnly(),
907 /* MultiSymbolsAllowed*/ true);
909
911 ".rodata.8", SectionKind::getReadOnly(),
913 /* MultiSymbolsAllowed*/ true);
915
917 ".rodata.16", SectionKind::getReadOnly(),
919 /* MultiSymbolsAllowed*/ true);
921
923 ".tdata", SectionKind::getThreadData(),
925 /* MultiSymbolsAllowed*/ true);
926
928 "TOC", SectionKind::getData(),
931
932 // The TOC-base always has 0 size, but 4 byte alignment.
934
936 ".gcc_except_table", SectionKind::getReadOnly(),
939
941 ".eh_info_table", SectionKind::getData(),
944
945 // DWARF sections for XCOFF are not csects. They are special STYP_DWARF
946 // sections, and the individual DWARF sections are distinguished by their
947 // section subtype.
949 ".dwabrev", SectionKind::getMetadata(),
950 /* CsectProperties */ std::nullopt,
951 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWABREV);
952
954 ".dwinfo", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
955 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWINFO);
956
958 ".dwline", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
959 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWLINE);
960
962 ".dwframe", SectionKind::getMetadata(),
963 /* CsectProperties */ std::nullopt,
964 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWFRAME);
965
967 ".dwpbnms", SectionKind::getMetadata(),
968 /* CsectProperties */ std::nullopt,
969 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWPBNMS);
970
972 ".dwpbtyp", SectionKind::getMetadata(),
973 /* CsectProperties */ std::nullopt,
974 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWPBTYP);
975
977 ".dwstr", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
978 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWSTR);
979
981 ".dwloc", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
982 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWLOC);
983
985 ".dwarnge", SectionKind::getMetadata(),
986 /* CsectProperties */ std::nullopt,
987 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWARNGE);
988
990 ".dwrnges", SectionKind::getMetadata(),
991 /* CsectProperties */ std::nullopt,
992 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWRNGES);
993
995 ".dwmac", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
996 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWMAC);
997}
998
999void MCObjectFileInfo::initDXContainerObjectFileInfo(const Triple &T) {
1000 // At the moment the DXBC section should end up empty.
1002}
1003
1005
1007 bool LargeCodeModel) {
1008 PositionIndependent = PIC;
1009 Ctx = &MCCtx;
1010
1011 // Common.
1015
1017
1019
1020 EHFrameSection = nullptr; // Created on demand.
1021 CompactUnwindSection = nullptr; // Used only by selected targets.
1022 DwarfAccelNamesSection = nullptr; // Used only by selected targets.
1023 DwarfAccelObjCSection = nullptr; // Used only by selected targets.
1024 DwarfAccelNamespaceSection = nullptr; // Used only by selected targets.
1025 DwarfAccelTypesSection = nullptr; // Used only by selected targets.
1026
1027 Triple TheTriple = Ctx->getTargetTriple();
1028 switch (Ctx->getObjectFileType()) {
1029 case MCContext::IsMachO:
1030 initMachOMCObjectFileInfo(TheTriple);
1031 break;
1032 case MCContext::IsCOFF:
1033 initCOFFMCObjectFileInfo(TheTriple);
1034 break;
1035 case MCContext::IsELF:
1036 initELFMCObjectFileInfo(TheTriple, LargeCodeModel);
1037 break;
1038 case MCContext::IsGOFF:
1039 initGOFFMCObjectFileInfo(TheTriple);
1040 break;
1041 case MCContext::IsSPIRV:
1042 initSPIRVMCObjectFileInfo(TheTriple);
1043 break;
1044 case MCContext::IsWasm:
1045 initWasmMCObjectFileInfo(TheTriple);
1046 break;
1047 case MCContext::IsXCOFF:
1048 initXCOFFMCObjectFileInfo(TheTriple);
1049 break;
1051 initDXContainerObjectFileInfo(TheTriple);
1052 break;
1053 }
1054}
1055
1056MCSection *MCObjectFileInfo::getDwarfComdatSection(const char *Name,
1057 uint64_t Hash) const {
1058 switch (Ctx->getTargetTriple().getObjectFormat()) {
1059 case Triple::ELF:
1061 utostr(Hash), /*IsComdat=*/true);
1062 case Triple::Wasm:
1064 utostr(Hash), MCContext::GenericSectionID);
1065 case Triple::MachO:
1066 case Triple::COFF:
1067 case Triple::GOFF:
1068 case Triple::SPIRV:
1069 case Triple::XCOFF:
1072 report_fatal_error("Cannot get DWARF comdat section for this object file "
1073 "format: not implemented.");
1074 break;
1075 }
1076 llvm_unreachable("Unknown ObjectFormatType");
1077}
1078
1079MCSection *
1081 if ((Ctx->getObjectFileType() != MCContext::IsELF) ||
1082 Ctx->getTargetTriple().isPS4())
1083 return StackSizesSection;
1084
1085 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1086 unsigned Flags = ELF::SHF_LINK_ORDER;
1087 StringRef GroupName;
1088 if (const MCSymbol *Group = ElfSec.getGroup()) {
1089 GroupName = Group->getName();
1090 Flags |= ELF::SHF_GROUP;
1091 }
1092
1093 return Ctx->getELFSection(".stack_sizes", ELF::SHT_PROGBITS, Flags, 0,
1094 GroupName, true, ElfSec.getUniqueID(),
1095 cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1096}
1097
1098MCSection *
1100 if (Ctx->getObjectFileType() != MCContext::IsELF)
1101 return nullptr;
1102
1103 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1104 unsigned Flags = ELF::SHF_LINK_ORDER;
1105 StringRef GroupName;
1106 if (const MCSymbol *Group = ElfSec.getGroup()) {
1107 GroupName = Group->getName();
1108 Flags |= ELF::SHF_GROUP;
1109 }
1110
1111 // Use the text section's begin symbol and unique ID to create a separate
1112 // .llvm_bb_addr_map section associated with every unique text section.
1113 return Ctx->getELFSection(".llvm_bb_addr_map", ELF::SHT_LLVM_BB_ADDR_MAP,
1114 Flags, 0, GroupName, true, ElfSec.getUniqueID(),
1115 cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1116}
1117
1118MCSection *
1120 if (Ctx->getObjectFileType() != MCContext::IsELF)
1121 return nullptr;
1122
1123 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1124 unsigned Flags = ELF::SHF_LINK_ORDER | ELF::SHF_ALLOC;
1125 StringRef GroupName;
1126 if (const MCSymbol *Group = ElfSec.getGroup()) {
1127 GroupName = Group->getName();
1128 Flags |= ELF::SHF_GROUP;
1129 }
1130
1131 return Ctx->getELFSection(".kcfi_traps", ELF::SHT_PROGBITS, Flags, 0,
1132 GroupName,
1133 /*IsComdat=*/true, ElfSec.getUniqueID(),
1134 cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1135}
1136
1137MCSection *
1139 if (Ctx->getObjectFileType() != MCContext::IsELF)
1140 return PseudoProbeSection;
1141
1142 const auto &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1143 unsigned Flags = ELF::SHF_LINK_ORDER;
1144 StringRef GroupName;
1145 if (const MCSymbol *Group = ElfSec.getGroup()) {
1146 GroupName = Group->getName();
1147 Flags |= ELF::SHF_GROUP;
1148 }
1149
1151 Flags, 0, GroupName, true, ElfSec.getUniqueID(),
1152 cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1153}
1154
1155MCSection *
1157 if (Ctx->getObjectFileType() == MCContext::IsELF) {
1158 // Create a separate comdat group for each function's descriptor in order
1159 // for the linker to deduplicate. The duplication, must be from different
1160 // tranlation unit, can come from:
1161 // 1. Inline functions defined in header files;
1162 // 2. ThinLTO imported funcions;
1163 // 3. Weak-linkage definitions.
1164 // Use a concatenation of the section name and the function name as the
1165 // group name so that descriptor-only groups won't be folded with groups of
1166 // code.
1167 if (Ctx->getTargetTriple().supportsCOMDAT() && !FuncName.empty()) {
1168 auto *S = static_cast<MCSectionELF *>(PseudoProbeDescSection);
1169 auto Flags = S->getFlags() | ELF::SHF_GROUP;
1170 return Ctx->getELFSection(S->getName(), S->getType(), Flags,
1171 S->getEntrySize(),
1172 S->getName() + "_" + FuncName,
1173 /*IsComdat=*/true);
1174 }
1175 }
1177}
1178
1180 return LLVMStatsSection;
1181}
1182
1184 const MCSection *TextSec) const {
1185 if (Ctx->getObjectFileType() != MCContext::IsELF)
1186 return nullptr;
1187
1188 // SHF_WRITE for relocations, and let user post-process data in-place.
1190
1191 if (!TextSec)
1192 TextSec = getTextSection();
1193
1194 StringRef GroupName;
1195 const auto &ElfSec = static_cast<const MCSectionELF &>(*TextSec);
1196 if (const MCSymbol *Group = ElfSec.getGroup()) {
1197 GroupName = Group->getName();
1198 Flags |= ELF::SHF_GROUP;
1199 }
1200 return Ctx->getELFSection(Name, ELF::SHT_PROGBITS, Flags, 0, GroupName, true,
1201 ElfSec.getUniqueID(),
1202 cast<MCSymbolELF>(TextSec->getBeginSymbol()));
1203}
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:546
Context object for machine code objects.
Definition: MCContext.h:83
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:489
Environment getObjectFileType() const
Definition: MCContext.h:395
MCSectionWasm * getWasmSection(const Twine &Section, SectionKind K, unsigned Flags=0)
Definition: MCContext.h:628
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:551
MCSectionXCOFF * getXCOFFSection(StringRef Section, SectionKind K, std::optional< XCOFF::CsectProperties > CsectProp=std::nullopt, bool MultiSymbolsAllowed=false, std::optional< XCOFF::DwarfSectionSubtypeFlags > DwarfSubtypeFlags=std::nullopt)
Definition: MCContext.cpp:800
const StringRef & getSwift5ReflectionSegmentName() const
Definition: MCContext.h:397
MCSectionCOFF * getCOFFSection(StringRef Section, unsigned Characteristics, StringRef COMDATSymName, int Selection, unsigned UniqueID=GenericSectionID)
Definition: MCContext.cpp:693
MCSectionGOFF * getGOFFSection(StringRef Section, SectionKind Kind, MCSection *Parent, uint32_t Subsection=0)
Definition: MCContext.cpp:675
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:412
@ GenericSectionID
Pass this value as the UniqueID during section creation to get the generic section with the given nam...
Definition: MCContext.h:534
MCSectionDXContainer * getDXContainerSection(StringRef Section, SectionKind K)
Get the section for the provided Section name.
Definition: MCContext.cpp:867
MCSectionSPIRV * getSPIRVSection()
Definition: MCContext.cpp:860
EmitDwarfUnwindType emitDwarfUnwindInfo() const
Definition: MCContext.cpp:931
const Triple & getTargetTriple() const
Definition: MCContext.h:400
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:27
unsigned getUniqueID() const
Definition: MCSectionELF.h:92
const MCSymbolELF * getGroup() const
Definition: MCSectionELF.h:82
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:36
void setAlignment(Align Value)
Definition: MCSection.h:145
StringRef getName() const
Definition: MCSection.h:128
MCSymbol * getBeginSymbol()
Definition: MCSection.h:133
void setSymbolTableName(StringRef STN)
Definition: MCSymbolXCOFF.h:63
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
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:754
ObjectFormatType getObjectFormat() const
Get the object format for this triple.
Definition: Triple.h:401
bool supportsCOMDAT() const
Tests whether the target supports comdat.
Definition: Triple.h:1050
@ aarch64_be
Definition: Triple.h:52
@ mips64el
Definition: Triple.h:67
@ aarch64_32
Definition: Triple.h:53
@ DXContainer
Definition: Triple.h:303
@ UnknownObjectFormat
Definition: Triple.h:300
#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
@ SHT_PROGBITS
Definition: ELF.h:1068
@ SHT_NOBITS
Definition: ELF.h:1075
@ SHT_MIPS_DWARF
Definition: ELF.h:1143
@ SHT_LLVM_BB_ADDR_MAP
Definition: ELF.h:1108
@ SHT_X86_64_UNWIND
Definition: ELF.h:1139
@ SHF_MERGE
Definition: ELF.h:1171
@ SHF_STRINGS
Definition: ELF.h:1174
@ SHF_EXCLUDE
Definition: ELF.h:1199
@ SHF_ALLOC
Definition: ELF.h:1165
@ SHF_LINK_ORDER
Definition: ELF.h:1180
@ SHF_GROUP
Definition: ELF.h:1187
@ SHF_WRITE
Definition: ELF.h:1162
@ SHF_TLS
Definition: ELF.h:1190
@ SHF_EXECINSTR
Definition: ELF.h:1168
@ SK_PPA1
Definition: GOFF.h:169
@ SK_PPA2
Definition: GOFF.h:170
@ 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
@ 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
@ 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:851
@ DW_EH_PE_sdata4
Definition: Dwarf.h:848
@ DW_EH_PE_sdata8
Definition: Dwarf.h:849
@ DW_EH_PE_absptr
Definition: Dwarf.h:840
@ WASM_SEG_FLAG_STRINGS
Definition: Wasm.h:218
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:167
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39