LLVM 20.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/Wasm.h"
14#include "llvm/MC/MCAsmInfo.h"
15#include "llvm/MC/MCContext.h"
16#include "llvm/MC/MCSection.h"
17#include "llvm/MC/MCSectionCOFF.h"
18#include "llvm/MC/MCSectionDXContainer.h"
19#include "llvm/MC/MCSectionELF.h"
20#include "llvm/MC/MCSectionGOFF.h"
21#include "llvm/MC/MCSectionMachO.h"
22#include "llvm/MC/MCSectionSPIRV.h"
23#include "llvm/MC/MCSectionWasm.h"
24#include "llvm/MC/MCSectionXCOFF.h"
25#include "llvm/Support/Casting.h"
26#include "llvm/TargetParser/Triple.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
64 SupportsWeakOmittedEHFrame = false;
65
66 EHFrameSection = Ctx->getMachOSection(
67 "__TEXT", "__eh_frame",
68 MachO::S_COALESCED | MachO::S_ATTR_NO_TOC |
69 MachO::S_ATTR_STRIP_STATIC_SYMS | MachO::S_ATTR_LIVE_SUPPORT,
70 SectionKind::getReadOnly());
71
72 if (T.isOSDarwin() &&
73 (T.getArch() == Triple::aarch64 || T.getArch() == Triple::aarch64_32 ||
74 T.isSimulatorEnvironment()))
75 SupportsCompactUnwindWithoutEHFrame = true;
76
77 switch (Ctx->emitDwarfUnwindInfo()) {
78 case EmitDwarfUnwindType::Always:
79 OmitDwarfIfHaveCompactUnwind = false;
80 break;
81 case EmitDwarfUnwindType::NoCompactUnwind:
82 OmitDwarfIfHaveCompactUnwind = true;
83 break;
84 case EmitDwarfUnwindType::Default:
85 OmitDwarfIfHaveCompactUnwind =
86 T.isWatchABI() || SupportsCompactUnwindWithoutEHFrame;
87 break;
88 }
89
90 FDECFIEncoding = dwarf::DW_EH_PE_pcrel;
91
92 TextSection // .text
93 = Ctx->getMachOSection("__TEXT", "__text",
94 MachO::S_ATTR_PURE_INSTRUCTIONS,
95 SectionKind::getText());
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",
104 MachO::S_THREAD_LOCAL_REGULAR,
105 SectionKind::getData());
106 TLSBSSSection // .tbss
107 = Ctx->getMachOSection("__DATA", "__thread_bss",
108 MachO::S_THREAD_LOCAL_ZEROFILL,
109 SectionKind::getThreadBSS());
110
111 // TODO: Verify datarel below.
112 TLSTLVSection // .tlv
113 = Ctx->getMachOSection("__DATA", "__thread_vars",
114 MachO::S_THREAD_LOCAL_VARIABLES,
115 SectionKind::getData());
116
117 TLSThreadInitSection = Ctx->getMachOSection(
118 "__DATA", "__thread_init", MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS,
119 SectionKind::getData());
120
121 CStringSection // .cstring
122 = Ctx->getMachOSection("__TEXT", "__cstring",
123 MachO::S_CSTRING_LITERALS,
124 SectionKind::getMergeable1ByteCString());
125 UStringSection
126 = Ctx->getMachOSection("__TEXT","__ustring", 0,
127 SectionKind::getMergeable2ByteCString());
128 FourByteConstantSection // .literal4
129 = Ctx->getMachOSection("__TEXT", "__literal4",
130 MachO::S_4BYTE_LITERALS,
131 SectionKind::getMergeableConst4());
132 EightByteConstantSection // .literal8
133 = Ctx->getMachOSection("__TEXT", "__literal8",
134 MachO::S_8BYTE_LITERALS,
135 SectionKind::getMergeableConst8());
136
137 SixteenByteConstantSection // .literal16
138 = Ctx->getMachOSection("__TEXT", "__literal16",
139 MachO::S_16BYTE_LITERALS,
140 SectionKind::getMergeableConst16());
141
142 ReadOnlySection // .const
143 = Ctx->getMachOSection("__TEXT", "__const", 0,
144 SectionKind::getReadOnly());
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,
156 SectionKind::getReadOnlyWithRel());
157
158 if (ArchTy == Triple::ppc || ArchTy == Triple::ppc64) {
159 TextCoalSection
160 = Ctx->getMachOSection("__TEXT", "__textcoal_nt",
161 MachO::S_COALESCED |
162 MachO::S_ATTR_PURE_INSTRUCTIONS,
163 SectionKind::getText());
164 ConstTextCoalSection
165 = Ctx->getMachOSection("__TEXT", "__const_coal",
166 MachO::S_COALESCED,
167 SectionKind::getReadOnly());
168 DataCoalSection = Ctx->getMachOSection(
169 "__DATA", "__datacoal_nt", MachO::S_COALESCED, SectionKind::getData());
170 ConstDataCoalSection = DataCoalSection;
171 } else {
172 TextCoalSection = TextSection;
173 ConstTextCoalSection = ReadOnlySection;
174 DataCoalSection = DataSection;
175 ConstDataCoalSection = ConstDataSection;
176 }
177
178 DataCommonSection
179 = Ctx->getMachOSection("__DATA","__common",
180 MachO::S_ZEROFILL,
181 SectionKind::getBSS());
182 DataBSSSection
183 = Ctx->getMachOSection("__DATA","__bss", MachO::S_ZEROFILL,
184 SectionKind::getBSS());
185
186
187 LazySymbolPointerSection
188 = Ctx->getMachOSection("__DATA", "__la_symbol_ptr",
189 MachO::S_LAZY_SYMBOL_POINTERS,
190 SectionKind::getMetadata());
191 NonLazySymbolPointerSection
192 = Ctx->getMachOSection("__DATA", "__nl_symbol_ptr",
193 MachO::S_NON_LAZY_SYMBOL_POINTERS,
194 SectionKind::getMetadata());
195
196 ThreadLocalPointerSection
197 = Ctx->getMachOSection("__DATA", "__thread_ptr",
198 MachO::S_THREAD_LOCAL_VARIABLE_POINTERS,
199 SectionKind::getMetadata());
200
201 AddrSigSection = Ctx->getMachOSection("__DATA", "__llvm_addrsig", 0,
202 SectionKind::getData());
203
204 // Exception Handling.
205 LSDASection = Ctx->getMachOSection("__TEXT", "__gcc_except_tab", 0,
206 SectionKind::getReadOnlyWithRel());
207
208 COFFDebugSymbolsSection = nullptr;
209 COFFDebugTypesSection = nullptr;
210 COFFGlobalTypeHashesSection = nullptr;
211
212 if (useCompactUnwind(T)) {
213 CompactUnwindSection =
214 Ctx->getMachOSection("__LD", "__compact_unwind", MachO::S_ATTR_DEBUG,
215 SectionKind::getReadOnly());
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.
226 DwarfDebugNamesSection =
227 Ctx->getMachOSection("__DWARF", "__debug_names", MachO::S_ATTR_DEBUG,
228 SectionKind::getMetadata(), "debug_names_begin");
229 DwarfAccelNamesSection =
230 Ctx->getMachOSection("__DWARF", "__apple_names", MachO::S_ATTR_DEBUG,
231 SectionKind::getMetadata(), "names_begin");
232 DwarfAccelObjCSection =
233 Ctx->getMachOSection("__DWARF", "__apple_objc", MachO::S_ATTR_DEBUG,
234 SectionKind::getMetadata(), "objc_begin");
235 // 16 character section limit...
236 DwarfAccelNamespaceSection =
237 Ctx->getMachOSection("__DWARF", "__apple_namespac", MachO::S_ATTR_DEBUG,
238 SectionKind::getMetadata(), "namespac_begin");
239 DwarfAccelTypesSection =
240 Ctx->getMachOSection("__DWARF", "__apple_types", MachO::S_ATTR_DEBUG,
241 SectionKind::getMetadata(), "types_begin");
242
243 DwarfSwiftASTSection =
244 Ctx->getMachOSection("__DWARF", "__swift_ast", MachO::S_ATTR_DEBUG,
245 SectionKind::getMetadata());
246
247 DwarfAbbrevSection =
248 Ctx->getMachOSection("__DWARF", "__debug_abbrev", MachO::S_ATTR_DEBUG,
249 SectionKind::getMetadata(), "section_abbrev");
250 DwarfInfoSection =
251 Ctx->getMachOSection("__DWARF", "__debug_info", MachO::S_ATTR_DEBUG,
252 SectionKind::getMetadata(), "section_info");
253 DwarfLineSection =
254 Ctx->getMachOSection("__DWARF", "__debug_line", MachO::S_ATTR_DEBUG,
255 SectionKind::getMetadata(), "section_line");
256 DwarfLineStrSection =
257 Ctx->getMachOSection("__DWARF", "__debug_line_str", MachO::S_ATTR_DEBUG,
258 SectionKind::getMetadata(), "section_line_str");
259 DwarfFrameSection =
260 Ctx->getMachOSection("__DWARF", "__debug_frame", MachO::S_ATTR_DEBUG,
261 SectionKind::getMetadata(), "section_frame");
262 DwarfPubNamesSection =
263 Ctx->getMachOSection("__DWARF", "__debug_pubnames", MachO::S_ATTR_DEBUG,
264 SectionKind::getMetadata());
265 DwarfPubTypesSection =
266 Ctx->getMachOSection("__DWARF", "__debug_pubtypes", MachO::S_ATTR_DEBUG,
267 SectionKind::getMetadata());
268 DwarfGnuPubNamesSection =
269 Ctx->getMachOSection("__DWARF", "__debug_gnu_pubn", MachO::S_ATTR_DEBUG,
270 SectionKind::getMetadata());
271 DwarfGnuPubTypesSection =
272 Ctx->getMachOSection("__DWARF", "__debug_gnu_pubt", MachO::S_ATTR_DEBUG,
273 SectionKind::getMetadata());
274 DwarfStrSection =
275 Ctx->getMachOSection("__DWARF", "__debug_str", MachO::S_ATTR_DEBUG,
276 SectionKind::getMetadata(), "info_string");
277 DwarfStrOffSection =
278 Ctx->getMachOSection("__DWARF", "__debug_str_offs", MachO::S_ATTR_DEBUG,
279 SectionKind::getMetadata(), "section_str_off");
280 DwarfAddrSection =
281 Ctx->getMachOSection("__DWARF", "__debug_addr", MachO::S_ATTR_DEBUG,
282 SectionKind::getMetadata(), "section_info");
283 DwarfLocSection =
284 Ctx->getMachOSection("__DWARF", "__debug_loc", MachO::S_ATTR_DEBUG,
285 SectionKind::getMetadata(), "section_debug_loc");
286 DwarfLoclistsSection =
287 Ctx->getMachOSection("__DWARF", "__debug_loclists", MachO::S_ATTR_DEBUG,
288 SectionKind::getMetadata(), "section_debug_loc");
289
290 DwarfARangesSection =
291 Ctx->getMachOSection("__DWARF", "__debug_aranges", MachO::S_ATTR_DEBUG,
292 SectionKind::getMetadata());
293 DwarfRangesSection =
294 Ctx->getMachOSection("__DWARF", "__debug_ranges", MachO::S_ATTR_DEBUG,
295 SectionKind::getMetadata(), "debug_range");
296 DwarfRnglistsSection =
297 Ctx->getMachOSection("__DWARF", "__debug_rnglists", MachO::S_ATTR_DEBUG,
298 SectionKind::getMetadata(), "debug_range");
299 DwarfMacinfoSection =
300 Ctx->getMachOSection("__DWARF", "__debug_macinfo", MachO::S_ATTR_DEBUG,
301 SectionKind::getMetadata(), "debug_macinfo");
302 DwarfMacroSection =
303 Ctx->getMachOSection("__DWARF", "__debug_macro", MachO::S_ATTR_DEBUG,
304 SectionKind::getMetadata(), "debug_macro");
305 DwarfDebugInlineSection =
306 Ctx->getMachOSection("__DWARF", "__debug_inlined", MachO::S_ATTR_DEBUG,
307 SectionKind::getMetadata());
308 DwarfCUIndexSection =
309 Ctx->getMachOSection("__DWARF", "__debug_cu_index", MachO::S_ATTR_DEBUG,
310 SectionKind::getMetadata());
311 DwarfTUIndexSection =
312 Ctx->getMachOSection("__DWARF", "__debug_tu_index", MachO::S_ATTR_DEBUG,
313 SectionKind::getMetadata());
314 StackMapSection = Ctx->getMachOSection("__LLVM_STACKMAPS", "__llvm_stackmaps",
315 0, SectionKind::getMetadata());
316
317 FaultMapSection = Ctx->getMachOSection("__LLVM_FAULTMAPS", "__llvm_faultmaps",
318 0, SectionKind::getMetadata());
319
320 RemarksSection = Ctx->getMachOSection(
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.
326 if (!Ctx->getSwift5ReflectionSegmentName().empty()) {
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
335 TLSExtraDataSection = TLSTLVSection;
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)
349 FDECFIEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
350 else
351 FDECFIEncoding = Ctx->getAsmInfo()->getCodePointerSize() == 4
352 ? dwarf::DW_EH_PE_sdata4
353 : dwarf::DW_EH_PE_sdata8;
354 break;
355 case Triple::ppc64:
356 case Triple::ppc64le:
357 case Triple::aarch64:
358 case Triple::aarch64_be:
359 case Triple::x86_64:
360 FDECFIEncoding = dwarf::DW_EH_PE_pcrel |
361 (Large ? dwarf::DW_EH_PE_sdata8 : dwarf::DW_EH_PE_sdata4);
362 break;
363 case Triple::bpfel:
364 case Triple::bpfeb:
365 FDECFIEncoding = dwarf::DW_EH_PE_sdata8;
366 break;
367 case Triple::hexagon:
368 FDECFIEncoding =
369 PositionIndependent ? dwarf::DW_EH_PE_pcrel : dwarf::DW_EH_PE_absptr;
370 break;
371 case Triple::xtensa:
372 FDECFIEncoding = dwarf::DW_EH_PE_sdata4;
373 break;
374 default:
375 FDECFIEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
376 break;
377 }
378
379 unsigned EHSectionType = T.getArch() == Triple::x86_64
380 ? ELF::SHT_X86_64_UNWIND
381 : ELF::SHT_PROGBITS;
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
390 BSSSection = Ctx->getELFSection(".bss", ELF::SHT_NOBITS,
391 ELF::SHF_WRITE | ELF::SHF_ALLOC);
392
393 TextSection = Ctx->getELFSection(".text", ELF::SHT_PROGBITS,
394 ELF::SHF_EXECINSTR | ELF::SHF_ALLOC);
395
396 DataSection = Ctx->getELFSection(".data", ELF::SHT_PROGBITS,
397 ELF::SHF_WRITE | ELF::SHF_ALLOC);
398
399 ReadOnlySection =
400 Ctx->getELFSection(".rodata", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
401
402 TLSDataSection =
403 Ctx->getELFSection(".tdata", ELF::SHT_PROGBITS,
404 ELF::SHF_ALLOC | ELF::SHF_TLS | ELF::SHF_WRITE);
405
406 TLSBSSSection = Ctx->getELFSection(
407 ".tbss", ELF::SHT_NOBITS, ELF::SHF_ALLOC | ELF::SHF_TLS | ELF::SHF_WRITE);
408
409 DataRelROSection = Ctx->getELFSection(".data.rel.ro", ELF::SHT_PROGBITS,
410 ELF::SHF_ALLOC | ELF::SHF_WRITE);
411
412 MergeableConst4Section =
413 Ctx->getELFSection(".rodata.cst4", ELF::SHT_PROGBITS,
414 ELF::SHF_ALLOC | ELF::SHF_MERGE, 4);
415
416 MergeableConst8Section =
417 Ctx->getELFSection(".rodata.cst8", ELF::SHT_PROGBITS,
418 ELF::SHF_ALLOC | ELF::SHF_MERGE, 8);
419
420 MergeableConst16Section =
421 Ctx->getELFSection(".rodata.cst16", ELF::SHT_PROGBITS,
422 ELF::SHF_ALLOC | ELF::SHF_MERGE, 16);
423
424 MergeableConst32Section =
425 Ctx->getELFSection(".rodata.cst32", ELF::SHT_PROGBITS,
426 ELF::SHF_ALLOC | ELF::SHF_MERGE, 32);
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,
435 ELF::SHF_ALLOC);
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.
449 DwarfAbbrevSection =
450 Ctx->getELFSection(".debug_abbrev", DebugSecType, 0);
451 DwarfInfoSection = Ctx->getELFSection(".debug_info", DebugSecType, 0);
452 DwarfLineSection = Ctx->getELFSection(".debug_line", DebugSecType, 0);
453 DwarfLineStrSection =
454 Ctx->getELFSection(".debug_line_str", DebugSecType,
455 ELF::SHF_MERGE | ELF::SHF_STRINGS, 1);
456 DwarfFrameSection = Ctx->getELFSection(".debug_frame", DebugSecType, 0);
457 DwarfPubNamesSection =
458 Ctx->getELFSection(".debug_pubnames", DebugSecType, 0);
459 DwarfPubTypesSection =
460 Ctx->getELFSection(".debug_pubtypes", DebugSecType, 0);
461 DwarfGnuPubNamesSection =
462 Ctx->getELFSection(".debug_gnu_pubnames", DebugSecType, 0);
463 DwarfGnuPubTypesSection =
464 Ctx->getELFSection(".debug_gnu_pubtypes", DebugSecType, 0);
465 DwarfStrSection =
466 Ctx->getELFSection(".debug_str", DebugSecType,
467 ELF::SHF_MERGE | ELF::SHF_STRINGS, 1);
468 DwarfLocSection = Ctx->getELFSection(".debug_loc", DebugSecType, 0);
469 DwarfARangesSection =
470 Ctx->getELFSection(".debug_aranges", DebugSecType, 0);
471 DwarfRangesSection =
472 Ctx->getELFSection(".debug_ranges", DebugSecType, 0);
473 DwarfMacinfoSection =
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
480 DwarfDebugNamesSection =
481 Ctx->getELFSection(".debug_names", ELF::SHT_PROGBITS, 0);
482 DwarfAccelNamesSection =
483 Ctx->getELFSection(".apple_names", ELF::SHT_PROGBITS, 0);
484 DwarfAccelObjCSection =
485 Ctx->getELFSection(".apple_objc", ELF::SHT_PROGBITS, 0);
486 DwarfAccelNamespaceSection =
487 Ctx->getELFSection(".apple_namespaces", ELF::SHT_PROGBITS, 0);
488 DwarfAccelTypesSection =
489 Ctx->getELFSection(".apple_types", ELF::SHT_PROGBITS, 0);
490
491 // String Offset and Address Sections
492 DwarfStrOffSection =
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
499 DwarfInfoDWOSection =
500 Ctx->getELFSection(".debug_info.dwo", DebugSecType, ELF::SHF_EXCLUDE);
501 DwarfTypesDWOSection =
502 Ctx->getELFSection(".debug_types.dwo", DebugSecType, ELF::SHF_EXCLUDE);
503 DwarfAbbrevDWOSection =
504 Ctx->getELFSection(".debug_abbrev.dwo", DebugSecType, ELF::SHF_EXCLUDE);
505 DwarfStrDWOSection = Ctx->getELFSection(
506 ".debug_str.dwo", DebugSecType,
507 ELF::SHF_MERGE | ELF::SHF_STRINGS | ELF::SHF_EXCLUDE, 1);
508 DwarfLineDWOSection =
509 Ctx->getELFSection(".debug_line.dwo", DebugSecType, ELF::SHF_EXCLUDE);
510 DwarfLocDWOSection =
511 Ctx->getELFSection(".debug_loc.dwo", DebugSecType, ELF::SHF_EXCLUDE);
512 DwarfStrOffDWOSection = Ctx->getELFSection(".debug_str_offsets.dwo",
513 DebugSecType, ELF::SHF_EXCLUDE);
514 DwarfRnglistsDWOSection =
515 Ctx->getELFSection(".debug_rnglists.dwo", DebugSecType, ELF::SHF_EXCLUDE);
516 DwarfMacinfoDWOSection =
517 Ctx->getELFSection(".debug_macinfo.dwo", DebugSecType, ELF::SHF_EXCLUDE);
518 DwarfMacroDWOSection =
519 Ctx->getELFSection(".debug_macro.dwo", DebugSecType, ELF::SHF_EXCLUDE);
520
521 DwarfLoclistsDWOSection =
522 Ctx->getELFSection(".debug_loclists.dwo", DebugSecType, ELF::SHF_EXCLUDE);
523
524 // DWP Sections
525 DwarfCUIndexSection =
526 Ctx->getELFSection(".debug_cu_index", DebugSecType, 0);
527 DwarfTUIndexSection =
528 Ctx->getELFSection(".debug_tu_index", DebugSecType, 0);
529
530 StackMapSection =
531 Ctx->getELFSection(".llvm_stackmaps", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
532
533 FaultMapSection =
534 Ctx->getELFSection(".llvm_faultmaps", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
535
536 EHFrameSection =
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);
542 PseudoProbeDescSection =
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);
551 PPA1Section = Ctx->getGOFFSection(".ppa1", SectionKind::getMetadata(),
552 TextSection, GOFF::SK_PPA1);
553 PPA2Section = Ctx->getGOFFSection(".ppa2", SectionKind::getMetadata(),
554 TextSection, GOFF::SK_PPA2);
555
556 PPA2ListSection =
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) {
564 EHFrameSection =
565 Ctx->getCOFFSection(".eh_frame", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
566 COFF::IMAGE_SCN_MEM_READ);
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
574 BSSSection = Ctx->getCOFFSection(
575 ".bss", COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
576 COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE);
577 TextSection = Ctx->getCOFFSection(
578 ".text",
579 (IsThumb ? COFF::IMAGE_SCN_MEM_16BIT : (COFF::SectionCharacteristics)0) |
580 COFF::IMAGE_SCN_CNT_CODE | COFF::IMAGE_SCN_MEM_EXECUTE |
581 COFF::IMAGE_SCN_MEM_READ);
582 DataSection = Ctx->getCOFFSection(
583 ".data", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ |
584 COFF::IMAGE_SCN_MEM_WRITE);
585 ReadOnlySection =
586 Ctx->getCOFFSection(".rdata", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
587 COFF::IMAGE_SCN_MEM_READ);
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",
595 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
596 COFF::IMAGE_SCN_MEM_READ);
597 }
598
599 if (T.getArch() == Triple::aarch64) {
600 ImportCallSection =
601 Ctx->getCOFFSection(".impcall", COFF::IMAGE_SCN_LNK_INFO);
602 }
603
604 // Debug info.
605 COFFDebugSymbolsSection =
606 Ctx->getCOFFSection(".debug$S", (COFF::IMAGE_SCN_MEM_DISCARDABLE |
607 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
608 COFF::IMAGE_SCN_MEM_READ));
609 COFFDebugTypesSection =
610 Ctx->getCOFFSection(".debug$T", (COFF::IMAGE_SCN_MEM_DISCARDABLE |
611 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
612 COFF::IMAGE_SCN_MEM_READ));
613 COFFGlobalTypeHashesSection =
614 Ctx->getCOFFSection(".debug$H", (COFF::IMAGE_SCN_MEM_DISCARDABLE |
615 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
616 COFF::IMAGE_SCN_MEM_READ));
617
618 DwarfAbbrevSection = Ctx->getCOFFSection(
619 ".debug_abbrev", COFF::IMAGE_SCN_MEM_DISCARDABLE |
620 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
621 COFF::IMAGE_SCN_MEM_READ);
622 DwarfInfoSection = Ctx->getCOFFSection(
623 ".debug_info", COFF::IMAGE_SCN_MEM_DISCARDABLE |
624 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
625 COFF::IMAGE_SCN_MEM_READ);
626 DwarfLineSection = Ctx->getCOFFSection(
627 ".debug_line", COFF::IMAGE_SCN_MEM_DISCARDABLE |
628 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
629 COFF::IMAGE_SCN_MEM_READ);
630 DwarfLineStrSection = Ctx->getCOFFSection(
631 ".debug_line_str", COFF::IMAGE_SCN_MEM_DISCARDABLE |
632 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
633 COFF::IMAGE_SCN_MEM_READ);
634 DwarfFrameSection = Ctx->getCOFFSection(
635 ".debug_frame", COFF::IMAGE_SCN_MEM_DISCARDABLE |
636 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
637 COFF::IMAGE_SCN_MEM_READ);
638 DwarfPubNamesSection = Ctx->getCOFFSection(
639 ".debug_pubnames", COFF::IMAGE_SCN_MEM_DISCARDABLE |
640 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
641 COFF::IMAGE_SCN_MEM_READ);
642 DwarfPubTypesSection = Ctx->getCOFFSection(
643 ".debug_pubtypes", COFF::IMAGE_SCN_MEM_DISCARDABLE |
644 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
645 COFF::IMAGE_SCN_MEM_READ);
646 DwarfGnuPubNamesSection = Ctx->getCOFFSection(
647 ".debug_gnu_pubnames", COFF::IMAGE_SCN_MEM_DISCARDABLE |
648 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
649 COFF::IMAGE_SCN_MEM_READ);
650 DwarfGnuPubTypesSection = Ctx->getCOFFSection(
651 ".debug_gnu_pubtypes", COFF::IMAGE_SCN_MEM_DISCARDABLE |
652 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
653 COFF::IMAGE_SCN_MEM_READ);
654 DwarfStrSection = Ctx->getCOFFSection(
655 ".debug_str", COFF::IMAGE_SCN_MEM_DISCARDABLE |
656 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
657 COFF::IMAGE_SCN_MEM_READ);
658 DwarfStrOffSection = Ctx->getCOFFSection(
659 ".debug_str_offsets", COFF::IMAGE_SCN_MEM_DISCARDABLE |
660 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
661 COFF::IMAGE_SCN_MEM_READ);
662 DwarfLocSection = Ctx->getCOFFSection(
663 ".debug_loc", COFF::IMAGE_SCN_MEM_DISCARDABLE |
664 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
665 COFF::IMAGE_SCN_MEM_READ);
666 DwarfLoclistsSection = Ctx->getCOFFSection(
667 ".debug_loclists", COFF::IMAGE_SCN_MEM_DISCARDABLE |
668 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
669 COFF::IMAGE_SCN_MEM_READ);
670 DwarfARangesSection = Ctx->getCOFFSection(
671 ".debug_aranges", COFF::IMAGE_SCN_MEM_DISCARDABLE |
672 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
673 COFF::IMAGE_SCN_MEM_READ);
674 DwarfRangesSection = Ctx->getCOFFSection(
675 ".debug_ranges", COFF::IMAGE_SCN_MEM_DISCARDABLE |
676 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
677 COFF::IMAGE_SCN_MEM_READ);
678 DwarfRnglistsSection = Ctx->getCOFFSection(
679 ".debug_rnglists", COFF::IMAGE_SCN_MEM_DISCARDABLE |
680 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
681 COFF::IMAGE_SCN_MEM_READ);
682 DwarfMacinfoSection = Ctx->getCOFFSection(
683 ".debug_macinfo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
684 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
685 COFF::IMAGE_SCN_MEM_READ);
686 DwarfMacroSection = Ctx->getCOFFSection(
687 ".debug_macro", COFF::IMAGE_SCN_MEM_DISCARDABLE |
688 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
689 COFF::IMAGE_SCN_MEM_READ);
690 DwarfMacinfoDWOSection = Ctx->getCOFFSection(
691 ".debug_macinfo.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
692 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
693 COFF::IMAGE_SCN_MEM_READ);
694 DwarfMacroDWOSection = Ctx->getCOFFSection(
695 ".debug_macro.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
696 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
697 COFF::IMAGE_SCN_MEM_READ);
698 DwarfInfoDWOSection = Ctx->getCOFFSection(
699 ".debug_info.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
700 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
701 COFF::IMAGE_SCN_MEM_READ);
702 DwarfTypesDWOSection = Ctx->getCOFFSection(
703 ".debug_types.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
704 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
705 COFF::IMAGE_SCN_MEM_READ);
706 DwarfAbbrevDWOSection = Ctx->getCOFFSection(
707 ".debug_abbrev.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
708 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
709 COFF::IMAGE_SCN_MEM_READ);
710 DwarfStrDWOSection = Ctx->getCOFFSection(
711 ".debug_str.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
712 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
713 COFF::IMAGE_SCN_MEM_READ);
714 DwarfLineDWOSection = Ctx->getCOFFSection(
715 ".debug_line.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
716 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
717 COFF::IMAGE_SCN_MEM_READ);
718 DwarfLocDWOSection = Ctx->getCOFFSection(
719 ".debug_loc.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
720 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
721 COFF::IMAGE_SCN_MEM_READ);
722 DwarfStrOffDWOSection = Ctx->getCOFFSection(
723 ".debug_str_offsets.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
724 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
725 COFF::IMAGE_SCN_MEM_READ);
726 DwarfAddrSection = Ctx->getCOFFSection(
727 ".debug_addr", COFF::IMAGE_SCN_MEM_DISCARDABLE |
728 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
729 COFF::IMAGE_SCN_MEM_READ);
730 DwarfCUIndexSection = Ctx->getCOFFSection(
731 ".debug_cu_index", COFF::IMAGE_SCN_MEM_DISCARDABLE |
732 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
733 COFF::IMAGE_SCN_MEM_READ);
734 DwarfTUIndexSection = Ctx->getCOFFSection(
735 ".debug_tu_index", COFF::IMAGE_SCN_MEM_DISCARDABLE |
736 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
737 COFF::IMAGE_SCN_MEM_READ);
738 DwarfDebugNamesSection = Ctx->getCOFFSection(
739 ".debug_names", COFF::IMAGE_SCN_MEM_DISCARDABLE |
740 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
741 COFF::IMAGE_SCN_MEM_READ);
742 DwarfAccelNamesSection = Ctx->getCOFFSection(
743 ".apple_names", COFF::IMAGE_SCN_MEM_DISCARDABLE |
744 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
745 COFF::IMAGE_SCN_MEM_READ);
746 DwarfAccelNamespaceSection = Ctx->getCOFFSection(
747 ".apple_namespaces", COFF::IMAGE_SCN_MEM_DISCARDABLE |
748 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
749 COFF::IMAGE_SCN_MEM_READ);
750 DwarfAccelTypesSection = Ctx->getCOFFSection(
751 ".apple_types", COFF::IMAGE_SCN_MEM_DISCARDABLE |
752 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
753 COFF::IMAGE_SCN_MEM_READ);
754 DwarfAccelObjCSection = Ctx->getCOFFSection(
755 ".apple_objc", COFF::IMAGE_SCN_MEM_DISCARDABLE |
756 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
757 COFF::IMAGE_SCN_MEM_READ);
758
759 DrectveSection = Ctx->getCOFFSection(
760 ".drectve", COFF::IMAGE_SCN_LNK_INFO | COFF::IMAGE_SCN_LNK_REMOVE);
761
762 PDataSection =
763 Ctx->getCOFFSection(".pdata", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
764 COFF::IMAGE_SCN_MEM_READ);
765
766 XDataSection =
767 Ctx->getCOFFSection(".xdata", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
768 COFF::IMAGE_SCN_MEM_READ);
769
770 SXDataSection = Ctx->getCOFFSection(".sxdata", COFF::IMAGE_SCN_LNK_INFO);
771
772 GEHContSection =
773 Ctx->getCOFFSection(".gehcont$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
774 COFF::IMAGE_SCN_MEM_READ);
775
776 GFIDsSection =
777 Ctx->getCOFFSection(".gfids$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
778 COFF::IMAGE_SCN_MEM_READ);
779
780 GIATsSection =
781 Ctx->getCOFFSection(".giats$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
782 COFF::IMAGE_SCN_MEM_READ);
783
784 GLJMPSection =
785 Ctx->getCOFFSection(".gljmp$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
786 COFF::IMAGE_SCN_MEM_READ);
787
788 TLSDataSection = Ctx->getCOFFSection(
789 ".tls$", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ |
790 COFF::IMAGE_SCN_MEM_WRITE);
791
792 StackMapSection = Ctx->getCOFFSection(".llvm_stackmaps",
793 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
794 COFF::IMAGE_SCN_MEM_READ);
795}
796
797void MCObjectFileInfo::initSPIRVMCObjectFileInfo(const Triple &T) {
798 // Put everything in a single binary section.
799 TextSection = Ctx->getSPIRVSection();
800}
801
802void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
803 TextSection = Ctx->getWasmSection(".text", SectionKind::getText());
804 DataSection = Ctx->getWasmSection(".data", SectionKind::getData());
805
806 DwarfLineSection =
807 Ctx->getWasmSection(".debug_line", SectionKind::getMetadata());
808 DwarfLineStrSection =
809 Ctx->getWasmSection(".debug_line_str", SectionKind::getMetadata(),
810 wasm::WASM_SEG_FLAG_STRINGS);
811 DwarfStrSection = Ctx->getWasmSection(
812 ".debug_str", SectionKind::getMetadata(), wasm::WASM_SEG_FLAG_STRINGS);
813 DwarfLocSection =
814 Ctx->getWasmSection(".debug_loc", SectionKind::getMetadata());
815 DwarfAbbrevSection =
816 Ctx->getWasmSection(".debug_abbrev", SectionKind::getMetadata());
817 DwarfARangesSection = Ctx->getWasmSection(".debug_aranges", SectionKind::getMetadata());
818 DwarfRangesSection =
819 Ctx->getWasmSection(".debug_ranges", SectionKind::getMetadata());
820 DwarfMacinfoSection =
821 Ctx->getWasmSection(".debug_macinfo", SectionKind::getMetadata());
822 DwarfMacroSection =
823 Ctx->getWasmSection(".debug_macro", SectionKind::getMetadata());
824 DwarfCUIndexSection = Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata());
825 DwarfTUIndexSection = Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata());
826 DwarfInfoSection =
827 Ctx->getWasmSection(".debug_info", SectionKind::getMetadata());
828 DwarfFrameSection = Ctx->getWasmSection(".debug_frame", SectionKind::getMetadata());
829 DwarfPubNamesSection = Ctx->getWasmSection(".debug_pubnames", SectionKind::getMetadata());
830 DwarfPubTypesSection = Ctx->getWasmSection(".debug_pubtypes", SectionKind::getMetadata());
831 DwarfGnuPubNamesSection =
832 Ctx->getWasmSection(".debug_gnu_pubnames", SectionKind::getMetadata());
833 DwarfGnuPubTypesSection =
834 Ctx->getWasmSection(".debug_gnu_pubtypes", SectionKind::getMetadata());
835
836 DwarfDebugNamesSection =
837 Ctx->getWasmSection(".debug_names", SectionKind::getMetadata());
838 DwarfStrOffSection =
839 Ctx->getWasmSection(".debug_str_offsets", SectionKind::getMetadata());
840 DwarfAddrSection =
841 Ctx->getWasmSection(".debug_addr", SectionKind::getMetadata());
842 DwarfRnglistsSection =
843 Ctx->getWasmSection(".debug_rnglists", SectionKind::getMetadata());
844 DwarfLoclistsSection =
845 Ctx->getWasmSection(".debug_loclists", SectionKind::getMetadata());
846
847 // Fission Sections
848 DwarfInfoDWOSection =
849 Ctx->getWasmSection(".debug_info.dwo", SectionKind::getMetadata());
850 DwarfTypesDWOSection =
851 Ctx->getWasmSection(".debug_types.dwo", SectionKind::getMetadata());
852 DwarfAbbrevDWOSection =
853 Ctx->getWasmSection(".debug_abbrev.dwo", SectionKind::getMetadata());
854 DwarfStrDWOSection =
855 Ctx->getWasmSection(".debug_str.dwo", SectionKind::getMetadata(),
856 wasm::WASM_SEG_FLAG_STRINGS);
857 DwarfLineDWOSection =
858 Ctx->getWasmSection(".debug_line.dwo", SectionKind::getMetadata());
859 DwarfLocDWOSection =
860 Ctx->getWasmSection(".debug_loc.dwo", SectionKind::getMetadata());
861 DwarfStrOffDWOSection =
862 Ctx->getWasmSection(".debug_str_offsets.dwo", SectionKind::getMetadata());
863 DwarfRnglistsDWOSection =
864 Ctx->getWasmSection(".debug_rnglists.dwo", SectionKind::getMetadata());
865 DwarfMacinfoDWOSection =
866 Ctx->getWasmSection(".debug_macinfo.dwo", SectionKind::getMetadata());
867 DwarfMacroDWOSection =
868 Ctx->getWasmSection(".debug_macro.dwo", SectionKind::getMetadata());
869
870 DwarfLoclistsDWOSection =
871 Ctx->getWasmSection(".debug_loclists.dwo", SectionKind::getMetadata());
872
873 // DWP Sections
874 DwarfCUIndexSection =
875 Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata());
876 DwarfTUIndexSection =
877 Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata());
878
879 // Wasm use data section for LSDA.
880 // TODO Consider putting each function's exception table in a separate
881 // section, as in -function-sections, to facilitate lld's --gc-section.
882 LSDASection = Ctx->getWasmSection(".rodata.gcc_except_table",
883 SectionKind::getReadOnlyWithRel());
884
885 // TODO: Define more sections.
886}
887
888void MCObjectFileInfo::initXCOFFMCObjectFileInfo(const Triple &T) {
889 // The default csect for program code. Functions without a specified section
890 // get placed into this csect. The choice of csect name is not a property of
891 // the ABI or object file format, but various tools rely on the section
892 // name being empty (considering named symbols to be "user symbol names").
893 TextSection = Ctx->getXCOFFSection(
894 "..text..", // Use a non-null name to work around an AIX assembler bug...
895 SectionKind::getText(),
896 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_PR, XCOFF::XTY_SD),
897 /* MultiSymbolsAllowed*/ true);
898
899 // ... but use a null name when generating the symbol table.
900 MCSectionXCOFF *TS = static_cast<MCSectionXCOFF *>(TextSection);
901 TS->getQualNameSymbol()->setSymbolTableName("");
902 TS->setSymbolTableName("");
903
904 DataSection = Ctx->getXCOFFSection(
905 ".data", SectionKind::getData(),
906 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RW, XCOFF::XTY_SD),
907 /* MultiSymbolsAllowed*/ true);
908
909 ReadOnlySection = Ctx->getXCOFFSection(
910 ".rodata", SectionKind::getReadOnly(),
911 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD),
912 /* MultiSymbolsAllowed*/ true);
913 ReadOnlySection->setAlignment(Align(4));
914
915 ReadOnly8Section = Ctx->getXCOFFSection(
916 ".rodata.8", SectionKind::getReadOnly(),
917 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD),
918 /* MultiSymbolsAllowed*/ true);
919 ReadOnly8Section->setAlignment(Align(8));
920
921 ReadOnly16Section = Ctx->getXCOFFSection(
922 ".rodata.16", SectionKind::getReadOnly(),
923 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD),
924 /* MultiSymbolsAllowed*/ true);
925 ReadOnly16Section->setAlignment(Align(16));
926
927 TLSDataSection = Ctx->getXCOFFSection(
928 ".tdata", SectionKind::getThreadData(),
929 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_TL, XCOFF::XTY_SD),
930 /* MultiSymbolsAllowed*/ true);
931
932 TOCBaseSection = Ctx->getXCOFFSection(
933 "TOC", SectionKind::getData(),
934 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_TC0,
935 XCOFF::XTY_SD));
936
937 // The TOC-base always has 0 size, but 4 byte alignment.
938 TOCBaseSection->setAlignment(Align(4));
939
940 LSDASection = Ctx->getXCOFFSection(
941 ".gcc_except_table", SectionKind::getReadOnly(),
942 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO,
943 XCOFF::XTY_SD));
944
945 CompactUnwindSection = Ctx->getXCOFFSection(
946 ".eh_info_table", SectionKind::getData(),
947 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RW,
948 XCOFF::XTY_SD));
949
950 // DWARF sections for XCOFF are not csects. They are special STYP_DWARF
951 // sections, and the individual DWARF sections are distinguished by their
952 // section subtype.
953 DwarfAbbrevSection = Ctx->getXCOFFSection(
954 ".dwabrev", SectionKind::getMetadata(),
955 /* CsectProperties */ std::nullopt,
956 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWABREV);
957
958 DwarfInfoSection = Ctx->getXCOFFSection(
959 ".dwinfo", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
960 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWINFO);
961
962 DwarfLineSection = Ctx->getXCOFFSection(
963 ".dwline", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
964 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWLINE);
965
966 DwarfFrameSection = Ctx->getXCOFFSection(
967 ".dwframe", SectionKind::getMetadata(),
968 /* CsectProperties */ std::nullopt,
969 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWFRAME);
970
971 DwarfPubNamesSection = Ctx->getXCOFFSection(
972 ".dwpbnms", SectionKind::getMetadata(),
973 /* CsectProperties */ std::nullopt,
974 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWPBNMS);
975
976 DwarfPubTypesSection = Ctx->getXCOFFSection(
977 ".dwpbtyp", SectionKind::getMetadata(),
978 /* CsectProperties */ std::nullopt,
979 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWPBTYP);
980
981 DwarfStrSection = Ctx->getXCOFFSection(
982 ".dwstr", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
983 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWSTR);
984
985 DwarfLocSection = Ctx->getXCOFFSection(
986 ".dwloc", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
987 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWLOC);
988
989 DwarfARangesSection = Ctx->getXCOFFSection(
990 ".dwarnge", SectionKind::getMetadata(),
991 /* CsectProperties */ std::nullopt,
992 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWARNGE);
993
994 DwarfRangesSection = Ctx->getXCOFFSection(
995 ".dwrnges", SectionKind::getMetadata(),
996 /* CsectProperties */ std::nullopt,
997 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWRNGES);
998
999 DwarfMacinfoSection = Ctx->getXCOFFSection(
1000 ".dwmac", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1001 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWMAC);
1002}
1003
1004void MCObjectFileInfo::initDXContainerObjectFileInfo(const Triple &T) {
1005 // At the moment the DXBC section should end up empty.
1006 TextSection = Ctx->getDXContainerSection("DXBC", SectionKind::getText());
1007}
1008
1009MCObjectFileInfo::~MCObjectFileInfo() = default;
1010
1011void MCObjectFileInfo::initMCObjectFileInfo(MCContext &MCCtx, bool PIC,
1012 bool LargeCodeModel) {
1013 PositionIndependent = PIC;
1014 Ctx = &MCCtx;
1015
1016 // Common.
1017 SupportsWeakOmittedEHFrame = true;
1018 SupportsCompactUnwindWithoutEHFrame = false;
1019 OmitDwarfIfHaveCompactUnwind = false;
1020
1021 FDECFIEncoding = dwarf::DW_EH_PE_absptr;
1022
1023 CompactUnwindDwarfEHFrameOnly = 0;
1024
1025 EHFrameSection = nullptr; // Created on demand.
1026 CompactUnwindSection = nullptr; // Used only by selected targets.
1027 DwarfAccelNamesSection = nullptr; // Used only by selected targets.
1028 DwarfAccelObjCSection = nullptr; // Used only by selected targets.
1029 DwarfAccelNamespaceSection = nullptr; // Used only by selected targets.
1030 DwarfAccelTypesSection = nullptr; // Used only by selected targets.
1031
1032 const Triple &TheTriple = Ctx->getTargetTriple();
1033 switch (Ctx->getObjectFileType()) {
1034 case MCContext::IsMachO:
1035 initMachOMCObjectFileInfo(TheTriple);
1036 break;
1037 case MCContext::IsCOFF:
1038 initCOFFMCObjectFileInfo(TheTriple);
1039 break;
1040 case MCContext::IsELF:
1041 initELFMCObjectFileInfo(TheTriple, LargeCodeModel);
1042 break;
1043 case MCContext::IsGOFF:
1044 initGOFFMCObjectFileInfo(TheTriple);
1045 break;
1046 case MCContext::IsSPIRV:
1047 initSPIRVMCObjectFileInfo(TheTriple);
1048 break;
1049 case MCContext::IsWasm:
1050 initWasmMCObjectFileInfo(TheTriple);
1051 break;
1052 case MCContext::IsXCOFF:
1053 initXCOFFMCObjectFileInfo(TheTriple);
1054 break;
1055 case MCContext::IsDXContainer:
1056 initDXContainerObjectFileInfo(TheTriple);
1057 break;
1058 }
1059}
1060
1061MCSection *MCObjectFileInfo::getDwarfComdatSection(const char *Name,
1062 uint64_t Hash) const {
1063 switch (Ctx->getTargetTriple().getObjectFormat()) {
1064 case Triple::ELF:
1065 return Ctx->getELFSection(Name, ELF::SHT_PROGBITS, ELF::SHF_GROUP, 0,
1066 utostr(Hash), /*IsComdat=*/true);
1067 case Triple::Wasm:
1068 return Ctx->getWasmSection(Name, SectionKind::getMetadata(), 0,
1069 utostr(Hash), MCContext::GenericSectionID);
1070 case Triple::MachO:
1071 case Triple::COFF:
1072 case Triple::GOFF:
1073 case Triple::SPIRV:
1074 case Triple::XCOFF:
1075 case Triple::DXContainer:
1076 case Triple::UnknownObjectFormat:
1077 report_fatal_error("Cannot get DWARF comdat section for this object file "
1078 "format: not implemented.");
1079 break;
1080 }
1081 llvm_unreachable("Unknown ObjectFormatType");
1082}
1083
1084MCSection *
1085MCObjectFileInfo::getStackSizesSection(const MCSection &TextSec) const {
1086 if ((Ctx->getObjectFileType() != MCContext::IsELF) ||
1087 Ctx->getTargetTriple().isPS4())
1088 return StackSizesSection;
1089
1090 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1091 unsigned Flags = ELF::SHF_LINK_ORDER;
1092 StringRef GroupName;
1093 if (const MCSymbol *Group = ElfSec.getGroup()) {
1094 GroupName = Group->getName();
1095 Flags |= ELF::SHF_GROUP;
1096 }
1097
1098 return Ctx->getELFSection(".stack_sizes", ELF::SHT_PROGBITS, Flags, 0,
1099 GroupName, true, ElfSec.getUniqueID(),
1100 cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1101}
1102
1103MCSection *
1104MCObjectFileInfo::getBBAddrMapSection(const MCSection &TextSec) const {
1105 if (Ctx->getObjectFileType() != MCContext::IsELF)
1106 return nullptr;
1107
1108 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1109 unsigned Flags = ELF::SHF_LINK_ORDER;
1110 StringRef GroupName;
1111 if (const MCSymbol *Group = ElfSec.getGroup()) {
1112 GroupName = Group->getName();
1113 Flags |= ELF::SHF_GROUP;
1114 }
1115
1116 // Use the text section's begin symbol and unique ID to create a separate
1117 // .llvm_bb_addr_map section associated with every unique text section.
1118 return Ctx->getELFSection(".llvm_bb_addr_map", ELF::SHT_LLVM_BB_ADDR_MAP,
1119 Flags, 0, GroupName, true, ElfSec.getUniqueID(),
1120 cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1121}
1122
1123MCSection *
1124MCObjectFileInfo::getKCFITrapSection(const MCSection &TextSec) const {
1125 if (Ctx->getObjectFileType() != MCContext::IsELF)
1126 return nullptr;
1127
1128 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1129 unsigned Flags = ELF::SHF_LINK_ORDER | ELF::SHF_ALLOC;
1130 StringRef GroupName;
1131 if (const MCSymbol *Group = ElfSec.getGroup()) {
1132 GroupName = Group->getName();
1133 Flags |= ELF::SHF_GROUP;
1134 }
1135
1136 return Ctx->getELFSection(".kcfi_traps", ELF::SHT_PROGBITS, Flags, 0,
1137 GroupName,
1138 /*IsComdat=*/true, ElfSec.getUniqueID(),
1139 cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1140}
1141
1142MCSection *
1143MCObjectFileInfo::getPseudoProbeSection(const MCSection &TextSec) const {
1144 if (Ctx->getObjectFileType() != MCContext::IsELF)
1145 return PseudoProbeSection;
1146
1147 const auto &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1148 unsigned Flags = ELF::SHF_LINK_ORDER;
1149 StringRef GroupName;
1150 if (const MCSymbol *Group = ElfSec.getGroup()) {
1151 GroupName = Group->getName();
1152 Flags |= ELF::SHF_GROUP;
1153 }
1154
1155 return Ctx->getELFSection(PseudoProbeSection->getName(), ELF::SHT_PROGBITS,
1156 Flags, 0, GroupName, true, ElfSec.getUniqueID(),
1157 cast<MCSymbolELF>(TextSec.getBeginSymbol()));
1158}
1159
1160MCSection *
1161MCObjectFileInfo::getPseudoProbeDescSection(StringRef FuncName) const {
1162 if (Ctx->getObjectFileType() == MCContext::IsELF) {
1163 // Create a separate comdat group for each function's descriptor in order
1164 // for the linker to deduplicate. The duplication, must be from different
1165 // tranlation unit, can come from:
1166 // 1. Inline functions defined in header files;
1167 // 2. ThinLTO imported funcions;
1168 // 3. Weak-linkage definitions.
1169 // Use a concatenation of the section name and the function name as the
1170 // group name so that descriptor-only groups won't be folded with groups of
1171 // code.
1172 if (Ctx->getTargetTriple().supportsCOMDAT() && !FuncName.empty()) {
1173 auto *S = static_cast<MCSectionELF *>(PseudoProbeDescSection);
1174 auto Flags = S->getFlags() | ELF::SHF_GROUP;
1175 return Ctx->getELFSection(S->getName(), S->getType(), Flags,
1176 S->getEntrySize(),
1177 S->getName() + "_" + FuncName,
1178 /*IsComdat=*/true);
1179 }
1180 }
1181 return PseudoProbeDescSection;
1182}
1183
1184MCSection *MCObjectFileInfo::getLLVMStatsSection() const {
1185 return LLVMStatsSection;
1186}
1187
1188MCSection *MCObjectFileInfo::getPCSection(StringRef Name,
1189 const MCSection *TextSec) const {
1190 if (Ctx->getObjectFileType() != MCContext::IsELF)
1191 return nullptr;
1192
1193 // SHF_WRITE for relocations, and let user post-process data in-place.
1194 unsigned Flags = ELF::SHF_WRITE | ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER;
1195
1196 if (!TextSec)
1197 TextSec = getTextSection();
1198
1199 StringRef GroupName;
1200 const auto &ElfSec = static_cast<const MCSectionELF &>(*TextSec);
1201 if (const MCSymbol *Group = ElfSec.getGroup()) {
1202 GroupName = Group->getName();
1203 Flags |= ELF::SHF_GROUP;
1204 }
1205 return Ctx->getELFSection(Name, ELF::SHT_PROGBITS, Flags, 0, GroupName, true,
1206 ElfSec.getUniqueID(),
1207 cast<MCSymbolELF>(TextSec->getBeginSymbol()));
1208}
Name
std::string Name
Definition: ELFObjHandler.cpp:77
useCompactUnwind
static bool useCompactUnwind(const Triple &T)
Definition: MCObjectFileInfo.cpp:30
MCSectionGOFF.h
This file declares the MCSectionGOFF class, which contains all of the necessary machine code sections...
PIC
PassInstrumentationCallbacks PIC
Definition: PassBuilderBindings.cpp:57
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:449
llvm::MCContext
Context object for machine code objects.
Definition: MCContext.h:83
llvm::MCContext::getMachOSection
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:488
llvm::MCContext::getObjectFileType
Environment getObjectFileType() const
Definition: MCContext.h:395
llvm::MCContext::getWasmSection
MCSectionWasm * getWasmSection(const Twine &Section, SectionKind K, unsigned Flags=0)
Definition: MCContext.h:628
llvm::MCContext::getELFSection
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:551
llvm::MCContext::getXCOFFSection
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:805
llvm::MCContext::getSwift5ReflectionSegmentName
const StringRef & getSwift5ReflectionSegmentName() const
Definition: MCContext.h:397
llvm::MCContext::getCOFFSection
MCSectionCOFF * getCOFFSection(StringRef Section, unsigned Characteristics, StringRef COMDATSymName, int Selection, unsigned UniqueID=GenericSectionID)
Definition: MCContext.cpp:692
llvm::MCContext::getGOFFSection
MCSectionGOFF * getGOFFSection(StringRef Section, SectionKind Kind, MCSection *Parent, uint32_t Subsection=0)
Definition: MCContext.cpp:674
llvm::MCContext::getAsmInfo
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:412
llvm::MCContext::getDXContainerSection
MCSectionDXContainer * getDXContainerSection(StringRef Section, SectionKind K)
Get the section for the provided Section name.
Definition: MCContext.cpp:872
llvm::MCContext::getSPIRVSection
MCSectionSPIRV * getSPIRVSection()
Definition: MCContext.cpp:865
llvm::MCContext::emitDwarfUnwindInfo
EmitDwarfUnwindType emitDwarfUnwindInfo() const
Definition: MCContext.cpp:936
llvm::MCContext::GenericSectionID
@ GenericSectionID
Pass this value as the UniqueID during section creation to get the generic section with the given nam...
Definition: MCContext.h:534
llvm::MCContext::getTargetTriple
const Triple & getTargetTriple() const
Definition: MCContext.h:400
llvm::MCObjectFileInfo::NonLazySymbolPointerSection
MCSection * NonLazySymbolPointerSection
Definition: MCObjectFileInfo.h:218
llvm::MCObjectFileInfo::TLSBSSSection
MCSection * TLSBSSSection
Section directive for Thread Local uninitialized data.
Definition: MCObjectFileInfo.h:160
llvm::MCObjectFileInfo::DwarfDebugNamesSection
MCSection * DwarfDebugNamesSection
Accelerator table sections.
Definition: MCObjectFileInfo.h:103
llvm::MCObjectFileInfo::TLSThreadInitSection
const MCSection * TLSThreadInitSection
Section for thread local data initialization functions.
Definition: MCObjectFileInfo.h:203
llvm::MCObjectFileInfo::DwarfStrOffSection
MCSection * DwarfStrOffSection
The DWARF v5 string offset and address table sections.
Definition: MCObjectFileInfo.h:121
llvm::MCObjectFileInfo::DwarfARangesSection
MCSection * DwarfARangesSection
Definition: MCObjectFileInfo.h:91
llvm::MCObjectFileInfo::MergeableConst16Section
MCSection * MergeableConst16Section
Definition: MCObjectFileInfo.h:190
llvm::MCObjectFileInfo::COFFGlobalTypeHashesSection
MCSection * COFFGlobalTypeHashesSection
Definition: MCObjectFileInfo.h:146
llvm::MCObjectFileInfo::MergeableConst4Section
MCSection * MergeableConst4Section
Definition: MCObjectFileInfo.h:188
llvm::MCObjectFileInfo::DwarfMacinfoSection
MCSection * DwarfMacinfoSection
Definition: MCObjectFileInfo.h:93
llvm::MCObjectFileInfo::DwarfPubNamesSection
MCSection * DwarfPubNamesSection
Definition: MCObjectFileInfo.h:97
llvm::MCObjectFileInfo::DwarfGnuPubTypesSection
MCSection * DwarfGnuPubTypesSection
Section for newer gnu pubtypes.
Definition: MCObjectFileInfo.h:139
llvm::MCObjectFileInfo::getLLVMStatsSection
MCSection * getLLVMStatsSection() const
Definition: MCObjectFileInfo.cpp:1184
llvm::MCObjectFileInfo::TextSection
MCSection * TextSection
Section directive for standard text.
Definition: MCObjectFileInfo.h:53
llvm::MCObjectFileInfo::ConstDataCoalSection
MCSection * ConstDataCoalSection
Definition: MCObjectFileInfo.h:211
llvm::MCObjectFileInfo::ConstTextCoalSection
MCSection * ConstTextCoalSection
Definition: MCObjectFileInfo.h:208
llvm::MCObjectFileInfo::TLSDataSection
MCSection * TLSDataSection
Section directive for Thread Local data. ELF, MachO, COFF, and Wasm.
Definition: MCObjectFileInfo.h:155
llvm::MCObjectFileInfo::MergeableConst8Section
MCSection * MergeableConst8Section
Definition: MCObjectFileInfo.h:189
llvm::MCObjectFileInfo::ThreadLocalPointerSection
MCSection * ThreadLocalPointerSection
Definition: MCObjectFileInfo.h:219
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:69
llvm::MCObjectFileInfo::CompactUnwindSection
MCSection * CompactUnwindSection
If exception handling is supported by the target and the target can support a compact representation ...
Definition: MCObjectFileInfo.h:74
llvm::MCObjectFileInfo::COFFDebugSymbolsSection
MCSection * COFFDebugSymbolsSection
Definition: MCObjectFileInfo.h:144
llvm::MCObjectFileInfo::getPseudoProbeDescSection
MCSection * getPseudoProbeDescSection(StringRef FuncName) const
Definition: MCObjectFileInfo.cpp:1161
llvm::MCObjectFileInfo::DwarfLoclistsSection
MCSection * DwarfLoclistsSection
The DWARF v5 locations list section.
Definition: MCObjectFileInfo.h:126
llvm::MCObjectFileInfo::PseudoProbeSection
MCSection * PseudoProbeSection
Section for pseudo probe information used by AutoFDO.
Definition: MCObjectFileInfo.h:180
llvm::MCObjectFileInfo::FourByteConstantSection
MCSection * FourByteConstantSection
Definition: MCObjectFileInfo.h:214
llvm::MCObjectFileInfo::DwarfAccelNamesSection
MCSection * DwarfAccelNamesSection
Definition: MCObjectFileInfo.h:104
llvm::MCObjectFileInfo::getStackSizesSection
MCSection * getStackSizesSection(const MCSection &TextSec) const
Definition: MCObjectFileInfo.cpp:1085
llvm::MCObjectFileInfo::DwarfRnglistsSection
MCSection * DwarfRnglistsSection
The DWARF v5 range list section.
Definition: MCObjectFileInfo.h:124
llvm::MCObjectFileInfo::DwarfDebugInlineSection
const MCSection * DwarfDebugInlineSection
Definition: MCObjectFileInfo.h:88
llvm::MCObjectFileInfo::DwarfAbbrevDWOSection
MCSection * DwarfAbbrevDWOSection
Definition: MCObjectFileInfo.h:112
llvm::MCObjectFileInfo::getBBAddrMapSection
MCSection * getBBAddrMapSection(const MCSection &TextSec) const
Definition: MCObjectFileInfo.cpp:1104
llvm::MCObjectFileInfo::COFFDebugTypesSection
MCSection * COFFDebugTypesSection
Definition: MCObjectFileInfo.h:145
llvm::MCObjectFileInfo::LazySymbolPointerSection
MCSection * LazySymbolPointerSection
Definition: MCObjectFileInfo.h:217
llvm::MCObjectFileInfo::RemarksSection
MCSection * RemarksSection
Remarks section.
Definition: MCObjectFileInfo.h:169
llvm::MCObjectFileInfo::getPseudoProbeSection
MCSection * getPseudoProbeSection(const MCSection &TextSec) const
Definition: MCObjectFileInfo.cpp:1143
llvm::MCObjectFileInfo::PseudoProbeDescSection
MCSection * PseudoProbeDescSection
Definition: MCObjectFileInfo.h:181
llvm::MCObjectFileInfo::DwarfPubTypesSection
MCSection * DwarfPubTypesSection
Definition: MCObjectFileInfo.h:87
llvm::MCObjectFileInfo::DwarfRangesSection
MCSection * DwarfRangesSection
Definition: MCObjectFileInfo.h:92
llvm::MCObjectFileInfo::DwarfStrOffDWOSection
MCSection * DwarfStrOffDWOSection
Definition: MCObjectFileInfo.h:116
llvm::MCObjectFileInfo::TLSExtraDataSection
MCSection * TLSExtraDataSection
Extra TLS Variable Data section.
Definition: MCObjectFileInfo.h:152
llvm::MCObjectFileInfo::EHFrameSection
MCSection * EHFrameSection
EH frame section.
Definition: MCObjectFileInfo.h:174
llvm::MCObjectFileInfo::OmitDwarfIfHaveCompactUnwind
bool OmitDwarfIfHaveCompactUnwind
OmitDwarfIfHaveCompactUnwind - True if the target object file supports having some functions with com...
Definition: MCObjectFileInfo.h:41
llvm::MCObjectFileInfo::DrectveSection
MCSection * DrectveSection
COFF specific sections.
Definition: MCObjectFileInfo.h:223
llvm::MCObjectFileInfo::FaultMapSection
MCSection * FaultMapSection
FaultMap section.
Definition: MCObjectFileInfo.h:166
llvm::MCObjectFileInfo::getKCFITrapSection
MCSection * getKCFITrapSection(const MCSection &TextSec) const
Definition: MCObjectFileInfo.cpp:1124
llvm::MCObjectFileInfo::DwarfAccelObjCSection
MCSection * DwarfAccelObjCSection
Definition: MCObjectFileInfo.h:105
llvm::MCObjectFileInfo::TLSTLVSection
MCSection * TLSTLVSection
Section for thread local structure information.
Definition: MCObjectFileInfo.h:199
llvm::MCObjectFileInfo::DwarfSwiftASTSection
MCSection * DwarfSwiftASTSection
Definition: MCObjectFileInfo.h:142
llvm::MCObjectFileInfo::initMCObjectFileInfo
void initMCObjectFileInfo(MCContext &MCCtx, bool PIC, bool LargeCodeModel=false)
Definition: MCObjectFileInfo.cpp:1011
llvm::MCObjectFileInfo::DwarfRnglistsDWOSection
MCSection * DwarfRnglistsDWOSection
The DWARF v5 range and location list sections for fission.
Definition: MCObjectFileInfo.h:129
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:78
llvm::MCObjectFileInfo::MergeableConst32Section
MCSection * MergeableConst32Section
Definition: MCObjectFileInfo.h:191
llvm::MCObjectFileInfo::SixteenByteConstantSection
MCSection * SixteenByteConstantSection
Definition: MCObjectFileInfo.h:216
llvm::MCObjectFileInfo::getPCSection
MCSection * getPCSection(StringRef Name, const MCSection *TextSec) const
Definition: MCObjectFileInfo.cpp:1188
llvm::MCObjectFileInfo::DwarfLineStrSection
MCSection * DwarfLineStrSection
Definition: MCObjectFileInfo.h:85
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:36
llvm::MCObjectFileInfo::ReadOnlySection
MCSection * ReadOnlySection
Section that is readonly and can contain arbitrary initialized data.
Definition: MCObjectFileInfo.h:65
llvm::MCObjectFileInfo::DwarfAbbrevSection
MCSection * DwarfAbbrevSection
Definition: MCObjectFileInfo.h:82
llvm::MCObjectFileInfo::FDECFIEncoding
unsigned FDECFIEncoding
FDE CFI encoding.
Definition: MCObjectFileInfo.h:47
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:32
llvm::MCObjectFileInfo::DwarfLoclistsDWOSection
MCSection * DwarfLoclistsDWOSection
Definition: MCObjectFileInfo.h:130
llvm::MCObjectFileInfo::BSSSection
MCSection * BSSSection
Section that is default initialized to zero.
Definition: MCObjectFileInfo.h:59
llvm::MCObjectFileInfo::EightByteConstantSection
MCSection * EightByteConstantSection
Definition: MCObjectFileInfo.h:215
llvm::MCObjectFileInfo::StackSizesSection
MCSection * StackSizesSection
Section containing metadata on function stack sizes.
Definition: MCObjectFileInfo.h:177
llvm::MCObjectFileInfo::CompactUnwindDwarfEHFrameOnly
unsigned CompactUnwindDwarfEHFrameOnly
Compact unwind encoding indicating that we should emit only an EH frame.
Definition: MCObjectFileInfo.h:50
llvm::MCObjectFileInfo::getTextSection
MCSection * getTextSection() const
Definition: MCObjectFileInfo.h:271
llvm::MCObjectFileInfo::DwarfTypesDWOSection
MCSection * DwarfTypesDWOSection
Definition: MCObjectFileInfo.h:111
llvm::MCObjectFileInfo::DwarfGnuPubNamesSection
MCSection * DwarfGnuPubNamesSection
Section for newer gnu pubnames.
Definition: MCObjectFileInfo.h:137
llvm::MCObjectFileInfo::StackMapSection
MCSection * StackMapSection
StackMap section.
Definition: MCObjectFileInfo.h:163
llvm::MCObjectFileInfo::DwarfMacroDWOSection
MCSection * DwarfMacroDWOSection
Definition: MCObjectFileInfo.h:118
llvm::MCObjectFileInfo::DwarfMacinfoDWOSection
MCSection * DwarfMacinfoDWOSection
Definition: MCObjectFileInfo.h:117
llvm::MCObjectFileInfo::DwarfAccelNamespaceSection
MCSection * DwarfAccelNamespaceSection
Definition: MCObjectFileInfo.h:106
llvm::MCObjectFileInfo::DwarfAccelTypesSection
MCSection * DwarfAccelTypesSection
Definition: MCObjectFileInfo.h:107
llvm::MCObjectFileInfo::DataSection
MCSection * DataSection
Section directive for standard data.
Definition: MCObjectFileInfo.h:56
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:94
llvm::MCSectionELF::getGroup
const MCSymbolELF * getGroup() const
Definition: MCSectionELF.h:84
llvm::MCSectionXCOFF::setSymbolTableName
void setSymbolTableName(StringRef STN)
Definition: MCSectionXCOFF.h:123
llvm::MCSectionXCOFF::getQualNameSymbol
MCSymbolXCOFF * getQualNameSymbol() const
Definition: MCSectionXCOFF.h:116
llvm::MCSection
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:36
llvm::MCSection::setAlignment
void setAlignment(Align Value)
Definition: MCSection.h:147
llvm::MCSection::getName
StringRef getName() const
Definition: MCSection.h:130
llvm::MCSection::getBeginSymbol
MCSymbol * getBeginSymbol()
Definition: MCSection.h:135
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:41
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:51
llvm::StringRef::empty
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:147
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
llvm::Triple::isPS4
bool isPS4() const
Tests whether the target is the PS4 platform.
Definition: Triple.h:768
llvm::Triple::getObjectFormat
ObjectFormatType getObjectFormat() const
Get the object format for this triple.
Definition: Triple.h:409
llvm::Triple::supportsCOMDAT
bool supportsCOMDAT() const
Tests whether the target supports comdat.
Definition: Triple.h:1095
llvm::Triple::aarch64_be
@ aarch64_be
Definition: Triple.h:52
llvm::Triple::mips64el
@ mips64el
Definition: Triple.h:67
llvm::Triple::aarch64_32
@ aarch64_32
Definition: Triple.h:53
llvm::Triple::DXContainer
@ DXContainer
Definition: Triple.h:311
llvm::Triple::UnknownObjectFormat
@ UnknownObjectFormat
Definition: Triple.h:308
uint64_t
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::COFF::SectionCharacteristics
SectionCharacteristics
Definition: COFF.h:297
llvm::COFF::IMAGE_SCN_LNK_REMOVE
@ IMAGE_SCN_LNK_REMOVE
Definition: COFF.h:307
llvm::COFF::IMAGE_SCN_CNT_CODE
@ IMAGE_SCN_CNT_CODE
Definition: COFF.h:302
llvm::COFF::IMAGE_SCN_MEM_READ
@ IMAGE_SCN_MEM_READ
Definition: COFF.h:335
llvm::COFF::IMAGE_SCN_MEM_EXECUTE
@ IMAGE_SCN_MEM_EXECUTE
Definition: COFF.h:334
llvm::COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA
@ IMAGE_SCN_CNT_UNINITIALIZED_DATA
Definition: COFF.h:304
llvm::COFF::IMAGE_SCN_MEM_DISCARDABLE
@ IMAGE_SCN_MEM_DISCARDABLE
Definition: COFF.h:330
llvm::COFF::IMAGE_SCN_LNK_INFO
@ IMAGE_SCN_LNK_INFO
Definition: COFF.h:306
llvm::COFF::IMAGE_SCN_MEM_16BIT
@ IMAGE_SCN_MEM_16BIT
Definition: COFF.h:311
llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA
@ IMAGE_SCN_CNT_INITIALIZED_DATA
Definition: COFF.h:303
llvm::COFF::IMAGE_SCN_MEM_WRITE
@ IMAGE_SCN_MEM_WRITE
Definition: COFF.h:336
llvm::ELF::SHT_PROGBITS
@ SHT_PROGBITS
Definition: ELF.h:1098
llvm::ELF::SHT_NOBITS
@ SHT_NOBITS
Definition: ELF.h:1105
llvm::ELF::SHT_MIPS_DWARF
@ SHT_MIPS_DWARF
Definition: ELF.h:1174
llvm::ELF::SHT_LLVM_BB_ADDR_MAP
@ SHT_LLVM_BB_ADDR_MAP
Definition: ELF.h:1138
llvm::ELF::SHT_X86_64_UNWIND
@ SHT_X86_64_UNWIND
Definition: ELF.h:1170
llvm::ELF::SHF_MERGE
@ SHF_MERGE
Definition: ELF.h:1202
llvm::ELF::SHF_STRINGS
@ SHF_STRINGS
Definition: ELF.h:1205
llvm::ELF::SHF_EXCLUDE
@ SHF_EXCLUDE
Definition: ELF.h:1230
llvm::ELF::SHF_ALLOC
@ SHF_ALLOC
Definition: ELF.h:1196
llvm::ELF::SHF_LINK_ORDER
@ SHF_LINK_ORDER
Definition: ELF.h:1211
llvm::ELF::SHF_GROUP
@ SHF_GROUP
Definition: ELF.h:1218
llvm::ELF::SHF_WRITE
@ SHF_WRITE
Definition: ELF.h:1193
llvm::ELF::SHF_TLS
@ SHF_TLS
Definition: ELF.h:1221
llvm::ELF::SHF_EXECINSTR
@ SHF_EXECINSTR
Definition: ELF.h:1199
llvm::GOFF::SK_PPA1
@ SK_PPA1
Definition: GOFF.h:169
llvm::GOFF::SK_PPA2
@ SK_PPA2
Definition: GOFF.h:170
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:159
llvm::XCOFF::SSUBTYP_DWFRAME
@ SSUBTYP_DWFRAME
DWARF frame section.
Definition: XCOFF.h:164
llvm::XCOFF::SSUBTYP_DWABREV
@ SSUBTYP_DWABREV
DWARF abbrev section.
Definition: XCOFF.h:160
llvm::XCOFF::SSUBTYP_DWINFO
@ SSUBTYP_DWINFO
DWARF info section.
Definition: XCOFF.h:155
llvm::XCOFF::SSUBTYP_DWRNGES
@ SSUBTYP_DWRNGES
DWARF ranges section.
Definition: XCOFF.h:162
llvm::XCOFF::SSUBTYP_DWLOC
@ SSUBTYP_DWLOC
DWARF loc section.
Definition: XCOFF.h:163
llvm::XCOFF::SSUBTYP_DWMAC
@ SSUBTYP_DWMAC
DWARF macinfo section.
Definition: XCOFF.h:165
llvm::XCOFF::SSUBTYP_DWPBNMS
@ SSUBTYP_DWPBNMS
DWARF pubnames section.
Definition: XCOFF.h:157
llvm::XCOFF::SSUBTYP_DWPBTYP
@ SSUBTYP_DWPBTYP
DWARF pubtypes section.
Definition: XCOFF.h:158
llvm::XCOFF::SSUBTYP_DWLINE
@ SSUBTYP_DWLINE
DWARF line section.
Definition: XCOFF.h:156
llvm::XCOFF::SSUBTYP_DWSTR
@ SSUBTYP_DWSTR
DWARF str section.
Definition: XCOFF.h:161
llvm::XCOFF::XMC_TC0
@ XMC_TC0
TOC Anchor for TOC Addressability.
Definition: XCOFF.h:118
llvm::XCOFF::XMC_RW
@ XMC_RW
Read Write Data.
Definition: XCOFF.h:117
llvm::XCOFF::XMC_TL
@ XMC_TL
Initialized thread-local variable.
Definition: XCOFF.h:126
llvm::XCOFF::XMC_RO
@ XMC_RO
Read Only Constant.
Definition: XCOFF.h:106
llvm::XCOFF::XMC_PR
@ XMC_PR
Program Code.
Definition: XCOFF.h:105
llvm::XCOFF::XTY_SD
@ XTY_SD
Csect definition for initialized storage.
Definition: XCOFF.h:242
llvm::dwarf::DW_EH_PE_pcrel
@ DW_EH_PE_pcrel
Definition: Dwarf.h:858
llvm::dwarf::DW_EH_PE_sdata4
@ DW_EH_PE_sdata4
Definition: Dwarf.h:855
llvm::dwarf::DW_EH_PE_sdata8
@ DW_EH_PE_sdata8
Definition: Dwarf.h:856
llvm::dwarf::DW_EH_PE_absptr
@ DW_EH_PE_absptr
Definition: Dwarf.h:847
llvm::wasm::WASM_SEG_FLAG_STRINGS
@ WASM_SEG_FLAG_STRINGS
Definition: Wasm.h:225
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::report_fatal_error
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
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 Sun Mar 23 2025 03:41:24 for LLVM by doxygen 1.9.6