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