LLVM 23.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/GOFF.h"
14#include "llvm/BinaryFormat/SFrame.h"
15#include "llvm/BinaryFormat/Wasm.h"
16#include "llvm/MC/MCAsmInfo.h"
17#include "llvm/MC/MCContext.h"
18#include "llvm/MC/MCGOFFAttributes.h"
19#include "llvm/MC/MCSection.h"
20#include "llvm/MC/MCSectionCOFF.h"
21#include "llvm/MC/MCSectionDXContainer.h"
22#include "llvm/MC/MCSectionELF.h"
23#include "llvm/MC/MCSectionGOFF.h"
24#include "llvm/MC/MCSectionMachO.h"
25#include "llvm/MC/MCSectionSPIRV.h"
26#include "llvm/MC/MCSectionWasm.h"
27#include "llvm/MC/MCSectionXCOFF.h"
28#include "llvm/MC/MCSymbolGOFF.h"
29#include "llvm/MC/SectionKind.h"
30#include "llvm/TargetParser/Triple.h"
31
32using namespace llvm;
33
34static bool useCompactUnwind(const Triple &T) {
35 // Only on darwin.
36 if (!T.isOSDarwin())
37 return false;
38
39 // aarch64 always has it.
40 if (T.getArch() == Triple::aarch64 || T.getArch() == Triple::aarch64_32)
41 return true;
42
43 // armv7k always has it.
44 if (T.isWatchABI())
45 return true;
46
47 // Use it on newer version of OS X.
48 if (T.isMacOSX() && !T.isMacOSXVersionLT(10, 6))
49 return true;
50
51 // And the iOS simulator.
52 if (T.isiOS() && T.isX86())
53 return true;
54
55 // The rest of the simulators always have it.
56 if (T.isSimulatorEnvironment())
57 return true;
58
59 // XROS always has it.
60 if (T.isXROS())
61 return true;
62
63 return false;
64}
65
66void MCObjectFileInfo::initMachOMCObjectFileInfo(const Triple &T) {
67 EHFrameSection = Ctx->getMachOSection(
68 "__TEXT", "__eh_frame",
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 PseudoProbeSection =
325 Ctx->getMachOSection("__PSEUDO_PROBE", "__probes",
326 MachO::S_ATTR_DEBUG | MachO::S_ATTR_NO_DEAD_STRIP,
327 SectionKind::getMetadata());
328 PseudoProbeDescSection =
329 Ctx->getMachOSection("__PSEUDO_PROBE", "__probe_descs",
330 MachO::S_ATTR_DEBUG | MachO::S_ATTR_NO_DEAD_STRIP,
331 SectionKind::getMetadata());
332
333 // The architecture of dsymutil makes it very difficult to copy the Swift
334 // reflection metadata sections into the __TEXT segment, so dsymutil creates
335 // these sections in the __DWARF segment instead.
336 if (!Ctx->getSwift5ReflectionSegmentName().empty()) {
337#define HANDLE_SWIFT_SECTION(KIND, MACHO, ELF, COFF) \
338 Swift5ReflectionSections \
339 [llvm::binaryformat::Swift5ReflectionSectionKind::KIND] = \
340 Ctx->getMachOSection(Ctx->getSwift5ReflectionSegmentName().data(), \
341 MACHO, 0, SectionKind::getMetadata());
342#include "llvm/BinaryFormat/Swift.def"
343 }
344
345 TLSExtraDataSection = TLSTLVSection;
346}
347
348void MCObjectFileInfo::initELFMCObjectFileInfo(const Triple &T, bool Large) {
349 switch (T.getArch()) {
350 case Triple::mips:
351 case Triple::mipsel:
352 case Triple::mips64:
353 case Triple::mips64el:
354 // We cannot use DW_EH_PE_sdata8 for the large PositionIndependent case
355 // since there is no R_MIPS_PC64 relocation (only a 32-bit version).
356 // In fact DW_EH_PE_sdata4 is enough for us now, and GNU ld doesn't
357 // support pcrel|sdata8 well. Let's use sdata4 for now.
358 if (PositionIndependent)
359 FDECFIEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
360 else
361 FDECFIEncoding = Ctx->getAsmInfo().getCodePointerSize() == 4
362 ? dwarf::DW_EH_PE_sdata4
363 : dwarf::DW_EH_PE_sdata8;
364 break;
365 case Triple::ppc64:
366 case Triple::ppc64le:
367 case Triple::aarch64:
368 case Triple::aarch64_be:
369 case Triple::x86_64:
370 FDECFIEncoding = dwarf::DW_EH_PE_pcrel |
371 (Large ? dwarf::DW_EH_PE_sdata8 : dwarf::DW_EH_PE_sdata4);
372 break;
373 case Triple::bpfel:
374 case Triple::bpfeb:
375 FDECFIEncoding = dwarf::DW_EH_PE_sdata8;
376 break;
377 case Triple::hexagon:
378 FDECFIEncoding =
379 PositionIndependent ? dwarf::DW_EH_PE_pcrel : dwarf::DW_EH_PE_absptr;
380 break;
381 case Triple::xtensa:
382 FDECFIEncoding = dwarf::DW_EH_PE_sdata4;
383 break;
384 default:
385 FDECFIEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
386 break;
387 }
388
389 unsigned EHSectionType = T.getArch() == Triple::x86_64
390 ? ELF::SHT_X86_64_UNWIND
391 : ELF::SHT_PROGBITS;
392 switch (T.getArch()) {
393 case Triple::x86_64:
394 SFrameABIArch = sframe::ABI::AMD64EndianLittle;
395 break;
396 case Triple::aarch64:
397 SFrameABIArch = sframe::ABI::AArch64EndianLittle;
398 break;
399 case Triple::aarch64_be:
400 SFrameABIArch = sframe::ABI::AArch64EndianBig;
401 break;
402 default:
403 break;
404 }
405
406 // Solaris requires different flags for .eh_frame to seemingly every other
407 // platform.
408 unsigned EHSectionFlags = ELF::SHF_ALLOC;
409 if (T.isOSSolaris() && T.getArch() != Triple::x86_64)
410 EHSectionFlags |= ELF::SHF_WRITE;
411
412 // ELF
413 BSSSection = Ctx->getELFSection(".bss", ELF::SHT_NOBITS,
414 ELF::SHF_WRITE | ELF::SHF_ALLOC);
415
416 TextSection = Ctx->getELFSection(".text", ELF::SHT_PROGBITS,
417 ELF::SHF_EXECINSTR | ELF::SHF_ALLOC);
418
419 DataSection = Ctx->getELFSection(".data", ELF::SHT_PROGBITS,
420 ELF::SHF_WRITE | ELF::SHF_ALLOC);
421
422 ReadOnlySection =
423 Ctx->getELFSection(".rodata", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
424
425 TLSDataSection =
426 Ctx->getELFSection(".tdata", ELF::SHT_PROGBITS,
427 ELF::SHF_ALLOC | ELF::SHF_TLS | ELF::SHF_WRITE);
428
429 TLSBSSSection = Ctx->getELFSection(
430 ".tbss", ELF::SHT_NOBITS, ELF::SHF_ALLOC | ELF::SHF_TLS | ELF::SHF_WRITE);
431
432 DataRelROSection = Ctx->getELFSection(".data.rel.ro", ELF::SHT_PROGBITS,
433 ELF::SHF_ALLOC | ELF::SHF_WRITE);
434
435 unsigned MergeableCstFlags = ELF::SHF_ALLOC | ELF::SHF_MERGE;
436 StringRef CstPrefix = ".rodata";
437 if (Large && T.getArch() == Triple::x86_64) {
438 MergeableCstFlags |= ELF::SHF_X86_64_LARGE;
439 CstPrefix = ".lrodata";
440 }
441
442 MergeableConst4Section = Ctx->getELFSection(
443 (CstPrefix + ".cst4").str(), ELF::SHT_PROGBITS, MergeableCstFlags, 4);
444
445 MergeableConst8Section = Ctx->getELFSection(
446 (CstPrefix + ".cst8").str(), ELF::SHT_PROGBITS, MergeableCstFlags, 8);
447
448 MergeableConst16Section = Ctx->getELFSection(
449 (CstPrefix + ".cst16").str(), ELF::SHT_PROGBITS, MergeableCstFlags, 16);
450
451 MergeableConst32Section = Ctx->getELFSection(
452 (CstPrefix + ".cst32").str(), ELF::SHT_PROGBITS, MergeableCstFlags, 32);
453
454 // Exception Handling Sections.
455
456 // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
457 // it contains relocatable pointers. In PIC mode, this is probably a big
458 // runtime hit for C++ apps. Either the contents of the LSDA need to be
459 // adjusted or this should be a data section.
460 LSDASection = Ctx->getELFSection(".gcc_except_table", ELF::SHT_PROGBITS,
461 ELF::SHF_ALLOC);
462
463 COFFDebugSymbolsSection = nullptr;
464 COFFDebugTypesSection = nullptr;
465
466 unsigned DebugSecType = ELF::SHT_PROGBITS;
467
468 // MIPS .debug_* sections should have SHT_MIPS_DWARF section type
469 // to distinguish among sections contain DWARF and ECOFF debug formats.
470 // Sections with ECOFF debug format are obsoleted and marked by SHT_PROGBITS.
471 if (T.isMIPS())
472 DebugSecType = ELF::SHT_MIPS_DWARF;
473
474 // Debug Info Sections.
475 DwarfAbbrevSection =
476 Ctx->getELFSection(".debug_abbrev", DebugSecType, 0);
477 DwarfInfoSection = Ctx->getELFSection(".debug_info", DebugSecType, 0);
478 DwarfLineSection = Ctx->getELFSection(".debug_line", DebugSecType, 0);
479 DwarfLineStrSection =
480 Ctx->getELFSection(".debug_line_str", DebugSecType,
481 ELF::SHF_MERGE | ELF::SHF_STRINGS, 1);
482 DwarfFrameSection = Ctx->getELFSection(".debug_frame", DebugSecType, 0);
483 DwarfPubNamesSection =
484 Ctx->getELFSection(".debug_pubnames", DebugSecType, 0);
485 DwarfPubTypesSection =
486 Ctx->getELFSection(".debug_pubtypes", DebugSecType, 0);
487 DwarfGnuPubNamesSection =
488 Ctx->getELFSection(".debug_gnu_pubnames", DebugSecType, 0);
489 DwarfGnuPubTypesSection =
490 Ctx->getELFSection(".debug_gnu_pubtypes", DebugSecType, 0);
491 DwarfStrSection =
492 Ctx->getELFSection(".debug_str", DebugSecType,
493 ELF::SHF_MERGE | ELF::SHF_STRINGS, 1);
494 DwarfLocSection = Ctx->getELFSection(".debug_loc", DebugSecType, 0);
495 DwarfARangesSection =
496 Ctx->getELFSection(".debug_aranges", DebugSecType, 0);
497 DwarfRangesSection =
498 Ctx->getELFSection(".debug_ranges", DebugSecType, 0);
499 DwarfMacinfoSection =
500 Ctx->getELFSection(".debug_macinfo", DebugSecType, 0);
501 DwarfMacroSection = Ctx->getELFSection(".debug_macro", DebugSecType, 0);
502
503 // DWARF5 Experimental Debug Info
504
505 // Accelerator Tables
506 DwarfDebugNamesSection =
507 Ctx->getELFSection(".debug_names", ELF::SHT_PROGBITS, 0);
508 DwarfAccelNamesSection =
509 Ctx->getELFSection(".apple_names", ELF::SHT_PROGBITS, 0);
510 DwarfAccelObjCSection =
511 Ctx->getELFSection(".apple_objc", ELF::SHT_PROGBITS, 0);
512 DwarfAccelNamespaceSection =
513 Ctx->getELFSection(".apple_namespaces", ELF::SHT_PROGBITS, 0);
514 DwarfAccelTypesSection =
515 Ctx->getELFSection(".apple_types", ELF::SHT_PROGBITS, 0);
516
517 // String Offset and Address Sections
518 DwarfStrOffSection =
519 Ctx->getELFSection(".debug_str_offsets", DebugSecType, 0);
520 DwarfAddrSection = Ctx->getELFSection(".debug_addr", DebugSecType, 0);
521 DwarfRnglistsSection = Ctx->getELFSection(".debug_rnglists", DebugSecType, 0);
522 DwarfLoclistsSection = Ctx->getELFSection(".debug_loclists", DebugSecType, 0);
523
524 // Fission Sections
525 DwarfInfoDWOSection =
526 Ctx->getELFSection(".debug_info.dwo", DebugSecType, ELF::SHF_EXCLUDE);
527 DwarfTypesDWOSection =
528 Ctx->getELFSection(".debug_types.dwo", DebugSecType, ELF::SHF_EXCLUDE);
529 DwarfAbbrevDWOSection =
530 Ctx->getELFSection(".debug_abbrev.dwo", DebugSecType, ELF::SHF_EXCLUDE);
531 DwarfStrDWOSection = Ctx->getELFSection(
532 ".debug_str.dwo", DebugSecType,
533 ELF::SHF_MERGE | ELF::SHF_STRINGS | ELF::SHF_EXCLUDE, 1);
534 DwarfLineDWOSection =
535 Ctx->getELFSection(".debug_line.dwo", DebugSecType, ELF::SHF_EXCLUDE);
536 DwarfLocDWOSection =
537 Ctx->getELFSection(".debug_loc.dwo", DebugSecType, ELF::SHF_EXCLUDE);
538 DwarfStrOffDWOSection = Ctx->getELFSection(".debug_str_offsets.dwo",
539 DebugSecType, ELF::SHF_EXCLUDE);
540 DwarfRnglistsDWOSection =
541 Ctx->getELFSection(".debug_rnglists.dwo", DebugSecType, ELF::SHF_EXCLUDE);
542 DwarfMacinfoDWOSection =
543 Ctx->getELFSection(".debug_macinfo.dwo", DebugSecType, ELF::SHF_EXCLUDE);
544 DwarfMacroDWOSection =
545 Ctx->getELFSection(".debug_macro.dwo", DebugSecType, ELF::SHF_EXCLUDE);
546
547 DwarfLoclistsDWOSection =
548 Ctx->getELFSection(".debug_loclists.dwo", DebugSecType, ELF::SHF_EXCLUDE);
549
550 // DWP Sections
551 DwarfCUIndexSection =
552 Ctx->getELFSection(".debug_cu_index", DebugSecType, 0);
553 DwarfTUIndexSection =
554 Ctx->getELFSection(".debug_tu_index", DebugSecType, 0);
555
556 StackMapSection =
557 Ctx->getELFSection(".llvm_stackmaps", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
558
559 FaultMapSection =
560 Ctx->getELFSection(".llvm_faultmaps", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
561
562 EHFrameSection =
563 Ctx->getELFSection(".eh_frame", EHSectionType, EHSectionFlags);
564
565 SFrameSection =
566 Ctx->getELFSection(".sframe", ELF::SHT_GNU_SFRAME, ELF::SHF_ALLOC);
567
568 CallGraphSection =
569 Ctx->getELFSection(".llvm.callgraph", ELF::SHT_LLVM_CALL_GRAPH, 0);
570
571 StackSizesSection = Ctx->getELFSection(".stack_sizes", ELF::SHT_PROGBITS, 0);
572
573 PseudoProbeSection = Ctx->getELFSection(".pseudo_probe", DebugSecType, 0);
574 PseudoProbeDescSection =
575 Ctx->getELFSection(".pseudo_probe_desc", DebugSecType, 0);
576
577 LLVMStatsSection = Ctx->getELFSection(".llvm_stats", ELF::SHT_PROGBITS, 0);
578}
579
580void MCObjectFileInfo::initGOFFMCObjectFileInfo(const Triple &T) {
581 MCSectionGOFF *RootSDSection = Ctx->getGOFFSection(
582 SectionKind::getMetadata(), "#C",
583 GOFF::SDAttr{GOFF::ESD_TA_Rent, GOFF::ESD_BSC_Section});
584
585 MCSectionGOFF *ADAEDSection = Ctx->getGOFFSection(
586 SectionKind::getMetadata(), GOFF::CLASS_WSA,
587 GOFF::EDAttr{false, GOFF::ESD_RMODE_64, GOFF::ESD_NS_Parts,
588 GOFF::ESD_TS_ByteOriented, GOFF::ESD_BA_Merge,
589 GOFF::ESD_LB_Deferred, GOFF::ESD_RQ_1,
590 GOFF::ESD_ALIGN_Quadword, 0},
591 RootSDSection);
592 ADASection = Ctx->getGOFFSection(SectionKind::getData(), "#S",
593 GOFF::PRAttr{false, GOFF::ESD_EXE_DATA,
594 GOFF::ESD_LT_XPLink,
595 GOFF::ESD_BSC_Section, 0},
596 ADAEDSection);
597
598 TextSection = Ctx->getGOFFSection(
599 SectionKind::getText(), GOFF::CLASS_CODE,
600 GOFF::EDAttr{true, GOFF::ESD_RMODE_64, GOFF::ESD_NS_NormalName,
601 GOFF::ESD_TS_ByteOriented, GOFF::ESD_BA_Concatenate,
602 GOFF::ESD_LB_Initial, GOFF::ESD_RQ_0,
603 GOFF::ESD_ALIGN_Doubleword, 0},
604 RootSDSection);
605
606 MCSectionGOFF *PPA2ListEDSection = Ctx->getGOFFSection(
607 SectionKind::getMetadata(), GOFF::CLASS_PPA2,
608 GOFF::EDAttr{true, GOFF::ESD_RMODE_64, GOFF::ESD_NS_Parts,
609 GOFF::ESD_TS_ByteOriented, GOFF::ESD_BA_Merge,
610 GOFF::ESD_LB_Initial, GOFF::ESD_RQ_0,
611 GOFF::ESD_ALIGN_Doubleword, 0},
612 RootSDSection);
613 PPA2ListSection = Ctx->getGOFFSection(SectionKind::getData(), ".&ppa2",
614 GOFF::PRAttr{true, GOFF::ESD_EXE_DATA,
615 GOFF::ESD_LT_OS,
616 GOFF::ESD_BSC_Section, 0},
617 PPA2ListEDSection);
618
619 IDRLSection = Ctx->getGOFFSection(
620 SectionKind::getData(), "B_IDRL",
621 GOFF::EDAttr{true, GOFF::ESD_RMODE_64, GOFF::ESD_NS_NormalName,
622 GOFF::ESD_TS_Structured, GOFF::ESD_BA_Concatenate,
623 GOFF::ESD_LB_NoLoad, GOFF::ESD_RQ_0,
624 GOFF::ESD_ALIGN_Doubleword, 0},
625 RootSDSection);
626
627 // Debug Info Sections. The ED name is the same used by the XL compiler.
628 auto InitDebugSection = [this,
629 RootSDSection](StringRef EDName,
630 StringRef LDName) -> MCSectionGOFF * {
631 MCSectionGOFF *ED = Ctx->getGOFFSection(
632 SectionKind::getMetadata(), EDName,
633 GOFF::EDAttr{false, GOFF::ESD_RMODE_64, GOFF::ESD_NS_Parts,
634 GOFF::ESD_TS_ByteOriented, GOFF::ESD_BA_Concatenate,
635 GOFF::ESD_LB_NoLoad, GOFF::ESD_RQ_0,
636 GOFF::ESD_ALIGN_Doubleword, 0},
637 RootSDSection);
638 // At least for llc, this function is called twice! (See function
639 // compileModule() in llc.cpp). Since the context is not cleared, the
640 // already allocated section is returned above. We only add the begin symbol
641 // if it is not yet set to avoid an assertion.
642 MCSymbolGOFF *LD = static_cast<MCSymbolGOFF *>(ED->getBeginSymbol());
643 if (!LD) {
644 LD = static_cast<MCSymbolGOFF *>(getContext().getOrCreateSymbol(LDName));
645 LD->setCodeData(GOFF::ESD_EXE_DATA);
646 LD->setWeak(false);
647 LD->setLinkage(GOFF::ESD_LT_XPLink);
648 LD->setExternal(false);
649 ED->setBeginSymbol(LD);
650 } else
651 assert(LD->getName() == LDName && "Wrong label name");
652 return ED;
653 };
654 DwarfAbbrevSection = InitDebugSection("D_ABREV", ".debug_abbrev");
655 DwarfInfoSection = InitDebugSection("D_INFO", ".debug_info");
656 DwarfLineSection = InitDebugSection("D_LINE", ".debug_line");
657 DwarfFrameSection = InitDebugSection("D_FRAME", ".debug_frame");
658 DwarfPubNamesSection = InitDebugSection("D_PBNMS", ".debug_pubnames");
659 DwarfPubTypesSection = InitDebugSection("D_PTYPES", ".debug_pubtypes");
660 DwarfStrSection = InitDebugSection("D_STR", ".debug_str");
661 DwarfLocSection = InitDebugSection("D_LOC", ".debug_loc");
662 DwarfARangesSection = InitDebugSection("D_ARNGE", ".debug_aranges");
663 DwarfRangesSection = InitDebugSection("D_RNGES", ".debug_ranges");
664 DwarfMacinfoSection = InitDebugSection("D_MACIN", ".debug_macinfo");
665
666 // DWARF 5 sections.
667 DwarfDebugNamesSection = InitDebugSection("D_NAMES", ".debug_names");
668 DwarfStrOffSection = InitDebugSection("D_STROFFS", ".debug_str_offsets");
669 DwarfAddrSection = InitDebugSection("D_ADDR", ".debug_addr");
670 DwarfRnglistsSection = InitDebugSection("D_RNGLISTS", ".debug_rnglists");
671 DwarfLoclistsSection = InitDebugSection("D_LOCLISTS", ".debug_loclists");
672 DwarfLineStrSection = InitDebugSection("D_LINESTR", ".debug_line_str");
673
674 // Special GNU sections.
675 DwarfGnuPubNamesSection = InitDebugSection("D_GPBNMS", ".debug_gnu_pubnames");
676 DwarfGnuPubTypesSection =
677 InitDebugSection("D_GPTYPES", ".debug_gnu_pubtypes");
678
679 // Accelerator Tables.
680 DwarfAccelNamesSection = InitDebugSection("D_APPLNMS", ".apple_names");
681 DwarfAccelNamespaceSection =
682 InitDebugSection("D_APPLNMSP", ".apple_namespaces");
683 DwarfAccelTypesSection = InitDebugSection("D_APPLTYPS", ".apple_types");
684 DwarfAccelObjCSection = InitDebugSection("D_APPLOBJC", ".apple_objc");
685}
686
687void MCObjectFileInfo::initCOFFMCObjectFileInfo(const Triple &T) {
688 EHFrameSection =
689 Ctx->getCOFFSection(".eh_frame", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
690 COFF::IMAGE_SCN_MEM_READ);
691
692 // Set the `IMAGE_SCN_MEM_16BIT` flag when compiling for thumb mode. This is
693 // used to indicate to the linker that the text segment contains thumb instructions
694 // and to set the ISA selection bit for calls accordingly.
695 const bool IsThumb = T.getArch() == Triple::thumb;
696
697 // COFF
698 BSSSection = Ctx->getCOFFSection(
699 ".bss", COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
700 COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE);
701 TextSection = Ctx->getCOFFSection(
702 ".text",
703 (IsThumb ? COFF::IMAGE_SCN_MEM_16BIT : (COFF::SectionCharacteristics)0) |
704 COFF::IMAGE_SCN_CNT_CODE | COFF::IMAGE_SCN_MEM_EXECUTE |
705 COFF::IMAGE_SCN_MEM_READ);
706 DataSection = Ctx->getCOFFSection(
707 ".data", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ |
708 COFF::IMAGE_SCN_MEM_WRITE);
709 ReadOnlySection =
710 Ctx->getCOFFSection(".rdata", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
711 COFF::IMAGE_SCN_MEM_READ);
712
713 if (T.getArch() == Triple::x86_64 || T.getArch() == Triple::aarch64 ||
714 T.getArch() == Triple::arm || T.getArch() == Triple::thumb) {
715 // On Windows with SEH, the LSDA is emitted into the .xdata section
716 LSDASection = nullptr;
717 } else {
718 LSDASection = Ctx->getCOFFSection(".gcc_except_table",
719 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
720 COFF::IMAGE_SCN_MEM_READ);
721 }
722
723 if (T.getArch() == Triple::aarch64) {
724 ImportCallSection =
725 Ctx->getCOFFSection(".impcall", COFF::IMAGE_SCN_LNK_INFO);
726 } else if (T.getArch() == Triple::x86_64) {
727 // Import Call Optimization on x64 leverages the same metadata as the
728 // retpoline mitigation, hence the unusual section name.
729 ImportCallSection =
730 Ctx->getCOFFSection(".retplne", COFF::IMAGE_SCN_LNK_INFO);
731 }
732
733 // Debug info.
734 COFFDebugSymbolsSection =
735 Ctx->getCOFFSection(".debug$S", (COFF::IMAGE_SCN_MEM_DISCARDABLE |
736 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
737 COFF::IMAGE_SCN_MEM_READ));
738 COFFDebugTypesSection =
739 Ctx->getCOFFSection(".debug$T", (COFF::IMAGE_SCN_MEM_DISCARDABLE |
740 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
741 COFF::IMAGE_SCN_MEM_READ));
742 COFFGlobalTypeHashesSection =
743 Ctx->getCOFFSection(".debug$H", (COFF::IMAGE_SCN_MEM_DISCARDABLE |
744 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
745 COFF::IMAGE_SCN_MEM_READ));
746
747 DwarfAbbrevSection = Ctx->getCOFFSection(
748 ".debug_abbrev", COFF::IMAGE_SCN_MEM_DISCARDABLE |
749 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
750 COFF::IMAGE_SCN_MEM_READ);
751 DwarfInfoSection = Ctx->getCOFFSection(
752 ".debug_info", COFF::IMAGE_SCN_MEM_DISCARDABLE |
753 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
754 COFF::IMAGE_SCN_MEM_READ);
755 DwarfLineSection = Ctx->getCOFFSection(
756 ".debug_line", COFF::IMAGE_SCN_MEM_DISCARDABLE |
757 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
758 COFF::IMAGE_SCN_MEM_READ);
759 DwarfLineStrSection = Ctx->getCOFFSection(
760 ".debug_line_str", COFF::IMAGE_SCN_MEM_DISCARDABLE |
761 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
762 COFF::IMAGE_SCN_MEM_READ);
763 DwarfFrameSection = Ctx->getCOFFSection(
764 ".debug_frame", COFF::IMAGE_SCN_MEM_DISCARDABLE |
765 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
766 COFF::IMAGE_SCN_MEM_READ);
767 DwarfPubNamesSection = Ctx->getCOFFSection(
768 ".debug_pubnames", COFF::IMAGE_SCN_MEM_DISCARDABLE |
769 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
770 COFF::IMAGE_SCN_MEM_READ);
771 DwarfPubTypesSection = Ctx->getCOFFSection(
772 ".debug_pubtypes", COFF::IMAGE_SCN_MEM_DISCARDABLE |
773 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
774 COFF::IMAGE_SCN_MEM_READ);
775 DwarfGnuPubNamesSection = Ctx->getCOFFSection(
776 ".debug_gnu_pubnames", COFF::IMAGE_SCN_MEM_DISCARDABLE |
777 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
778 COFF::IMAGE_SCN_MEM_READ);
779 DwarfGnuPubTypesSection = Ctx->getCOFFSection(
780 ".debug_gnu_pubtypes", COFF::IMAGE_SCN_MEM_DISCARDABLE |
781 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
782 COFF::IMAGE_SCN_MEM_READ);
783 DwarfStrSection = Ctx->getCOFFSection(
784 ".debug_str", COFF::IMAGE_SCN_MEM_DISCARDABLE |
785 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
786 COFF::IMAGE_SCN_MEM_READ);
787 DwarfStrOffSection = Ctx->getCOFFSection(
788 ".debug_str_offsets", COFF::IMAGE_SCN_MEM_DISCARDABLE |
789 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
790 COFF::IMAGE_SCN_MEM_READ);
791 DwarfLocSection = Ctx->getCOFFSection(
792 ".debug_loc", COFF::IMAGE_SCN_MEM_DISCARDABLE |
793 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
794 COFF::IMAGE_SCN_MEM_READ);
795 DwarfLoclistsSection = Ctx->getCOFFSection(
796 ".debug_loclists", COFF::IMAGE_SCN_MEM_DISCARDABLE |
797 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
798 COFF::IMAGE_SCN_MEM_READ);
799 DwarfARangesSection = Ctx->getCOFFSection(
800 ".debug_aranges", COFF::IMAGE_SCN_MEM_DISCARDABLE |
801 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
802 COFF::IMAGE_SCN_MEM_READ);
803 DwarfRangesSection = Ctx->getCOFFSection(
804 ".debug_ranges", COFF::IMAGE_SCN_MEM_DISCARDABLE |
805 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
806 COFF::IMAGE_SCN_MEM_READ);
807 DwarfRnglistsSection = Ctx->getCOFFSection(
808 ".debug_rnglists", COFF::IMAGE_SCN_MEM_DISCARDABLE |
809 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
810 COFF::IMAGE_SCN_MEM_READ);
811 DwarfMacinfoSection = Ctx->getCOFFSection(
812 ".debug_macinfo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
813 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
814 COFF::IMAGE_SCN_MEM_READ);
815 DwarfMacroSection = Ctx->getCOFFSection(
816 ".debug_macro", COFF::IMAGE_SCN_MEM_DISCARDABLE |
817 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
818 COFF::IMAGE_SCN_MEM_READ);
819 DwarfMacinfoDWOSection = Ctx->getCOFFSection(
820 ".debug_macinfo.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
821 COFF::IMAGE_SCN_LNK_REMOVE |
822 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
823 COFF::IMAGE_SCN_MEM_READ);
824 DwarfMacroDWOSection = Ctx->getCOFFSection(
825 ".debug_macro.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
826 COFF::IMAGE_SCN_LNK_REMOVE |
827 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
828 COFF::IMAGE_SCN_MEM_READ);
829 DwarfInfoDWOSection = Ctx->getCOFFSection(
830 ".debug_info.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
831 COFF::IMAGE_SCN_LNK_REMOVE |
832 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
833 COFF::IMAGE_SCN_MEM_READ);
834 DwarfTypesDWOSection = Ctx->getCOFFSection(
835 ".debug_types.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
836 COFF::IMAGE_SCN_LNK_REMOVE |
837 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
838 COFF::IMAGE_SCN_MEM_READ);
839 DwarfAbbrevDWOSection = Ctx->getCOFFSection(
840 ".debug_abbrev.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
841 COFF::IMAGE_SCN_LNK_REMOVE |
842 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
843 COFF::IMAGE_SCN_MEM_READ);
844 DwarfStrDWOSection = Ctx->getCOFFSection(
845 ".debug_str.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
846 COFF::IMAGE_SCN_LNK_REMOVE |
847 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
848 COFF::IMAGE_SCN_MEM_READ);
849 DwarfLineDWOSection = Ctx->getCOFFSection(
850 ".debug_line.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
851 COFF::IMAGE_SCN_LNK_REMOVE |
852 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
853 COFF::IMAGE_SCN_MEM_READ);
854 DwarfLocDWOSection = Ctx->getCOFFSection(
855 ".debug_loc.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
856 COFF::IMAGE_SCN_LNK_REMOVE |
857 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
858 COFF::IMAGE_SCN_MEM_READ);
859 DwarfLoclistsDWOSection = Ctx->getCOFFSection(
860 ".debug_loclists.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
861 COFF::IMAGE_SCN_LNK_REMOVE |
862 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
863 COFF::IMAGE_SCN_MEM_READ);
864 DwarfStrOffDWOSection = Ctx->getCOFFSection(
865 ".debug_str_offsets.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
866 COFF::IMAGE_SCN_LNK_REMOVE |
867 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
868 COFF::IMAGE_SCN_MEM_READ);
869 DwarfRnglistsDWOSection = Ctx->getCOFFSection(
870 ".debug_rnglists.dwo", COFF::IMAGE_SCN_MEM_DISCARDABLE |
871 COFF::IMAGE_SCN_LNK_REMOVE |
872 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
873 COFF::IMAGE_SCN_MEM_READ);
874 DwarfAddrSection = Ctx->getCOFFSection(
875 ".debug_addr", COFF::IMAGE_SCN_MEM_DISCARDABLE |
876 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
877 COFF::IMAGE_SCN_MEM_READ);
878 DwarfCUIndexSection = Ctx->getCOFFSection(
879 ".debug_cu_index", COFF::IMAGE_SCN_MEM_DISCARDABLE |
880 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
881 COFF::IMAGE_SCN_MEM_READ);
882 DwarfTUIndexSection = Ctx->getCOFFSection(
883 ".debug_tu_index", COFF::IMAGE_SCN_MEM_DISCARDABLE |
884 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
885 COFF::IMAGE_SCN_MEM_READ);
886 DwarfDebugNamesSection = Ctx->getCOFFSection(
887 ".debug_names", COFF::IMAGE_SCN_MEM_DISCARDABLE |
888 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
889 COFF::IMAGE_SCN_MEM_READ);
890 DwarfAccelNamesSection = Ctx->getCOFFSection(
891 ".apple_names", COFF::IMAGE_SCN_MEM_DISCARDABLE |
892 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
893 COFF::IMAGE_SCN_MEM_READ);
894 DwarfAccelNamespaceSection = Ctx->getCOFFSection(
895 ".apple_namespaces", COFF::IMAGE_SCN_MEM_DISCARDABLE |
896 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
897 COFF::IMAGE_SCN_MEM_READ);
898 DwarfAccelTypesSection = Ctx->getCOFFSection(
899 ".apple_types", COFF::IMAGE_SCN_MEM_DISCARDABLE |
900 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
901 COFF::IMAGE_SCN_MEM_READ);
902 DwarfAccelObjCSection = Ctx->getCOFFSection(
903 ".apple_objc", COFF::IMAGE_SCN_MEM_DISCARDABLE |
904 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
905 COFF::IMAGE_SCN_MEM_READ);
906
907 DrectveSection = Ctx->getCOFFSection(
908 ".drectve", COFF::IMAGE_SCN_LNK_INFO | COFF::IMAGE_SCN_LNK_REMOVE);
909
910 PDataSection =
911 Ctx->getCOFFSection(".pdata", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
912 COFF::IMAGE_SCN_MEM_READ);
913
914 XDataSection =
915 Ctx->getCOFFSection(".xdata", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
916 COFF::IMAGE_SCN_MEM_READ);
917
918 SXDataSection = Ctx->getCOFFSection(".sxdata", COFF::IMAGE_SCN_LNK_INFO);
919
920 GEHContSection =
921 Ctx->getCOFFSection(".gehcont$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
922 COFF::IMAGE_SCN_MEM_READ);
923
924 GFIDsSection =
925 Ctx->getCOFFSection(".gfids$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
926 COFF::IMAGE_SCN_MEM_READ);
927
928 GIATsSection =
929 Ctx->getCOFFSection(".giats$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
930 COFF::IMAGE_SCN_MEM_READ);
931
932 GLJMPSection =
933 Ctx->getCOFFSection(".gljmp$y", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
934 COFF::IMAGE_SCN_MEM_READ);
935
936 TLSDataSection = Ctx->getCOFFSection(
937 ".tls$", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ |
938 COFF::IMAGE_SCN_MEM_WRITE);
939
940 StackMapSection = Ctx->getCOFFSection(".llvm_stackmaps",
941 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
942 COFF::IMAGE_SCN_MEM_READ);
943
944 // Set IMAGE_SCN_MEM_DISCARDABLE so that lld will not truncate section name.
945 PseudoProbeSection = Ctx->getCOFFSection(
946 ".pseudo_probe", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
947 COFF::IMAGE_SCN_MEM_DISCARDABLE |
948 COFF::IMAGE_SCN_MEM_READ);
949 PseudoProbeDescSection = Ctx->getCOFFSection(
950 ".pseudo_probe_desc", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
951 COFF::IMAGE_SCN_MEM_DISCARDABLE |
952 COFF::IMAGE_SCN_MEM_READ);
953}
954
955void MCObjectFileInfo::initSPIRVMCObjectFileInfo(const Triple &T) {
956 // Put everything in a single binary section.
957 TextSection = Ctx->getSPIRVSection();
958}
959
960void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
961 TextSection = Ctx->getWasmSection(".text", SectionKind::getText());
962 DataSection = Ctx->getWasmSection(".data", SectionKind::getData());
963
964 DwarfLineSection =
965 Ctx->getWasmSection(".debug_line", SectionKind::getMetadata());
966 DwarfLineStrSection =
967 Ctx->getWasmSection(".debug_line_str", SectionKind::getMetadata(),
968 wasm::WASM_SEG_FLAG_STRINGS);
969 DwarfStrSection = Ctx->getWasmSection(
970 ".debug_str", SectionKind::getMetadata(), wasm::WASM_SEG_FLAG_STRINGS);
971 DwarfLocSection =
972 Ctx->getWasmSection(".debug_loc", SectionKind::getMetadata());
973 DwarfAbbrevSection =
974 Ctx->getWasmSection(".debug_abbrev", SectionKind::getMetadata());
975 DwarfARangesSection = Ctx->getWasmSection(".debug_aranges", SectionKind::getMetadata());
976 DwarfRangesSection =
977 Ctx->getWasmSection(".debug_ranges", SectionKind::getMetadata());
978 DwarfMacinfoSection =
979 Ctx->getWasmSection(".debug_macinfo", SectionKind::getMetadata());
980 DwarfMacroSection =
981 Ctx->getWasmSection(".debug_macro", SectionKind::getMetadata());
982 DwarfCUIndexSection = Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata());
983 DwarfTUIndexSection = Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata());
984 DwarfInfoSection =
985 Ctx->getWasmSection(".debug_info", SectionKind::getMetadata());
986 DwarfFrameSection = Ctx->getWasmSection(".debug_frame", SectionKind::getMetadata());
987 DwarfPubNamesSection = Ctx->getWasmSection(".debug_pubnames", SectionKind::getMetadata());
988 DwarfPubTypesSection = Ctx->getWasmSection(".debug_pubtypes", SectionKind::getMetadata());
989 DwarfGnuPubNamesSection =
990 Ctx->getWasmSection(".debug_gnu_pubnames", SectionKind::getMetadata());
991 DwarfGnuPubTypesSection =
992 Ctx->getWasmSection(".debug_gnu_pubtypes", SectionKind::getMetadata());
993
994 DwarfDebugNamesSection =
995 Ctx->getWasmSection(".debug_names", SectionKind::getMetadata());
996 DwarfStrOffSection =
997 Ctx->getWasmSection(".debug_str_offsets", SectionKind::getMetadata());
998 DwarfAddrSection =
999 Ctx->getWasmSection(".debug_addr", SectionKind::getMetadata());
1000 DwarfRnglistsSection =
1001 Ctx->getWasmSection(".debug_rnglists", SectionKind::getMetadata());
1002 DwarfLoclistsSection =
1003 Ctx->getWasmSection(".debug_loclists", SectionKind::getMetadata());
1004
1005 // Fission Sections
1006 DwarfInfoDWOSection =
1007 Ctx->getWasmSection(".debug_info.dwo", SectionKind::getMetadata());
1008 DwarfTypesDWOSection =
1009 Ctx->getWasmSection(".debug_types.dwo", SectionKind::getMetadata());
1010 DwarfAbbrevDWOSection =
1011 Ctx->getWasmSection(".debug_abbrev.dwo", SectionKind::getMetadata());
1012 DwarfStrDWOSection =
1013 Ctx->getWasmSection(".debug_str.dwo", SectionKind::getMetadata(),
1014 wasm::WASM_SEG_FLAG_STRINGS);
1015 DwarfLineDWOSection =
1016 Ctx->getWasmSection(".debug_line.dwo", SectionKind::getMetadata());
1017 DwarfLocDWOSection =
1018 Ctx->getWasmSection(".debug_loc.dwo", SectionKind::getMetadata());
1019 DwarfStrOffDWOSection =
1020 Ctx->getWasmSection(".debug_str_offsets.dwo", SectionKind::getMetadata());
1021 DwarfRnglistsDWOSection =
1022 Ctx->getWasmSection(".debug_rnglists.dwo", SectionKind::getMetadata());
1023 DwarfMacinfoDWOSection =
1024 Ctx->getWasmSection(".debug_macinfo.dwo", SectionKind::getMetadata());
1025 DwarfMacroDWOSection =
1026 Ctx->getWasmSection(".debug_macro.dwo", SectionKind::getMetadata());
1027
1028 DwarfLoclistsDWOSection =
1029 Ctx->getWasmSection(".debug_loclists.dwo", SectionKind::getMetadata());
1030
1031 // DWP Sections
1032 DwarfCUIndexSection =
1033 Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata());
1034 DwarfTUIndexSection =
1035 Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata());
1036
1037 // Wasm use data section for LSDA.
1038 // TODO Consider putting each function's exception table in a separate
1039 // section, as in -function-sections, to facilitate lld's --gc-section.
1040 LSDASection = Ctx->getWasmSection(".rodata.gcc_except_table",
1041 SectionKind::getReadOnlyWithRel());
1042
1043 // TODO: Define more sections.
1044}
1045
1046void MCObjectFileInfo::initXCOFFMCObjectFileInfo(const Triple &T) {
1047 // The default csect for program code. Functions without a specified section
1048 // get placed into this csect. The choice of csect name is not a property of
1049 // the ABI or object file format, but various tools rely on the section
1050 // name being empty (considering named symbols to be "user symbol names").
1051 TextSection = Ctx->getXCOFFSection(
1052 "..text..", // Use a non-null name to work around an AIX assembler bug...
1053 SectionKind::getText(),
1054 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_PR, XCOFF::XTY_SD),
1055 /* MultiSymbolsAllowed*/ true);
1056
1057 // ... but use a null name when generating the symbol table.
1058 MCSectionXCOFF *TS = static_cast<MCSectionXCOFF *>(TextSection);
1059 TS->getQualNameSymbol()->setSymbolTableName("");
1060 TS->setSymbolTableName("");
1061
1062 DataSection = Ctx->getXCOFFSection(
1063 ".data", SectionKind::getData(),
1064 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RW, XCOFF::XTY_SD),
1065 /* MultiSymbolsAllowed*/ true);
1066
1067 ReadOnlySection = Ctx->getXCOFFSection(
1068 ".rodata", SectionKind::getReadOnly(),
1069 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD),
1070 /* MultiSymbolsAllowed*/ true);
1071 ReadOnlySection->setAlignment(Align(4));
1072
1073 ReadOnly8Section = Ctx->getXCOFFSection(
1074 ".rodata.8", SectionKind::getReadOnly(),
1075 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD),
1076 /* MultiSymbolsAllowed*/ true);
1077 ReadOnly8Section->setAlignment(Align(8));
1078
1079 ReadOnly16Section = Ctx->getXCOFFSection(
1080 ".rodata.16", SectionKind::getReadOnly(),
1081 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO, XCOFF::XTY_SD),
1082 /* MultiSymbolsAllowed*/ true);
1083 ReadOnly16Section->setAlignment(Align(16));
1084
1085 TLSDataSection = Ctx->getXCOFFSection(
1086 ".tdata", SectionKind::getThreadData(),
1087 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_TL, XCOFF::XTY_SD),
1088 /* MultiSymbolsAllowed*/ true);
1089
1090 TOCBaseSection = Ctx->getXCOFFSection(
1091 "TOC", SectionKind::getData(),
1092 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_TC0,
1093 XCOFF::XTY_SD));
1094
1095 // The TOC-base always has 0 size, but 4 byte alignment.
1096 TOCBaseSection->setAlignment(Align(4));
1097
1098 LSDASection = Ctx->getXCOFFSection(
1099 ".gcc_except_table", SectionKind::getReadOnly(),
1100 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RO,
1101 XCOFF::XTY_SD));
1102
1103 CompactUnwindSection = Ctx->getXCOFFSection(
1104 ".eh_info_table", SectionKind::getData(),
1105 XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RW,
1106 XCOFF::XTY_SD));
1107
1108 // DWARF sections for XCOFF are not csects. They are special STYP_DWARF
1109 // sections, and the individual DWARF sections are distinguished by their
1110 // section subtype.
1111 DwarfAbbrevSection = Ctx->getXCOFFSection(
1112 ".dwabrev", SectionKind::getMetadata(),
1113 /* CsectProperties */ std::nullopt,
1114 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWABREV);
1115
1116 DwarfInfoSection = Ctx->getXCOFFSection(
1117 ".dwinfo", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1118 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWINFO);
1119
1120 DwarfLineSection = Ctx->getXCOFFSection(
1121 ".dwline", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1122 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWLINE);
1123
1124 DwarfFrameSection = Ctx->getXCOFFSection(
1125 ".dwframe", SectionKind::getMetadata(),
1126 /* CsectProperties */ std::nullopt,
1127 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWFRAME);
1128
1129 DwarfPubNamesSection = Ctx->getXCOFFSection(
1130 ".dwpbnms", SectionKind::getMetadata(),
1131 /* CsectProperties */ std::nullopt,
1132 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWPBNMS);
1133
1134 DwarfPubTypesSection = Ctx->getXCOFFSection(
1135 ".dwpbtyp", SectionKind::getMetadata(),
1136 /* CsectProperties */ std::nullopt,
1137 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWPBTYP);
1138
1139 DwarfStrSection = Ctx->getXCOFFSection(
1140 ".dwstr", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1141 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWSTR);
1142
1143 DwarfLocSection = Ctx->getXCOFFSection(
1144 ".dwloc", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1145 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWLOC);
1146
1147 DwarfARangesSection = Ctx->getXCOFFSection(
1148 ".dwarnge", SectionKind::getMetadata(),
1149 /* CsectProperties */ std::nullopt,
1150 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWARNGE);
1151
1152 DwarfRangesSection = Ctx->getXCOFFSection(
1153 ".dwrnges", SectionKind::getMetadata(),
1154 /* CsectProperties */ std::nullopt,
1155 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWRNGES);
1156
1157 DwarfMacinfoSection = Ctx->getXCOFFSection(
1158 ".dwmac", SectionKind::getMetadata(), /* CsectProperties */ std::nullopt,
1159 /* MultiSymbolsAllowed */ true, XCOFF::SSUBTYP_DWMAC);
1160}
1161
1162void MCObjectFileInfo::initDXContainerObjectFileInfo(const Triple &T) {
1163 // At the moment the DXBC section should end up empty.
1164 TextSection = Ctx->getDXContainerSection("DXBC", SectionKind::getText());
1165}
1166
1167MCObjectFileInfo::~MCObjectFileInfo() = default;
1168
1169void MCObjectFileInfo::initMCObjectFileInfo(MCContext &MCCtx, bool PIC,
1170 bool LargeCodeModel) {
1171 PositionIndependent = PIC;
1172 Ctx = &MCCtx;
1173
1174 // Common.
1175 SupportsCompactUnwindWithoutEHFrame = false;
1176 OmitDwarfIfHaveCompactUnwind = false;
1177
1178 FDECFIEncoding = dwarf::DW_EH_PE_absptr;
1179
1180 CompactUnwindDwarfEHFrameOnly = 0;
1181
1182 EHFrameSection = nullptr; // Created on demand.
1183 SFrameSection = nullptr; // Created on demand.
1184 CompactUnwindSection = nullptr; // Used only by selected targets.
1185 DwarfAccelNamesSection = nullptr; // Used only by selected targets.
1186 DwarfAccelObjCSection = nullptr; // Used only by selected targets.
1187 DwarfAccelNamespaceSection = nullptr; // Used only by selected targets.
1188 DwarfAccelTypesSection = nullptr; // Used only by selected targets.
1189
1190 const Triple &TheTriple = Ctx->getTargetTriple();
1191 switch (Ctx->getObjectFileType()) {
1192 case MCContext::IsMachO:
1193 initMachOMCObjectFileInfo(TheTriple);
1194 break;
1195 case MCContext::IsCOFF:
1196 initCOFFMCObjectFileInfo(TheTriple);
1197 break;
1198 case MCContext::IsELF:
1199 initELFMCObjectFileInfo(TheTriple, LargeCodeModel);
1200 break;
1201 case MCContext::IsGOFF:
1202 initGOFFMCObjectFileInfo(TheTriple);
1203 break;
1204 case MCContext::IsSPIRV:
1205 initSPIRVMCObjectFileInfo(TheTriple);
1206 break;
1207 case MCContext::IsWasm:
1208 initWasmMCObjectFileInfo(TheTriple);
1209 break;
1210 case MCContext::IsXCOFF:
1211 initXCOFFMCObjectFileInfo(TheTriple);
1212 break;
1213 case MCContext::IsDXContainer:
1214 initDXContainerObjectFileInfo(TheTriple);
1215 break;
1216 }
1217}
1218
1219MCSection *MCObjectFileInfo::getDwarfComdatSection(const char *Name,
1220 uint64_t Hash) const {
1221 switch (Ctx->getTargetTriple().getObjectFormat()) {
1222 case Triple::ELF:
1223 return Ctx->getELFSection(Name, ELF::SHT_PROGBITS, ELF::SHF_GROUP, 0,
1224 utostr(Hash), /*IsComdat=*/true);
1225 case Triple::Wasm:
1226 return Ctx->getWasmSection(Name, SectionKind::getMetadata(), 0,
1227 utostr(Hash), MCSection::NonUniqueID);
1228 case Triple::MachO:
1229 case Triple::COFF:
1230 case Triple::GOFF:
1231 case Triple::SPIRV:
1232 case Triple::XCOFF:
1233 case Triple::DXContainer:
1234 case Triple::UnknownObjectFormat:
1235 report_fatal_error("Cannot get DWARF comdat section for this object file "
1236 "format: not implemented.");
1237 break;
1238 }
1239 llvm_unreachable("Unknown ObjectFormatType");
1240}
1241
1242MCSection *
1243MCObjectFileInfo::getCallGraphSection(const MCSection &TextSec) const {
1244 if (Ctx->getObjectFileType() != MCContext::IsELF)
1245 return CallGraphSection;
1246
1247 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1248 unsigned Flags = ELF::SHF_LINK_ORDER;
1249 StringRef GroupName;
1250 if (const MCSymbol *Group = ElfSec.getGroup()) {
1251 GroupName = Group->getName();
1252 Flags |= ELF::SHF_GROUP;
1253 }
1254
1255 return Ctx->getELFSection(
1256 ".llvm.callgraph", ELF::SHT_LLVM_CALL_GRAPH, Flags, 0, GroupName,
1257 /*IsComdat=*/true, ElfSec.getUniqueID(),
1258 static_cast<const MCSymbolELF *>(TextSec.getBeginSymbol()));
1259}
1260
1261MCSection *
1262MCObjectFileInfo::getStackSizesSection(const MCSection &TextSec) const {
1263 if ((Ctx->getObjectFileType() != MCContext::IsELF) ||
1264 Ctx->getTargetTriple().isPS4())
1265 return StackSizesSection;
1266
1267 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1268 unsigned Flags = ELF::SHF_LINK_ORDER;
1269 StringRef GroupName;
1270 if (const MCSymbol *Group = ElfSec.getGroup()) {
1271 GroupName = Group->getName();
1272 Flags |= ELF::SHF_GROUP;
1273 }
1274
1275 return Ctx->getELFSection(
1276 ".stack_sizes", ELF::SHT_PROGBITS, Flags, 0, GroupName, true,
1277 ElfSec.getUniqueID(),
1278 static_cast<const MCSymbolELF *>(TextSec.getBeginSymbol()));
1279}
1280
1281MCSection *
1282MCObjectFileInfo::getBBAddrMapSection(const MCSection &TextSec) const {
1283 constexpr StringLiteral Name = ".llvm_bb_addr_map";
1284 if (Ctx->getObjectFileType() == MCContext::IsELF) {
1285 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1286 unsigned Flags = ELF::SHF_LINK_ORDER;
1287 StringRef GroupName;
1288 if (const MCSymbol *Group = ElfSec.getGroup()) {
1289 GroupName = Group->getName();
1290 Flags |= ELF::SHF_GROUP;
1291 }
1292
1293 // Use the text section's begin symbol and unique ID to create a separate
1294 // .llvm_bb_addr_map section associated with every unique text section.
1295 return Ctx->getELFSection(
1296 Name, ELF::SHT_LLVM_BB_ADDR_MAP, Flags, 0, GroupName, true,
1297 ElfSec.getUniqueID(),
1298 static_cast<const MCSymbolELF *>(TextSec.getBeginSymbol()));
1299 } else if (Ctx->getObjectFileType() == MCContext::IsCOFF) {
1300 StringRef COMDATSymName;
1301 int Selection = 0;
1302 unsigned Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1303 COFF::IMAGE_SCN_MEM_DISCARDABLE |
1304 COFF::IMAGE_SCN_MEM_READ;
1305 const auto &COFFSec = static_cast<const MCSectionCOFF &>(TextSec);
1306 if (const MCSymbol *COMDATSym = COFFSec.getCOMDATSymbol()) {
1307 if (!Ctx->getAsmInfo().hasCOFFAssociativeComdats())
1308 report_fatal_error("BB address map requires associative COMDAT "
1309 "support for COMDAT functions");
1310 COMDATSymName = COMDATSym->getName();
1311 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1312 Selection = COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE;
1313 }
1314 return Ctx->getCOFFSection(Name, Characteristics, COMDATSymName, Selection,
1315 COFFSec.getUniqueID());
1316 }
1317
1318 return nullptr;
1319}
1320
1321MCSection *
1322MCObjectFileInfo::getKCFITrapSection(const MCSection &TextSec) const {
1323 if (Ctx->getObjectFileType() != MCContext::IsELF)
1324 return nullptr;
1325
1326 const MCSectionELF &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1327 unsigned Flags = ELF::SHF_LINK_ORDER | ELF::SHF_ALLOC;
1328 StringRef GroupName;
1329 if (const MCSymbol *Group = ElfSec.getGroup()) {
1330 GroupName = Group->getName();
1331 Flags |= ELF::SHF_GROUP;
1332 }
1333
1334 return Ctx->getELFSection(
1335 ".kcfi_traps", ELF::SHT_PROGBITS, Flags, 0, GroupName,
1336 /*IsComdat=*/true, ElfSec.getUniqueID(),
1337 static_cast<const MCSymbolELF *>(TextSec.getBeginSymbol()));
1338}
1339
1340MCSection *
1341MCObjectFileInfo::getPseudoProbeSection(const MCSection &TextSec) const {
1342 auto ObjFileType = Ctx->getObjectFileType();
1343 if (ObjFileType == MCContext::IsELF) {
1344 const auto &ElfSec = static_cast<const MCSectionELF &>(TextSec);
1345 unsigned Flags = ELF::SHF_LINK_ORDER;
1346 StringRef GroupName;
1347 if (const MCSymbol *Group = ElfSec.getGroup()) {
1348 GroupName = Group->getName();
1349 Flags |= ELF::SHF_GROUP;
1350 }
1351 return Ctx->getELFSection(
1352 PseudoProbeSection->getName(), ELF::SHT_PROGBITS, Flags, 0, GroupName,
1353 true, ElfSec.getUniqueID(),
1354 static_cast<const MCSymbolELF *>(TextSec.getBeginSymbol()));
1355 } else if (ObjFileType == MCContext::IsCOFF) {
1356 StringRef COMDATSymName = "";
1357 int Selection = 0;
1358 unsigned Characteristics =
1359 static_cast<MCSectionCOFF *>(PseudoProbeSection)->getCharacteristics();
1360 const auto &COFFSec = static_cast<const MCSectionCOFF &>(TextSec);
1361 if (const MCSymbol *COMDATSym = COFFSec.getCOMDATSymbol()) {
1362 // Associate .pseudo_probe to its function section.
1363 COMDATSymName = COMDATSym->getName();
1364 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1365 Selection = COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE;
1366 }
1367 return Ctx->getCOFFSection(PseudoProbeSection->getName(), Characteristics,
1368 COMDATSymName, Selection, COFFSec.getUniqueID());
1369 }
1370
1371 return PseudoProbeSection;
1372}
1373
1374MCSection *
1375MCObjectFileInfo::getPseudoProbeDescSection(StringRef FuncName,
1376 uint64_t FuncHash) const {
1377 if (!Ctx->getTargetTriple().supportsCOMDAT() || FuncName.empty())
1378 return PseudoProbeDescSection;
1379
1380 // Create a separate comdat group for each function's descriptor in order
1381 // for the linker to deduplicate. The duplication, must be from different
1382 // translation unit, can come from:
1383 // 1. Inline functions defined in header files;
1384 // 2. ThinLTO imported functions;
1385 // 3. Weak-linkage definitions.
1386 // Use a concatenation of the section name, function name, and function hash
1387 // as the group name so that descriptors with different hashes (due to user
1388 // code not following ODR or compiler codegen inconsistencies) get separate
1389 // COMDAT sections instead of being silently dropped (ELF) or causing linker
1390 // errors (COFF). Duplicate GUIDs with mismatching hashes are detected
1391 // during descriptor decoding and reported by llvm-profgen.
1392 auto ObjFileType = Ctx->getObjectFileType();
1393 if (ObjFileType == MCContext::IsELF) {
1394 auto *S = static_cast<MCSectionELF *>(PseudoProbeDescSection);
1395 auto Flags = S->getFlags() | ELF::SHF_GROUP;
1396 return Ctx->getELFSection(
1397 S->getName(), S->getType(), Flags, S->getEntrySize(),
1398 S->getName() + "_" + FuncName + "." + Twine::utohexstr(FuncHash),
1399 /*IsComdat=*/true);
1400 } else if (ObjFileType == MCContext::IsCOFF) {
1401 auto *S = static_cast<MCSectionCOFF *>(PseudoProbeDescSection);
1402 unsigned Characteristics =
1403 S->getCharacteristics() | COFF::IMAGE_SCN_LNK_COMDAT;
1404 std::string COMDATSymName =
1405 (S->getName() + "_" + FuncName + "." + Twine::utohexstr(FuncHash))
1406 .str();
1407 return Ctx->getCOFFSection(S->getName(), Characteristics, COMDATSymName,
1408 COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH);
1409 }
1410
1411 return PseudoProbeDescSection;
1412}
1413
1417
1418MCSection *MCObjectFileInfo::getPCSection(StringRef Name,
1419 const MCSection *TextSec) const {
1420 if (Ctx->getObjectFileType() != MCContext::IsELF)
1421 return nullptr;
1422
1423 // SHF_WRITE for relocations, and let user post-process data in-place.
1424 unsigned Flags = ELF::SHF_WRITE | ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER;
1425
1426 if (!TextSec)
1427 TextSec = getTextSection();
1428
1429 StringRef GroupName;
1430 const auto &ElfSec = static_cast<const MCSectionELF &>(*TextSec);
1431 if (const MCSymbol *Group = ElfSec.getGroup()) {
1432 GroupName = Group->getName();
1433 Flags |= ELF::SHF_GROUP;
1434 }
1435 return Ctx->getELFSection(
1436 Name, ELF::SHT_PROGBITS, Flags, 0, GroupName, true, ElfSec.getUniqueID(),
1437 static_cast<const MCSymbolELF *>(TextSec->getBeginSymbol()));
1438}
assert
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
Selection
amdgpu AMDGPU DAG DAG Pattern Instruction Selection
Definition AMDGPUISelDAGToDAG.cpp:160
useCompactUnwind
static bool useCompactUnwind(const Triple &T)
Definition MCObjectFileInfo.cpp:34
MCSectionGOFF.h
This file declares the MCSectionGOFF class, which contains all of the necessary machine code sections...
MCSymbolGOFF.h
This file contains the MCSymbolGOFF class.
T
#define T
Definition Mips16ISelLowering.cpp:282
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::MCContext
Context object for machine code objects.
Definition MCContext.h:83
llvm::MCContext::getOrCreateSymbol
LLVM_ABI MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition MCContext.cpp:208
llvm::MCObjectFileInfo::NonLazySymbolPointerSection
MCSection * NonLazySymbolPointerSection
Definition MCObjectFileInfo.h:225
llvm::MCObjectFileInfo::TLSBSSSection
MCSection * TLSBSSSection
Section directive for Thread Local uninitialized data.
Definition MCObjectFileInfo.h:164
llvm::MCObjectFileInfo::CallGraphSection
MCSection * CallGraphSection
Section containing call graph metadata.
Definition MCObjectFileInfo.h:73
llvm::MCObjectFileInfo::DwarfDebugNamesSection
MCSection * DwarfDebugNamesSection
Accelerator table sections.
Definition MCObjectFileInfo.h:107
llvm::MCObjectFileInfo::TLSThreadInitSection
const MCSection * TLSThreadInitSection
Section for thread local data initialization functions.
Definition MCObjectFileInfo.h:210
llvm::MCObjectFileInfo::DwarfStrOffSection
MCSection * DwarfStrOffSection
The DWARF v5 string offset and address table sections.
Definition MCObjectFileInfo.h:125
llvm::MCObjectFileInfo::MergeableConst16Section
MCSection * MergeableConst16Section
Definition MCObjectFileInfo.h:197
llvm::MCObjectFileInfo::COFFGlobalTypeHashesSection
MCSection * COFFGlobalTypeHashesSection
Definition MCObjectFileInfo.h:150
llvm::MCObjectFileInfo::SFrameSection
MCSection * SFrameSection
SFrame section.
Definition MCObjectFileInfo.h:181
llvm::MCObjectFileInfo::DwarfGnuPubTypesSection
MCSection * DwarfGnuPubTypesSection
Section for newer gnu pubtypes.
Definition MCObjectFileInfo.h:143
llvm::MCObjectFileInfo::getLLVMStatsSection
MCSection * getLLVMStatsSection() const
Definition MCObjectFileInfo.cpp:1414
llvm::MCObjectFileInfo::TextSection
MCSection * TextSection
Section directive for standard text.
Definition MCObjectFileInfo.h:54
llvm::MCObjectFileInfo::TLSDataSection
MCSection * TLSDataSection
Section directive for Thread Local data. ELF, MachO, COFF, and Wasm.
Definition MCObjectFileInfo.h:159
llvm::MCObjectFileInfo::ThreadLocalPointerSection
MCSection * ThreadLocalPointerSection
Definition MCObjectFileInfo.h:226
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:70
llvm::MCObjectFileInfo::CompactUnwindSection
MCSection * CompactUnwindSection
If exception handling is supported by the target and the target can support a compact representation ...
Definition MCObjectFileInfo.h:78
llvm::MCObjectFileInfo::COFFDebugSymbolsSection
MCSection * COFFDebugSymbolsSection
Definition MCObjectFileInfo.h:148
llvm::MCObjectFileInfo::getPseudoProbeDescSection
MCSection * getPseudoProbeDescSection(StringRef FuncName, uint64_t FuncHash) const
Definition MCObjectFileInfo.cpp:1375
llvm::MCObjectFileInfo::DwarfLoclistsSection
MCSection * DwarfLoclistsSection
The DWARF v5 locations list section.
Definition MCObjectFileInfo.h:130
llvm::MCObjectFileInfo::PseudoProbeSection
MCSection * PseudoProbeSection
Section for pseudo probe information used by AutoFDO.
Definition MCObjectFileInfo.h:187
llvm::MCObjectFileInfo::FourByteConstantSection
MCSection * FourByteConstantSection
Definition MCObjectFileInfo.h:221
llvm::MCObjectFileInfo::getStackSizesSection
MCSection * getStackSizesSection(const MCSection &TextSec) const
Definition MCObjectFileInfo.cpp:1262
llvm::MCObjectFileInfo::DwarfRnglistsSection
MCSection * DwarfRnglistsSection
The DWARF v5 range list section.
Definition MCObjectFileInfo.h:128
llvm::MCObjectFileInfo::DwarfDebugInlineSection
const MCSection * DwarfDebugInlineSection
Definition MCObjectFileInfo.h:92
llvm::MCObjectFileInfo::getBBAddrMapSection
MCSection * getBBAddrMapSection(const MCSection &TextSec) const
Definition MCObjectFileInfo.cpp:1282
llvm::MCObjectFileInfo::LazySymbolPointerSection
MCSection * LazySymbolPointerSection
Definition MCObjectFileInfo.h:224
llvm::MCObjectFileInfo::RemarksSection
MCSection * RemarksSection
Remarks section.
Definition MCObjectFileInfo.h:173
llvm::MCObjectFileInfo::getPseudoProbeSection
MCSection * getPseudoProbeSection(const MCSection &TextSec) const
Definition MCObjectFileInfo.cpp:1341
llvm::MCObjectFileInfo::TLSExtraDataSection
MCSection * TLSExtraDataSection
Extra TLS Variable Data section.
Definition MCObjectFileInfo.h:156
llvm::MCObjectFileInfo::EHFrameSection
MCSection * EHFrameSection
EH frame section.
Definition MCObjectFileInfo.h:178
llvm::MCObjectFileInfo::OmitDwarfIfHaveCompactUnwind
bool OmitDwarfIfHaveCompactUnwind
OmitDwarfIfHaveCompactUnwind - True if the target object file supports having some functions with com...
Definition MCObjectFileInfo.h:39
llvm::MCObjectFileInfo::DrectveSection
MCSection * DrectveSection
COFF specific sections.
Definition MCObjectFileInfo.h:230
llvm::MCObjectFileInfo::FaultMapSection
MCSection * FaultMapSection
FaultMap section.
Definition MCObjectFileInfo.h:170
llvm::MCObjectFileInfo::getKCFITrapSection
MCSection * getKCFITrapSection(const MCSection &TextSec) const
Definition MCObjectFileInfo.cpp:1322
llvm::MCObjectFileInfo::TLSTLVSection
MCSection * TLSTLVSection
Section for thread local structure information.
Definition MCObjectFileInfo.h:206
llvm::MCObjectFileInfo::initMCObjectFileInfo
void initMCObjectFileInfo(MCContext &MCCtx, bool PIC, bool LargeCodeModel=false)
Definition MCObjectFileInfo.cpp:1169
llvm::MCObjectFileInfo::DwarfRnglistsDWOSection
MCSection * DwarfRnglistsDWOSection
The DWARF v5 range and location list sections for fission.
Definition MCObjectFileInfo.h:133
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:82
llvm::MCObjectFileInfo::MergeableConst32Section
MCSection * MergeableConst32Section
Definition MCObjectFileInfo.h:198
llvm::MCObjectFileInfo::SixteenByteConstantSection
MCSection * SixteenByteConstantSection
Definition MCObjectFileInfo.h:223
llvm::MCObjectFileInfo::getPCSection
MCSection * getPCSection(StringRef Name, const MCSection *TextSec) const
Definition MCObjectFileInfo.cpp:1418
llvm::MCObjectFileInfo::SFrameABIArch
std::optional< sframe::ABI > SFrameABIArch
SFrame ABI architecture byte.
Definition MCObjectFileInfo.h:51
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:34
llvm::MCObjectFileInfo::ReadOnlySection
MCSection * ReadOnlySection
Section that is readonly and can contain arbitrary initialized data.
Definition MCObjectFileInfo.h:66
llvm::MCObjectFileInfo::FDECFIEncoding
unsigned FDECFIEncoding
FDE CFI encoding.
Definition MCObjectFileInfo.h:45
llvm::MCObjectFileInfo::DwarfLoclistsDWOSection
MCSection * DwarfLoclistsDWOSection
Definition MCObjectFileInfo.h:134
llvm::MCObjectFileInfo::getCallGraphSection
MCSection * getCallGraphSection(const MCSection &TextSec) const
Definition MCObjectFileInfo.cpp:1243
llvm::MCObjectFileInfo::BSSSection
MCSection * BSSSection
Section that is default initialized to zero.
Definition MCObjectFileInfo.h:60
llvm::MCObjectFileInfo::EightByteConstantSection
MCSection * EightByteConstantSection
Definition MCObjectFileInfo.h:222
llvm::MCObjectFileInfo::StackSizesSection
MCSection * StackSizesSection
Section containing metadata on function stack sizes.
Definition MCObjectFileInfo.h:184
llvm::MCObjectFileInfo::CompactUnwindDwarfEHFrameOnly
unsigned CompactUnwindDwarfEHFrameOnly
Compact unwind encoding indicating that we should emit only an EH frame.
Definition MCObjectFileInfo.h:48
llvm::MCObjectFileInfo::getTextSection
MCSection * getTextSection() const
Definition MCObjectFileInfo.h:274
llvm::MCObjectFileInfo::DwarfGnuPubNamesSection
MCSection * DwarfGnuPubNamesSection
Section for newer gnu pubnames.
Definition MCObjectFileInfo.h:141
llvm::MCObjectFileInfo::StackMapSection
MCSection * StackMapSection
StackMap section.
Definition MCObjectFileInfo.h:167
llvm::MCObjectFileInfo::getContext
MCContext & getContext() const
Definition MCObjectFileInfo.h:257
llvm::MCObjectFileInfo::DwarfAccelNamespaceSection
MCSection * DwarfAccelNamespaceSection
Definition MCObjectFileInfo.h:110
llvm::MCObjectFileInfo::DataSection
MCSection * DataSection
Section directive for standard data.
Definition MCObjectFileInfo.h:57
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::getFlags
unsigned getFlags() const
Definition MCSectionELF.h:74
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:573
llvm::MCSection::NonUniqueID
static constexpr unsigned NonUniqueID
Definition MCSection.h:578
llvm::MCSection::setBeginSymbol
void setBeginSymbol(MCSymbol *Sym)
Definition MCSection.h:650
llvm::MCSection::getBeginSymbol
MCSymbol * getBeginSymbol()
Definition MCSection.h:646
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::StringLiteral
A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs...
Definition StringRef.h:882
llvm::StringRef
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
llvm::StringRef::empty
constexpr bool empty() const
Check if the string is empty.
Definition StringRef.h:141
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition Triple.h:47
llvm::Triple::UnknownObjectFormat
@ UnknownObjectFormat
Definition Triple.h:332
llvm::Twine::utohexstr
static Twine utohexstr(uint64_t Val)
Definition Twine.h:385
uint64_t
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition ErrorHandling.h:164
llvm::AMDGPU::HSAMD::Kernel::Arg::Key::Align
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
Definition AMDGPUMetadata.h:183
llvm::ARM_MB::LD
@ LD
Definition ARMBaseInfo.h:72
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::SHF_MERGE
@ SHF_MERGE
Definition ELF.h:1257
llvm::ELF::SHF_STRINGS
@ SHF_STRINGS
Definition ELF.h:1260
llvm::ELF::SHF_EXCLUDE
@ SHF_EXCLUDE
Definition ELF.h:1285
llvm::ELF::SHF_ALLOC
@ SHF_ALLOC
Definition ELF.h:1251
llvm::ELF::SHF_LINK_ORDER
@ SHF_LINK_ORDER
Definition ELF.h:1266
llvm::ELF::SHF_GROUP
@ SHF_GROUP
Definition ELF.h:1273
llvm::ELF::SHF_X86_64_LARGE
@ SHF_X86_64_LARGE
Definition ELF.h:1314
llvm::ELF::SHF_WRITE
@ SHF_WRITE
Definition ELF.h:1248
llvm::ELF::SHF_TLS
@ SHF_TLS
Definition ELF.h:1276
llvm::ELF::SHF_EXECINSTR
@ SHF_EXECINSTR
Definition ELF.h:1254
llvm::ELF::SHT_PROGBITS
@ SHT_PROGBITS
Definition ELF.h:1150
llvm::ELF::SHT_NOBITS
@ SHT_NOBITS
Definition ELF.h:1157
llvm::ELF::SHT_LLVM_CALL_GRAPH
@ SHT_LLVM_CALL_GRAPH
Definition ELF.h:1193
llvm::ELF::SHT_MIPS_DWARF
@ SHT_MIPS_DWARF
Definition ELF.h:1229
llvm::ELF::SHT_LLVM_BB_ADDR_MAP
@ SHT_LLVM_BB_ADDR_MAP
Definition ELF.h:1188
llvm::ELF::SHT_GNU_SFRAME
@ SHT_GNU_SFRAME
Definition ELF.h:1197
llvm::ELF::SHT_X86_64_UNWIND
@ SHT_X86_64_UNWIND
Definition ELF.h:1225
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:95
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:97
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:94
llvm::GOFF::ESD_RMODE_64
@ ESD_RMODE_64
Definition GOFF.h:88
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::MachO::S_ATTR_DEBUG
@ S_ATTR_DEBUG
S_ATTR_DEBUG - A debug section.
Definition MachO.h:207
llvm::MachO::S_ATTR_NO_DEAD_STRIP
@ S_ATTR_NO_DEAD_STRIP
S_ATTR_NO_DEAD_STRIP - No dead stripping.
Definition MachO.h:200
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::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:885
llvm::dwarf::DW_EH_PE_sdata4
@ DW_EH_PE_sdata4
Definition Dwarf.h:882
llvm::dwarf::DW_EH_PE_sdata8
@ DW_EH_PE_sdata8
Definition Dwarf.h:883
llvm::dwarf::DW_EH_PE_absptr
@ DW_EH_PE_absptr
Definition Dwarf.h:874
llvm::wasm::WASM_SEG_FLAG_STRINGS
@ WASM_SEG_FLAG_STRINGS
Definition Wasm.h:238
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition FunctionInfo.h:25
llvm::FuncHash
FuncHash
Definition InstrProf.h:78
llvm::utostr
std::string utostr(uint64_t X, bool isNeg=false)
Definition StringExtras.h:322
llvm::report_fatal_error
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
Definition Error.cpp:163
Generated on for LLVM by doxygen 1.14.0