LLVM 24.0.0git
TargetLoweringObjectFileImpl.cpp
Go to the documentation of this file.
1//===- llvm/CodeGen/TargetLoweringObjectFileImpl.cpp - Object File Info ---===//
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// This file implements classes used to handle lowerings specific to common
10// object file formats.
11//
12//===----------------------------------------------------------------------===//
13
18#include "llvm/ADT/StringRef.h"
32#include "llvm/IR/Comdat.h"
33#include "llvm/IR/Constants.h"
34#include "llvm/IR/DataLayout.h"
38#include "llvm/IR/Function.h"
39#include "llvm/IR/GlobalAlias.h"
41#include "llvm/IR/GlobalValue.h"
43#include "llvm/IR/Mangler.h"
44#include "llvm/IR/Metadata.h"
45#include "llvm/IR/Module.h"
46#include "llvm/IR/Type.h"
47#include "llvm/MC/MCAsmInfo.h"
49#include "llvm/MC/MCContext.h"
50#include "llvm/MC/MCExpr.h"
58#include "llvm/MC/MCStreamer.h"
59#include "llvm/MC/MCSymbol.h"
60#include "llvm/MC/MCSymbolELF.h"
62#include "llvm/MC/MCValue.h"
63#include "llvm/MC/SectionKind.h"
65#include "llvm/Support/Base64.h"
69#include "llvm/Support/Format.h"
70#include "llvm/Support/Path.h"
74#include <cassert>
75#include <string>
76
77using namespace llvm;
78using namespace dwarf;
79
81 "jumptable-in-function-section", cl::Hidden, cl::init(false),
82 cl::desc("Putting Jump Table in function section"));
83
84static void GetObjCImageInfo(const Module &M, unsigned &Version,
85 unsigned &Flags, StringRef &Section) {
87 M.getModuleFlagsMetadata(ModuleFlags);
88
89 for (const auto &MFE: ModuleFlags) {
90 // Ignore flags with 'Require' behaviour.
91 if (MFE.Behavior == Module::Require)
92 continue;
93
94 StringRef Key = MFE.Key->getString();
95 if (Key == "Objective-C Image Info Version") {
96 Version = mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
97 } else if (Key == "Objective-C Garbage Collection" ||
98 Key == "Objective-C GC Only" ||
99 Key == "Objective-C Is Simulated" ||
100 Key == "Objective-C Class Properties" ||
101 Key == "Objective-C Enforce ClassRO Pointer Signing" ||
102 Key == "Objective-C Image Swift Version") {
103 Flags |= mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
104 } else if (Key == "Objective-C Image Info Section") {
105 Section = cast<MDString>(MFE.Val)->getString();
106 }
107 // Backend generates L_OBJC_IMAGE_INFO from Swift ABI version + major +
108 // minor + "Objective-C Garbage Collection".
109 else if (Key == "Swift ABI Version") {
110 Flags |= (mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue()) << 8;
111 } else if (Key == "Swift Major Version") {
112 Flags |= (mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue()) << 24;
113 } else if (Key == "Swift Minor Version") {
114 Flags |= (mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue()) << 16;
115 }
116 }
117}
118
119//===----------------------------------------------------------------------===//
120// ELF
121//===----------------------------------------------------------------------===//
122
124 const TargetMachine &TgtM,
125 const Module &M) {
127
128 const CodeModel::Model CM = TgtM.getCodeModel();
130
131 switch (TgtM.getTargetTriple().getArch()) {
132 case Triple::arm:
133 case Triple::armeb:
134 case Triple::thumb:
135 case Triple::thumbeb:
136 if (M.getExceptionModel() == ExceptionHandling::ARM)
137 break;
138 // Fallthrough if not using EHABI
139 [[fallthrough]];
140 case Triple::m68k:
141 case Triple::ppc:
142 case Triple::ppcle:
143 case Triple::x86:
156 break;
157 case Triple::x86_64: {
158 // The large EH encoding forces 64-bit-wide EH pointers regardless of the
159 // code model, so treat it like the Large code model when selecting
160 // encodings below.
161 const CodeModel::Model EHCM =
163 if (isPositionIndependent()) {
166 ((EHCM == CodeModel::Small || EHCM == CodeModel::Medium)
173 ((EHCM == CodeModel::Small || EHCM == CodeModel::Medium)
176 } else {
178 (EHCM == CodeModel::Small || EHCM == CodeModel::Medium)
185 }
186 break;
187 }
188 case Triple::hexagon:
192 if (isPositionIndependent()) {
196 }
197 break;
198 case Triple::aarch64:
201 // The small model guarantees static code/data size < 4GB, but not where it
202 // will be in memory. Most of these could end up >2GB away so even a signed
203 // pc-relative 32-bit address is insufficient, theoretically.
204 //
205 // Use DW_EH_PE_indirect even for -fno-pic to avoid copy relocations.
207 (TgtM.getTargetTriple().getEnvironment() == Triple::GNUILP32
212 break;
213 case Triple::lanai:
217 break;
218 case Triple::mips:
219 case Triple::mipsel:
220 case Triple::mips64:
221 case Triple::mips64el:
222 // MIPS uses indirect pointer to refer personality functions and types, so
223 // that the eh_frame section can be read-only. DW.ref.personality will be
224 // generated for relocation.
226 // FIXME: The N64 ABI probably ought to use DW_EH_PE_sdata8 but we can't
227 // identify N64 from just a triple.
230
231 // FreeBSD must be explicit about the data size and using pcrel since it's
232 // assembler/linker won't do the automatic conversion that the Linux tools
233 // do.
237 }
238 break;
239 case Triple::ppc64:
240 case Triple::ppc64le:
246 break;
247 case Triple::sparcel:
248 case Triple::sparc:
249 if (isPositionIndependent()) {
255 } else {
259 }
261 break;
262 case Triple::riscv32:
263 case Triple::riscv64:
272 break;
273 case Triple::sparcv9:
275 if (isPositionIndependent()) {
280 } else {
283 }
284 break;
285 case Triple::systemz:
286 // All currently-defined code models guarantee that 4-byte PC-relative
287 // values will be in range.
288 if (isPositionIndependent()) {
294 } else {
298 }
299 break;
307 break;
308 default:
309 break;
310 }
311
313 collectUsedGlobalVariables(M, Vec, false);
314 for (GlobalValue *GV : Vec)
315 if (auto *GO = dyn_cast<GlobalObject>(GV))
316 Used.insert(GO);
317}
318
320 const Module &M) const {
321 auto &C = getContext();
322
324
325 if (NamedMDNode *DependentLibraries = M.getNamedMetadata("llvm.dependent-libraries")) {
326 auto *S = C.getELFSection(".deplibs", ELF::SHT_LLVM_DEPENDENT_LIBRARIES,
328
329 Streamer.switchSection(S);
330
331 for (const auto *Operand : DependentLibraries->operands()) {
332 Streamer.emitBytes(
333 cast<MDString>(cast<MDNode>(Operand)->getOperand(0))->getString());
334 Streamer.emitInt8(0);
335 }
336 }
337
339
340 if (NamedMDNode *LLVMStats = M.getNamedMetadata("llvm.stats")) {
341 // Emit the metadata for llvm statistics into .llvm_stats section, which is
342 // formatted as a list of key/value pair, the value is base64 encoded.
343 auto *S = C.getObjectFileInfo()->getLLVMStatsSection();
344 Streamer.switchSection(S);
345 for (const auto *Operand : LLVMStats->operands()) {
346 const auto *MD = cast<MDNode>(Operand);
347 assert(MD->getNumOperands() % 2 == 0 &&
348 ("Operand num should be even for a list of key/value pair"));
349 for (size_t I = 0; I < MD->getNumOperands(); I += 2) {
350 // Encode the key string size.
351 auto *Key = cast<MDString>(MD->getOperand(I));
352 Streamer.emitULEB128IntValue(Key->getString().size());
353 Streamer.emitBytes(Key->getString());
354 // Encode the value into a Base64 string.
355 std::string Value = encodeBase64(
356 Twine(mdconst::dyn_extract<ConstantInt>(MD->getOperand(I + 1))
357 ->getZExtValue())
358 .str());
359 Streamer.emitULEB128IntValue(Value.size());
360 Streamer.emitBytes(Value);
361 }
362 }
363 }
364
365 unsigned Version = 0;
366 unsigned Flags = 0;
367 StringRef Section;
368
369 GetObjCImageInfo(M, Version, Flags, Section);
370 if (!Section.empty()) {
371 auto *S = C.getELFSection(Section, ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
372 Streamer.switchSection(S);
373 Streamer.emitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
374 Streamer.emitInt32(Version);
375 Streamer.emitInt32(Flags);
376 Streamer.addBlankLine();
377 }
378
380}
381
383 const Module &M) const {
384 auto &C = getContext();
385 if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
386 auto *S = C.getELFSection(".linker-options", ELF::SHT_LLVM_LINKER_OPTIONS,
388
389 Streamer.switchSection(S);
390
391 for (const auto *Operand : LinkerOptions->operands()) {
392 if (cast<MDNode>(Operand)->getNumOperands() != 2)
393 report_fatal_error("invalid llvm.linker.options");
394 for (const auto &Option : cast<MDNode>(Operand)->operands()) {
395 Streamer.emitBytes(cast<MDString>(Option)->getString());
396 Streamer.emitInt8(0);
397 }
398 }
399 }
400}
401
403 const GlobalValue *GV, const TargetMachine &TM,
404 MachineModuleInfo *MMI) const {
405 unsigned Encoding = getPersonalityEncoding();
406 if ((Encoding & 0x80) == DW_EH_PE_indirect)
407 return getContext().getOrCreateSymbol(StringRef("DW.ref.") +
408 TM.getSymbol(GV)->getName());
409 if ((Encoding & 0x70) == DW_EH_PE_absptr)
410 return TM.getSymbol(GV);
411 report_fatal_error("We do not support this DWARF encoding yet!");
412}
413
415 MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym,
416 const MachineModuleInfo *MMI) const {
417 SmallString<64> NameData("DW.ref.");
418 NameData += Sym->getName();
419 auto *Label =
420 static_cast<MCSymbolELF *>(getContext().getOrCreateSymbol(NameData));
421 Streamer.emitSymbolAttribute(Label, MCSA_Hidden);
422 Streamer.emitSymbolAttribute(Label, MCSA_Weak);
423 unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
424 MCSection *Sec = getContext().getELFNamedSection(".data", Label->getName(),
425 ELF::SHT_PROGBITS, Flags, 0);
426 unsigned Size = DL.getPointerSize();
427 Streamer.switchSection(Sec);
428 Streamer.emitValueToAlignment(DL.getPointerABIAlignment(0));
429 Streamer.emitSymbolAttribute(Label, MCSA_ELF_TypeObject);
431 Streamer.emitELFSize(Label, E);
432 Streamer.emitLabel(Label);
433
435}
436
438 MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym,
439 const MachineModuleInfo *MMI) const {
440 Streamer.emitSymbolValue(Sym, DL.getPointerSize());
441}
442
444 const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
446 if (Encoding & DW_EH_PE_indirect) {
448
449 MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", TM);
450
451 // Add information about the stub reference to ELFMMI so that the stub
452 // gets emitted by the asmprinter.
454 if (!StubSym.getPointer()) {
455 MCSymbol *Sym = TM.getSymbol(GV);
457 }
458
461 Encoding & ~DW_EH_PE_indirect, Streamer);
462 }
463
465 MMI, Streamer);
466}
467
469 // N.B.: The defaults used in here are not the same ones used in MC.
470 // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
471 // both gas and MC will produce a section with no flags. Given
472 // section(".eh_frame") gcc will produce:
473 //
474 // .section .eh_frame,"a",@progbits
475
476 if (Name == getInstrProfSectionName(IPSK_covmap, Triple::ELF,
477 /*AddSegmentInfo=*/false) ||
478 Name == getInstrProfSectionName(IPSK_covfun, Triple::ELF,
479 /*AddSegmentInfo=*/false) ||
480 Name == getInstrProfSectionName(IPSK_covdata, Triple::ELF,
481 /*AddSegmentInfo=*/false) ||
482 Name == getInstrProfSectionName(IPSK_covname, Triple::ELF,
483 /*AddSegmentInfo=*/false) ||
484 Name == ".llvmbc" || Name == ".llvmcmd")
486
487 if (!Name.starts_with(".")) return K;
488
489 // Default implementation based on some magic section names.
490 if (Name == ".bss" || Name.starts_with(".bss.") ||
491 Name.starts_with(".gnu.linkonce.b.") ||
492 Name.starts_with(".llvm.linkonce.b.") || Name == ".sbss" ||
493 Name.starts_with(".sbss.") || Name.starts_with(".gnu.linkonce.sb.") ||
494 Name.starts_with(".llvm.linkonce.sb."))
495 return SectionKind::getBSS();
496
497 if (Name == ".tdata" || Name.starts_with(".tdata.") ||
498 Name.starts_with(".gnu.linkonce.td.") ||
499 Name.starts_with(".llvm.linkonce.td."))
501
502 if (Name == ".tbss" || Name.starts_with(".tbss.") ||
503 Name.starts_with(".gnu.linkonce.tb.") ||
504 Name.starts_with(".llvm.linkonce.tb."))
506
507 return K;
508}
509
511 return SectionName.consume_front(Prefix) &&
512 (SectionName.empty() || SectionName[0] == '.');
513}
514
515static unsigned getELFSectionType(StringRef Name, SectionKind K) {
516 // Use SHT_NOTE for section whose name starts with ".note" to allow
517 // emitting ELF notes from C variable declaration.
518 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77609
519 if (Name.starts_with(".note"))
520 return ELF::SHT_NOTE;
521
522 if (hasPrefix(Name, ".init_array"))
523 return ELF::SHT_INIT_ARRAY;
524
525 if (hasPrefix(Name, ".fini_array"))
526 return ELF::SHT_FINI_ARRAY;
527
528 if (hasPrefix(Name, ".preinit_array"))
530
531 if (hasPrefix(Name, ".llvm.offloading"))
533 if (Name == ".llvm.lto")
534 return ELF::SHT_LLVM_LTO;
535
536 if (K.isBSS() || K.isThreadBSS())
537 return ELF::SHT_NOBITS;
538
539 return ELF::SHT_PROGBITS;
540}
541
542static unsigned getELFSectionFlags(SectionKind K, const Triple &T) {
543 unsigned Flags = 0;
544
545 if (!K.isMetadata() && !K.isExclude())
546 Flags |= ELF::SHF_ALLOC;
547
548 if (K.isExclude())
549 Flags |= ELF::SHF_EXCLUDE;
550
551 if (K.isText())
552 Flags |= ELF::SHF_EXECINSTR;
553
554 if (K.isExecuteOnly()) {
555 if (T.isAArch64())
557 else if (T.isARM() || T.isThumb())
558 Flags |= ELF::SHF_ARM_PURECODE;
559 }
560
561 if (K.isWriteable())
562 Flags |= ELF::SHF_WRITE;
563
564 if (K.isThreadLocal())
565 Flags |= ELF::SHF_TLS;
566
567 if (K.isMergeableCString() || K.isMergeableConst())
568 Flags |= ELF::SHF_MERGE;
569
570 if (K.isMergeableCString())
571 Flags |= ELF::SHF_STRINGS;
572
573 return Flags;
574}
575
576MCSection *
578 SectionKind Kind) const {
579 unsigned Type = getELFSectionType(Name, Kind);
580 unsigned Flags = getELFSectionFlags(Kind, getContext().getTargetTriple());
581 return getContext().getELFSection(Name, Type, Flags);
582}
583
584static const Comdat *getELFComdat(const GlobalValue *GV) {
585 const Comdat *C = GV->getComdat();
586 if (!C)
587 return nullptr;
588
589 if (C->getSelectionKind() != Comdat::Any &&
590 C->getSelectionKind() != Comdat::NoDeduplicate)
591 report_fatal_error("ELF COMDATs only support SelectionKind::Any and "
592 "SelectionKind::NoDeduplicate, '" +
593 C->getName() + "' cannot be lowered.");
594
595 return C;
596}
597
599 const TargetMachine &TM) {
600 MDNode *MD = GO->getMetadata(LLVMContext::MD_associated);
601 if (!MD)
602 return nullptr;
603
604 auto *VM = cast<ValueAsMetadata>(MD->getOperand(0).get());
605 auto *OtherGV = dyn_cast<GlobalValue>(VM->getValue());
606 return OtherGV ? static_cast<const MCSymbolELF *>(TM.getSymbol(OtherGV))
607 : nullptr;
608}
609
610static unsigned getEntrySizeForKind(SectionKind Kind) {
611 if (Kind.isMergeable1ByteCString())
612 return 1;
613 else if (Kind.isMergeable2ByteCString())
614 return 2;
615 else if (Kind.isMergeable4ByteCString())
616 return 4;
617 else if (Kind.isMergeableConst4())
618 return 4;
619 else if (Kind.isMergeableConst8())
620 return 8;
621 else if (Kind.isMergeableConst16())
622 return 16;
623 else if (Kind.isMergeableConst32())
624 return 32;
625 else {
626 // We shouldn't have mergeable C strings or mergeable constants that we
627 // didn't handle above.
628 assert(!Kind.isMergeableCString() && "unknown string width");
629 assert(!Kind.isMergeableConst() && "unknown data width");
630 return 0;
631 }
632}
633
634/// Return the section prefix name used by options FunctionsSections and
635/// DataSections.
637 if (Kind.isText())
638 return IsLarge ? ".ltext" : ".text";
639 if (Kind.isReadOnly())
640 return IsLarge ? ".lrodata" : ".rodata";
641 if (Kind.isBSS())
642 return IsLarge ? ".lbss" : ".bss";
643 if (Kind.isThreadData())
644 return ".tdata";
645 if (Kind.isThreadBSS())
646 return ".tbss";
647 if (Kind.isData())
648 return IsLarge ? ".ldata" : ".data";
649 if (Kind.isReadOnlyWithRel())
650 return IsLarge ? ".ldata.rel.ro" : ".data.rel.ro";
651 llvm_unreachable("Unknown section kind");
652}
653
654static SmallString<128>
656 Mangler &Mang, const TargetMachine &TM,
657 bool UniqueSectionName,
658 const MachineJumpTableEntry *JTE) {
659 SmallString<128> Name =
661 unsigned EntrySize = getEntrySizeForKind(Kind);
662 if (Kind.isMergeableCString()) {
663 // We also need alignment here.
664 // FIXME: this is getting the alignment of the character, not the
665 // alignment of the global!
666 Align Alignment = GO->getDataLayout().getPreferredAlign(
668
669 Name += ".str";
670 Name += utostr(EntrySize);
671 Name += ".";
672 Name += utostr(Alignment.value());
673 } else if (Kind.isMergeableConst()) {
674 Name += ".cst";
675 Name += utostr(EntrySize);
676 }
677
678 bool HasPrefix = false;
679 SmallString<32> SectionPrefix;
680 if (const auto *F = dyn_cast<Function>(GO)) {
681 // Jump table hotness takes precedence over its enclosing function's hotness
682 // if it's known. The function's section prefix is used if jump table entry
683 // hotness is unknown.
684 if (JTE && JTE->Hotness != MachineFunctionDataHotness::Unknown) {
685 switch (JTE->Hotness) {
687 raw_svector_ostream(SectionPrefix) << ".unlikely";
688 break;
691 GO->getContext()))
692 raw_svector_ostream(SectionPrefix) << ".hot";
693 break;
694 }
695 default:
696 llvm_unreachable("Unknown jump table hotness");
697 break;
698 }
699 } else if (std::optional<StringRef> Prefix = F->getSectionPrefix())
700 raw_svector_ostream(SectionPrefix) << "." << *Prefix;
701 } else if (const auto *GV = dyn_cast<GlobalVariable>(GO)) {
702 if (std::optional<StringRef> Prefix = GV->getSectionPrefix()) {
703 raw_svector_ostream(SectionPrefix) << "." << *Prefix;
704 }
705 }
706
707 if (!SectionPrefix.empty()) {
708 bool AddSectionPrefix = true;
709 if (Kind.isReadOnly() || Kind.isReadOnlyWithRel() || Kind.isData() ||
710 Kind.isBSS()) {
711 AddSectionPrefix =
713 (!SectionPrefix.starts_with(".hot") ||
715 GO->getContext()));
716 }
717
718 if (AddSectionPrefix) {
719 Name += SectionPrefix;
720 HasPrefix = true;
721 }
722 }
723
724 if (UniqueSectionName) {
725 Name.push_back('.');
726 TM.getNameWithPrefix(Name, GO, Mang, /*MayAlwaysUsePrivate*/true);
727 } else if (HasPrefix)
728 // For distinguishing between .text.${text-section-prefix}. (with trailing
729 // dot) and .text.${function-name}
730 Name.push_back('.');
731 return Name;
732}
733
734namespace {
735class LoweringDiagnosticInfo : public DiagnosticInfo {
736 const Twine &Msg;
737
738public:
739 LoweringDiagnosticInfo(const Twine &DiagMsg LLVM_LIFETIME_BOUND,
740 DiagnosticSeverity Severity = DS_Error)
741 : DiagnosticInfo(DK_Lowering, Severity), Msg(DiagMsg) {}
742 void print(DiagnosticPrinter &DP) const override { DP << Msg; }
743};
744}
745
746/// Calculate an appropriate unique ID for a section, and update Flags,
747/// EntrySize and NextUniqueID where appropriate.
748static unsigned
750 SectionKind Kind, const TargetMachine &TM,
751 MCContext &Ctx, Mangler &Mang, unsigned &Flags,
752 unsigned &EntrySize, unsigned &NextUniqueID,
753 const bool Retain, const bool ForceUnique) {
754 // Increment uniqueID if we are forced to emit a unique section.
755 // This works perfectly fine with section attribute or pragma section as the
756 // sections with the same name are grouped together by the assembler.
757 if (ForceUnique)
758 return NextUniqueID++;
759
760 // A section can have at most one associated section. Put each global with
761 // MD_associated in a unique section.
762 const bool Associated = GO->getMetadata(LLVMContext::MD_associated);
763 if (Associated) {
764 Flags |= ELF::SHF_LINK_ORDER;
765 return NextUniqueID++;
766 }
767
768 if (Retain) {
769 if (TM.getTargetTriple().isOSSolaris())
771 else if (Ctx.getAsmInfo().useIntegratedAssembler() ||
772 Ctx.getAsmInfo().binutilsIsAtLeast(2, 36))
773 Flags |= ELF::SHF_GNU_RETAIN;
774 return NextUniqueID++;
775 }
776
777 // If two symbols with differing sizes end up in the same mergeable section
778 // that section can be assigned an incorrect entry size. To avoid this we
779 // usually put symbols of the same size into distinct mergeable sections with
780 // the same name. Doing so relies on the ",unique ," assembly feature. This
781 // feature is not available until binutils version 2.35
782 // (https://sourceware.org/bugzilla/show_bug.cgi?id=25380).
783 const bool SupportsUnique = Ctx.getAsmInfo().useIntegratedAssembler() ||
784 Ctx.getAsmInfo().binutilsIsAtLeast(2, 35);
785 if (!SupportsUnique) {
786 Flags &= ~ELF::SHF_MERGE;
787 EntrySize = 0;
789 }
790
791 const bool SymbolMergeable = Flags & ELF::SHF_MERGE;
792 const bool SeenSectionNameBefore =
793 Ctx.isELFGenericMergeableSection(SectionName);
794 // If this is the first occurrence of this section name, treat it as the
795 // generic section
796 if (!SymbolMergeable && !SeenSectionNameBefore) {
798 return NextUniqueID++;
799 else
801 }
802
803 // Symbols must be placed into sections with compatible entry sizes. Generate
804 // unique sections for symbols that have not been assigned to compatible
805 // sections.
806 const auto PreviousID =
807 Ctx.getELFUniqueIDForEntsize(SectionName, Flags, EntrySize);
808 if (PreviousID &&
809 (!TM.getSeparateNamedSections() || *PreviousID == MCSection::NonUniqueID))
810 return *PreviousID;
811
812 // If the user has specified the same section name as would be created
813 // implicitly for this symbol e.g. .rodata.str1.1, then we don't need
814 // to unique the section as the entry size for this symbol will be
815 // compatible with implicitly created sections.
816 SmallString<128> ImplicitSectionNameStem =
817 getELFSectionNameForGlobal(GO, Kind, Mang, TM, false, /*MJTE=*/nullptr);
818 if (SymbolMergeable &&
819 Ctx.isELFImplicitMergeableSectionNamePrefix(SectionName) &&
820 SectionName.starts_with(ImplicitSectionNameStem))
822
823 // We have seen this section name before, but with different flags or entity
824 // size. Create a new unique ID.
825 return NextUniqueID++;
826}
827
828static std::tuple<StringRef, bool, unsigned, unsigned, unsigned>
831 StringRef Group = "";
832 bool IsComdat = false;
833 unsigned Flags = 0;
834 if (const Comdat *C = getELFComdat(GO)) {
835 Flags |= ELF::SHF_GROUP;
836 Group = C->getName();
837 IsComdat = C->getSelectionKind() == Comdat::Any;
838 }
839 if (TM.isLargeGlobalValue(GO))
840 Flags |= ELF::SHF_X86_64_LARGE;
841
842 unsigned Type, EntrySize;
843 if (MDNode *MD = GO->getMetadata(LLVMContext::MD_elf_section_properties)) {
844 Type = cast<ConstantAsMetadata>(MD->getOperand(0))
845 ->getValue()
846 ->getUniqueInteger()
847 .getZExtValue();
848 EntrySize = cast<ConstantAsMetadata>(MD->getOperand(1))
849 ->getValue()
850 ->getUniqueInteger()
851 .getZExtValue();
852 } else {
854 EntrySize = getEntrySizeForKind(Kind);
855 }
856
857 return {Group, IsComdat, Flags, Type, EntrySize};
858}
859
861 SectionKind Kind,
862 const TargetMachine &TM,
863 MCContext &Ctx, Mangler &Mang,
864 unsigned &NextUniqueID,
865 bool Retain, bool ForceUnique) {
868
869 // Infer section flags from the section name if we can.
871
872 unsigned Flags = getELFSectionFlags(Kind, GO->getParent()->getTargetTriple());
873 auto [Group, IsComdat, ExtraFlags, Type, EntrySize] =
874 getGlobalObjectInfo(GO, TM, SectionName, Kind);
875 Flags |= ExtraFlags;
876
878 GO, SectionName, Kind, TM, Ctx, Mang, Flags, EntrySize, NextUniqueID,
879 Retain, ForceUnique);
880
881 const MCSymbolELF *LinkedToSym = getLinkedToSymbol(GO, TM);
882 MCSectionELF *Section =
883 Ctx.getELFSection(SectionName, Type, Flags, EntrySize, Group, IsComdat,
884 UniqueID, LinkedToSym);
885 // Make sure that we did not get some other section with incompatible sh_link.
886 // This should not be possible due to UniqueID code above.
887 assert(Section->getLinkedToSymbol() == LinkedToSym &&
888 "Associated symbol mismatch between sections");
889
890 if (!(Ctx.getAsmInfo().useIntegratedAssembler() ||
891 Ctx.getAsmInfo().binutilsIsAtLeast(2, 35))) {
892 // If we are using GNU as before 2.35, then this symbol might have
893 // been placed in an incompatible mergeable section. Emit an error if this
894 // is the case to avoid creating broken output.
895 if ((Section->getFlags() & ELF::SHF_MERGE) &&
896 (Section->getEntrySize() != getEntrySizeForKind(Kind)))
897 GO->getContext().diagnose(LoweringDiagnosticInfo(
898 "Symbol '" + GO->getName() + "' from module '" +
899 (GO->getParent() ? GO->getParent()->getSourceFileName() : "unknown") +
900 "' required a section with entry-size=" +
901 Twine(getEntrySizeForKind(Kind)) + " but was placed in section '" +
902 SectionName + "' with entry-size=" + Twine(Section->getEntrySize()) +
903 ": Explicit assignment by pragma or attribute of an incompatible "
904 "symbol to this section?"));
905 }
906
907 return Section;
908}
909
911 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
913 NextUniqueID, Used.count(GO),
914 /* ForceUnique = */false);
915}
916
918 MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
919 const TargetMachine &TM, bool EmitUniqueSection, unsigned Flags,
920 unsigned *NextUniqueID, const MCSymbolELF *AssociatedSymbol,
921 const MachineJumpTableEntry *MJTE = nullptr) {
922 bool UniqueSectionName = false;
924 if (EmitUniqueSection) {
925 if (TM.getUniqueSectionNames()) {
926 UniqueSectionName = true;
927 } else {
928 UniqueID = *NextUniqueID;
929 (*NextUniqueID)++;
930 }
931 }
932 SmallString<128> Name =
933 getELFSectionNameForGlobal(GO, Kind, Mang, TM, UniqueSectionName, MJTE);
934
935 auto [Group, IsComdat, ExtraFlags, Type, EntrySize] =
936 getGlobalObjectInfo(GO, TM, Name, Kind);
937 Flags |= ExtraFlags;
938
939 // Use 0 as the unique ID for execute-only text.
940 if (Kind.isExecuteOnly())
941 UniqueID = 0;
942 return Ctx.getELFSection(Name, Type, Flags, EntrySize, Group, IsComdat,
943 UniqueID, AssociatedSymbol);
944}
945
947 MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
948 const TargetMachine &TM, bool Retain, bool EmitUniqueSection,
949 unsigned Flags, unsigned *NextUniqueID) {
950 const MCSymbolELF *LinkedToSym = getLinkedToSymbol(GO, TM);
951 if (LinkedToSym) {
952 EmitUniqueSection = true;
953 Flags |= ELF::SHF_LINK_ORDER;
954 }
955 if (Retain) {
956 if (TM.getTargetTriple().isOSSolaris()) {
957 EmitUniqueSection = true;
959 } else if (Ctx.getAsmInfo().useIntegratedAssembler() ||
960 Ctx.getAsmInfo().binutilsIsAtLeast(2, 36)) {
961 EmitUniqueSection = true;
962 Flags |= ELF::SHF_GNU_RETAIN;
963 }
964 }
965 if (GO->hasMetadata(LLVMContext::MD_elf_section_properties))
966 EmitUniqueSection = true;
967
969 Ctx, GO, Kind, Mang, TM, EmitUniqueSection, Flags,
970 NextUniqueID, LinkedToSym);
971 assert(Section->getLinkedToSymbol() == LinkedToSym);
972 return Section;
973}
974
976 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
977 unsigned Flags = getELFSectionFlags(Kind, GO->getParent()->getTargetTriple());
978
979 // If we have -ffunction-section or -fdata-section then we should emit the
980 // global value to a uniqued section specifically for it.
981 bool EmitUniqueSection = false;
982 if (!(Flags & ELF::SHF_MERGE) && !Kind.isCommon()) {
983 if (Kind.isText())
984 EmitUniqueSection = TM.getFunctionSections();
985 else
986 EmitUniqueSection = TM.getDataSections();
987 }
988 EmitUniqueSection |= GO->hasComdat();
989 return selectELFSectionForGlobal(getContext(), GO, Kind, getMangler(), TM,
990 Used.count(GO), EmitUniqueSection, Flags,
991 &NextUniqueID);
992}
993
995 const Function &F, const TargetMachine &TM) const {
997 unsigned Flags = getELFSectionFlags(Kind, F.getParent()->getTargetTriple());
998 // If the function's section names is pre-determined via pragma or a
999 // section attribute, call selectExplicitSectionGlobal.
1000 if (F.hasSection())
1002 &F, Kind, TM, getContext(), getMangler(), NextUniqueID,
1003 Used.count(&F), /* ForceUnique = */true);
1004
1006 getContext(), &F, Kind, getMangler(), TM, Used.count(&F),
1007 /*EmitUniqueSection=*/true, Flags, &NextUniqueID);
1008}
1009
1011 const Function &F, const TargetMachine &TM) const {
1012 return getSectionForJumpTable(F, TM, /*JTE=*/nullptr);
1013}
1014
1016 const Function &F, const TargetMachine &TM,
1017 const MachineJumpTableEntry *JTE) const {
1018 // If the function can be removed, produce a unique section so that
1019 // the table doesn't prevent the removal.
1020 const Comdat *C = F.getComdat();
1021 bool EmitUniqueSection = TM.getFunctionSections() || C;
1022 if (!EmitUniqueSection && !TM.getEnableStaticDataPartitioning())
1023 return ReadOnlySection;
1024
1026 getMangler(), TM, EmitUniqueSection,
1027 ELF::SHF_ALLOC, &NextUniqueID,
1028 /* AssociatedSymbol */ nullptr, JTE);
1029}
1030
1032 const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const {
1033 // If neither COMDAT nor function sections, use the monolithic LSDA section.
1034 // Re-use this path if LSDASection is null as in the Arm EHABI.
1035 if (!LSDASection || (!F.hasComdat() && !TM.getFunctionSections()))
1036 return LSDASection;
1037
1038 const auto *LSDA = static_cast<const MCSectionELF *>(LSDASection);
1039 unsigned Flags = LSDA->getFlags();
1040 const MCSymbolELF *LinkedToSym = nullptr;
1041 StringRef Group;
1042 bool IsComdat = false;
1043 if (const Comdat *C = getELFComdat(&F)) {
1044 Flags |= ELF::SHF_GROUP;
1045 Group = C->getName();
1046 IsComdat = C->getSelectionKind() == Comdat::Any;
1047 }
1048 // Use SHF_LINK_ORDER to facilitate --gc-sections if we can use GNU ld>=2.36
1049 // or LLD, which support mixed SHF_LINK_ORDER & non-SHF_LINK_ORDER.
1050 if (TM.getFunctionSections() &&
1051 (getContext().getAsmInfo().useIntegratedAssembler() &&
1052 getContext().getAsmInfo().binutilsIsAtLeast(2, 36))) {
1053 Flags |= ELF::SHF_LINK_ORDER;
1054 LinkedToSym = static_cast<const MCSymbolELF *>(&FnSym);
1055 }
1056
1057 // Append the function name as the suffix like GCC, assuming
1058 // -funique-section-names applies to .gcc_except_table sections.
1059 return getContext().getELFSection(
1060 (TM.getUniqueSectionNames() ? LSDA->getName() + "." + F.getName()
1061 : LSDA->getName()),
1062 LSDA->getType(), Flags, 0, Group, IsComdat, MCSection::NonUniqueID,
1063 LinkedToSym);
1064}
1065
1067 bool UsesLabelDifference, const Function &F) const {
1068 // We can always create relative relocations, so use another section
1069 // that can be marked non-executable.
1070 return false;
1071}
1072
1073/// Given a mergeable constant with the specified size and relocation
1074/// information, return a section that it should be placed in.
1076 SectionKind Kind,
1077 const Constant *C) const {
1078 if (!TM)
1079 return false;
1080 if (TM->getCodeModel() == CodeModel::Large)
1081 return TM->getTargetTriple().getArch() == Triple::x86_64;
1082 if (Kind.isMergeableCString() && C) {
1083 assert(C->getType()->isSized());
1084 return TM->isLargeDataSize(DL.getTypeAllocSize(C->getType()));
1085 }
1086 // Globals generated by the compiler, e.g. constant pool entries, are always
1087 // small under the x86-64 medium code model.
1088 return false;
1089}
1090
1092 const DataLayout &DL, SectionKind Kind, const Constant *C,
1093 StringRef SectionSuffix) const {
1094 auto &Context = getContext();
1095 unsigned MergeableCstFlags = ELF::SHF_ALLOC;
1096 if (Kind.isMergeableConst() || Kind.isMergeableCString())
1097 MergeableCstFlags |= ELF::SHF_MERGE;
1098 bool IsLarge = isLargeConstant(DL, Kind, C);
1099 if (IsLarge)
1100 MergeableCstFlags |= ELF::SHF_X86_64_LARGE;
1101
1102 StringRef CstPrefix = IsLarge ? ".lrodata" : ".rodata";
1103 SmallString<32> SectionSuffixStr;
1104 if (!SectionSuffix.empty()) {
1105 SectionSuffixStr.push_back('.');
1106 SectionSuffixStr += SectionSuffix;
1107 SectionSuffixStr.push_back('.');
1108 }
1109
1110 if (Kind.isMergeableConst4())
1111 return Context.getELFSection(CstPrefix + ".cst4" + SectionSuffixStr,
1112 ELF::SHT_PROGBITS, MergeableCstFlags, 4);
1113 if (Kind.isMergeableConst8())
1114 return Context.getELFSection(CstPrefix + ".cst8" + SectionSuffixStr,
1115 ELF::SHT_PROGBITS, MergeableCstFlags, 8);
1116 if (Kind.isMergeableConst16())
1117 return Context.getELFSection(CstPrefix + ".cst16" + SectionSuffixStr,
1118 ELF::SHT_PROGBITS, MergeableCstFlags, 16);
1119 if (Kind.isMergeableConst32())
1120 return Context.getELFSection(CstPrefix + ".cst32" + SectionSuffixStr,
1121 ELF::SHT_PROGBITS, MergeableCstFlags, 32);
1122 if (Kind.isReadOnly())
1123 return Context.getELFSection(
1124 CstPrefix + SectionSuffixStr, ELF::SHT_PROGBITS,
1125 ELF::SHF_ALLOC | (IsLarge ? ELF::SHF_X86_64_LARGE : 0));
1126
1127 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
1128 return Context.getELFSection(".data.rel.ro" + SectionSuffixStr,
1131}
1132
1134 const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment,
1135 const Function *F) const {
1136 return getSectionForConstantImpl(DL, Kind, C, "");
1137}
1138
1140 const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment,
1141 const Function *F, StringRef SectionSuffix) const {
1142 if (SectionSuffix.empty())
1143 return getSectionForConstant(DL, Kind, C, Alignment, F);
1144
1145 return getSectionForConstantImpl(DL, Kind, C, SectionSuffix);
1146}
1147
1148/// Returns a unique section for the given machine basic block.
1150 const Function &F, const MachineBasicBlock &MBB,
1151 const TargetMachine &TM) const {
1152 assert(MBB.isBeginSection() && "Basic block does not start a section!");
1154
1155 // For cold sections use the .text.split. prefix along with the parent
1156 // function name. All cold blocks for the same function go to the same
1157 // section. Similarly all exception blocks are grouped by symbol name
1158 // under the .text.eh prefix. For regular sections, we either use a unique
1159 // name, or a unique ID for the section.
1160 SmallString<128> Name;
1161 StringRef FunctionSectionName = MBB.getParent()->getSection()->getName();
1162 if (FunctionSectionName == ".text" ||
1163 FunctionSectionName.starts_with(".text.")) {
1164 // Function is in a regular .text section.
1165 StringRef FunctionName = MBB.getParent()->getName();
1166 if (MBB.getSectionID() == MBBSectionID::ColdSectionID) {
1168 Name += FunctionName;
1169 } else if (MBB.getSectionID() == MBBSectionID::ExceptionSectionID) {
1170 Name += ".text.eh.";
1171 Name += FunctionName;
1172 } else {
1173 Name += FunctionSectionName;
1174 if (TM.getUniqueBasicBlockSectionNames()) {
1175 if (!Name.ends_with("."))
1176 Name += ".";
1177 Name += MBB.getSymbol()->getName();
1178 } else {
1179 UniqueID = NextUniqueID++;
1180 }
1181 }
1182 } else {
1183 // If the original function has a custom non-dot-text section, then emit
1184 // all basic block sections into that section too, each with a unique id.
1185 Name = FunctionSectionName;
1186 UniqueID = NextUniqueID++;
1187 }
1188
1189 unsigned Flags =
1190 static_cast<const MCSectionELF *>(MBB.getParent()->getSection())
1191 ->getFlags();
1192 std::string GroupName;
1193 if (F.hasComdat()) {
1194 Flags |= ELF::SHF_GROUP;
1195 GroupName = F.getComdat()->getName().str();
1196 }
1197 return getContext().getELFSection(Name, ELF::SHT_PROGBITS, Flags,
1198 0 /* Entry Size */, GroupName,
1199 F.hasComdat(), UniqueID, nullptr);
1200}
1201
1202static MCSectionELF *getStaticStructorSection(MCContext &Ctx, bool UseInitArray,
1203 bool IsCtor, unsigned Priority,
1204 const MCSymbol *KeySym) {
1205 std::string Name;
1206 unsigned Type;
1207 unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE;
1208 StringRef Comdat = KeySym ? KeySym->getName() : "";
1209
1210 if (KeySym)
1211 Flags |= ELF::SHF_GROUP;
1212
1213 if (UseInitArray) {
1214 if (IsCtor) {
1216 Name = ".init_array";
1217 } else {
1219 Name = ".fini_array";
1220 }
1221 if (Priority != 65535) {
1222 Name += '.';
1223 Name += utostr(Priority);
1224 }
1225 } else {
1226 // The default scheme is .ctor / .dtor, so we have to invert the priority
1227 // numbering.
1228 if (IsCtor)
1229 Name = ".ctors";
1230 else
1231 Name = ".dtors";
1232 if (Priority != 65535)
1233 raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
1235 }
1236
1237 return Ctx.getELFSection(Name, Type, Flags, 0, Comdat, /*IsComdat=*/true);
1238}
1239
1241 unsigned Priority, const MCSymbol *KeySym) const {
1242 return getStaticStructorSection(getContext(), UseInitArray, true, Priority,
1243 KeySym);
1244}
1245
1247 unsigned Priority, const MCSymbol *KeySym) const {
1248 return getStaticStructorSection(getContext(), UseInitArray, false, Priority,
1249 KeySym);
1250}
1251
1253 const MCSymbol *LHS, const MCSymbol *RHS, int64_t Addend,
1254 std::optional<int64_t> PCRelativeOffset) const {
1255 auto &Ctx = getContext();
1256 const MCExpr *Res;
1257 // Return a relocatable expression with the PLT specifier, %plt(GV) or
1258 // %plt(GV-RHS).
1259 if (PCRelativeOffset && PLTPCRelativeSpecifier) {
1260 Res = MCSymbolRefExpr::create(LHS, Ctx);
1261 // The current location is RHS plus *PCRelativeOffset. Compensate for it.
1262 Addend += *PCRelativeOffset;
1263 if (Addend)
1264 Res = MCBinaryExpr::createAdd(Res, MCConstantExpr::create(Addend, Ctx),
1265 Ctx);
1267 }
1268
1270 return nullptr;
1273 MCSymbolRefExpr::create(RHS, Ctx), Ctx);
1274 if (Addend)
1275 Res =
1276 MCBinaryExpr::createAdd(Res, MCConstantExpr::create(Addend, Ctx), Ctx);
1277 return Res;
1278}
1279
1280// Reference the PLT entry of a function, optionally with a subtrahend (`RHS`).
1282 const MCSymbol *LHS, const MCSymbol *RHS, int64_t Addend,
1283 std::optional<int64_t> PCRelativeOffset, const TargetMachine &TM) const {
1284 if (RHS)
1285 return lowerSymbolDifference(LHS, RHS, Addend, PCRelativeOffset);
1286
1287 // Only the legacy MCSymbolRefExpr::VariantKind approach is implemented.
1288 // Reference LHS@plt or LHS@plt - RHS.
1291 return nullptr;
1292}
1293
1295 // Use ".GCC.command.line" since this feature is to support clang's
1296 // -frecord-gcc-switches which in turn attempts to mimic GCC's switch of the
1297 // same name.
1298 return getContext().getELFSection(".GCC.command.line", ELF::SHT_PROGBITS,
1300}
1301
1302void
1304 UseInitArray = UseInitArray_;
1305 MCContext &Ctx = getContext();
1306 if (!UseInitArray) {
1307 StaticCtorSection = Ctx.getELFSection(".ctors", ELF::SHT_PROGBITS,
1309
1310 StaticDtorSection = Ctx.getELFSection(".dtors", ELF::SHT_PROGBITS,
1312 return;
1313 }
1314
1315 StaticCtorSection = Ctx.getELFSection(".init_array", ELF::SHT_INIT_ARRAY,
1317 StaticDtorSection = Ctx.getELFSection(".fini_array", ELF::SHT_FINI_ARRAY,
1319}
1320
1321//===----------------------------------------------------------------------===//
1322// MachO
1323//===----------------------------------------------------------------------===//
1324
1328
1330 const TargetMachine &TM,
1331 const Module &M) {
1333 if (TM.getRelocationModel() == Reloc::Static) {
1334 StaticCtorSection = Ctx.getMachOSection("__TEXT", "__constructor", 0,
1336 StaticDtorSection = Ctx.getMachOSection("__TEXT", "__destructor", 0,
1338 } else {
1339 StaticCtorSection = Ctx.getMachOSection("__DATA", "__mod_init_func",
1342 StaticDtorSection = Ctx.getMachOSection("__DATA", "__mod_term_func",
1345 }
1346
1352}
1353
1355 unsigned Priority, const MCSymbol *KeySym) const {
1356 return StaticDtorSection;
1357 // In userspace, we lower global destructors via atexit(), but kernel/kext
1358 // environments do not provide this function so we still need to support the
1359 // legacy way here.
1360 // See the -disable-atexit-based-global-dtor-lowering CodeGen flag for more
1361 // context.
1362}
1363
1365 const Module &M) const {
1366 // Emit the linker options if present.
1368
1370
1371 unsigned VersionVal = 0;
1372 unsigned ImageInfoFlags = 0;
1373 StringRef SectionVal;
1374
1375 GetObjCImageInfo(M, VersionVal, ImageInfoFlags, SectionVal);
1377
1378 // The section is mandatory. If we don't have it, then we don't have GC info.
1379 if (SectionVal.empty())
1380 return;
1381
1382 StringRef Segment, Section;
1383 unsigned TAA = 0, StubSize = 0;
1384 bool TAAParsed;
1386 SectionVal, Segment, Section, TAA, TAAParsed, StubSize)) {
1387 // If invalid, report the error with report_fatal_error.
1388 report_fatal_error("Invalid section specifier '" + Section +
1389 "': " + toString(std::move(E)) + ".");
1390 }
1391
1392 // Get the section.
1394 Segment, Section, TAA, StubSize, SectionKind::getData());
1395 Streamer.switchSection(S);
1396 Streamer.emitLabel(getContext().
1397 getOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
1398 Streamer.emitInt32(VersionVal);
1399 Streamer.emitInt32(ImageInfoFlags);
1400 Streamer.addBlankLine();
1401}
1402
1403MCSection *
1405 SectionKind Kind) const {
1406 auto [Segment, SecName] = Name.split(',');
1407 return getContext().getMachOSection(Segment, SecName, 0, Kind);
1408}
1409
1411 MCStreamer &Streamer, const Module &M) const {
1412 if (auto *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
1413 for (const auto *Option : LinkerOptions->operands()) {
1414 SmallVector<std::string, 4> StrOptions;
1415 for (const auto &Piece : cast<MDNode>(Option)->operands())
1416 StrOptions.push_back(std::string(cast<MDString>(Piece)->getString()));
1417 Streamer.emitLinkerOptions(StrOptions);
1418 }
1419 }
1420}
1421
1422static void checkMachOComdat(const GlobalValue *GV) {
1423 const Comdat *C = GV->getComdat();
1424 if (!C)
1425 return;
1426
1427 report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() +
1428 "' cannot be lowered.");
1429}
1430
1432 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1433
1436
1437 // Parse the section specifier and create it if valid.
1438 StringRef Segment, Section;
1439 unsigned TAA = 0, StubSize = 0;
1440 bool TAAParsed;
1441
1442 checkMachOComdat(GO);
1443
1445 SectionName, Segment, Section, TAA, TAAParsed, StubSize)) {
1446 // If invalid, report the error with report_fatal_error.
1447 report_fatal_error("Global variable '" + GO->getName() +
1448 "' has an invalid section specifier '" +
1449 GO->getSection() + "': " + toString(std::move(E)) + ".");
1450 }
1451
1452 // Get the section.
1453 MCSectionMachO *S =
1454 getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
1455
1456 // If TAA wasn't set by ParseSectionSpecifier() above,
1457 // use the value returned by getMachOSection() as a default.
1458 if (!TAAParsed)
1459 TAA = S->getTypeAndAttributes();
1460
1461 // Okay, now that we got the section, verify that the TAA & StubSize agree.
1462 // If the user declared multiple globals with different section flags, we need
1463 // to reject it here.
1464 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
1465 // If invalid, report the error with report_fatal_error.
1466 report_fatal_error("Global variable '" + GO->getName() +
1467 "' section type or attributes does not match previous"
1468 " section specifier");
1469 }
1470
1471 return S;
1472}
1473
1475 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1476 checkMachOComdat(GO);
1477
1478 // Handle thread local data.
1479 if (Kind.isThreadBSS()) return TLSBSSSection;
1480 if (Kind.isThreadData()) return TLSDataSection;
1481
1482 if (Kind.isText())
1484
1485 // If this is weak/linkonce, put this in a coalescable section, either in text
1486 // or data depending on if it is writable.
1487 if (GO->isWeakForLinker()) {
1488 if (Kind.isReadOnly())
1489 return ConstTextCoalSection;
1490 if (Kind.isReadOnlyWithRel())
1491 return ConstDataCoalSection;
1492 return DataCoalSection;
1493 }
1494
1495 // FIXME: Alignment check should be handled by section classifier.
1496 if (Kind.isMergeable1ByteCString() &&
1498 cast<GlobalVariable>(GO)) < Align(32))
1499 return CStringSection;
1500
1501 // Do not put 16-bit arrays in the UString section if they have an
1502 // externally visible label, this runs into issues with certain linker
1503 // versions.
1504 if (Kind.isMergeable2ByteCString() && !GO->hasExternalLinkage() &&
1506 cast<GlobalVariable>(GO)) < Align(32))
1507 return UStringSection;
1508
1509 // With MachO only variables whose corresponding symbol starts with 'l' or
1510 // 'L' can be merged, so we only try merging GVs with private linkage.
1511 if (GO->hasPrivateLinkage() && Kind.isMergeableConst()) {
1512 if (Kind.isMergeableConst4())
1514 if (Kind.isMergeableConst8())
1516 if (Kind.isMergeableConst16())
1518 }
1519
1520 // Otherwise, if it is readonly, but not something we can specially optimize,
1521 // just drop it in .const.
1522 if (Kind.isReadOnly())
1523 return ReadOnlySection;
1524
1525 // If this is marked const, put it into a const section. But if the dynamic
1526 // linker needs to write to it, put it in the data segment.
1527 if (Kind.isReadOnlyWithRel())
1528 return ConstDataSection;
1529
1530 // Put zero initialized globals with strong external linkage in the
1531 // DATA, __common section with the .zerofill directive.
1532 if (Kind.isBSSExtern())
1533 return DataCommonSection;
1534
1535 // Put zero initialized globals with local linkage in __DATA,__bss directive
1536 // with the .zerofill directive (aka .lcomm).
1537 if (Kind.isBSSLocal())
1538 return DataBSSSection;
1539
1540 // Otherwise, just drop the variable in the normal data section.
1541 return DataSection;
1542}
1543
1545 const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment,
1546 const Function *F) const {
1547 // If this constant requires a relocation, we have to put it in the data
1548 // segment, not in the text segment.
1549 if (Kind.isData() || Kind.isReadOnlyWithRel())
1550 return ConstDataSection;
1551
1552 if (Kind.isMergeableConst4())
1554 if (Kind.isMergeableConst8())
1556 if (Kind.isMergeableConst16())
1558 return ReadOnlySection; // .const
1559}
1560
1565
1567 const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
1568 MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1569 // The mach-o version of this method defaults to returning a stub reference.
1570
1571 if (Encoding & DW_EH_PE_indirect) {
1572 MachineModuleInfoMachO &MachOMMI =
1574
1575 MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
1576
1577 // Add information about the stub reference to MachOMMI so that the stub
1578 // gets emitted by the asmprinter.
1579 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
1580 if (!StubSym.getPointer()) {
1581 MCSymbol *Sym = TM.getSymbol(GV);
1583 }
1584
1587 Encoding & ~DW_EH_PE_indirect, Streamer);
1588 }
1589
1591 MMI, Streamer);
1592}
1593
1595 const GlobalValue *GV, const TargetMachine &TM,
1596 MachineModuleInfo *MMI) const {
1597 // The mach-o version of this method defaults to returning a stub reference.
1598 MachineModuleInfoMachO &MachOMMI =
1600
1601 MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
1602
1603 // Add information about the stub reference to MachOMMI so that the stub
1604 // gets emitted by the asmprinter.
1605 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
1606 if (!StubSym.getPointer()) {
1607 MCSymbol *Sym = TM.getSymbol(GV);
1609 }
1610
1611 return SSym;
1612}
1613
1615 const GlobalValue *GV, const MCSymbol *Sym, const MCValue &MV,
1616 int64_t Offset, MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1617 // Although MachO 32-bit targets do not explicitly have a GOTPCREL relocation
1618 // as 64-bit do, we replace the GOT equivalent by accessing the final symbol
1619 // through a non_lazy_ptr stub instead. One advantage is that it allows the
1620 // computation of deltas to final external symbols. Example:
1621 //
1622 // _extgotequiv:
1623 // .long _extfoo
1624 //
1625 // _delta:
1626 // .long _extgotequiv-_delta
1627 //
1628 // is transformed to:
1629 //
1630 // _delta:
1631 // .long L_extfoo$non_lazy_ptr-(_delta+0)
1632 //
1633 // .section __IMPORT,__pointers,non_lazy_symbol_pointers
1634 // L_extfoo$non_lazy_ptr:
1635 // .indirect_symbol _extfoo
1636 // .long 0
1637 //
1638 // The indirect symbol table (and sections of non_lazy_symbol_pointers type)
1639 // may point to both local (same translation unit) and global (other
1640 // translation units) symbols. Example:
1641 //
1642 // .section __DATA,__pointers,non_lazy_symbol_pointers
1643 // L1:
1644 // .indirect_symbol _myGlobal
1645 // .long 0
1646 // L2:
1647 // .indirect_symbol _myLocal
1648 // .long _myLocal
1649 //
1650 // If the symbol is local, instead of the symbol's index, the assembler
1651 // places the constant INDIRECT_SYMBOL_LOCAL into the indirect symbol table.
1652 // Then the linker will notice the constant in the table and will look at the
1653 // content of the symbol.
1654 MachineModuleInfoMachO &MachOMMI =
1656 MCContext &Ctx = getContext();
1657
1658 // The offset must consider the original displacement from the base symbol
1659 // since 32-bit targets don't have a GOTPCREL to fold the PC displacement.
1660 Offset = -MV.getConstant();
1661 const MCSymbol *BaseSym = MV.getSubSym();
1662
1663 // Access the final symbol via sym$non_lazy_ptr and generate the appropriated
1664 // non_lazy_ptr stubs.
1665 SmallString<128> Name;
1666 StringRef Suffix = "$non_lazy_ptr";
1668 Name += Sym->getName();
1669 Name += Suffix;
1670 MCSymbol *Stub = Ctx.getOrCreateSymbol(Name);
1671
1672 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Stub);
1673
1674 if (!StubSym.getPointer())
1675 StubSym = MachineModuleInfoImpl::StubValueTy(const_cast<MCSymbol *>(Sym),
1676 !GV->hasLocalLinkage());
1677
1678 const MCExpr *BSymExpr = MCSymbolRefExpr::create(BaseSym, Ctx);
1679 const MCExpr *LHS = MCSymbolRefExpr::create(Stub, Ctx);
1680
1681 if (!Offset)
1682 return MCBinaryExpr::createSub(LHS, BSymExpr, Ctx);
1683
1684 const MCExpr *RHS =
1686 return MCBinaryExpr::createSub(LHS, RHS, Ctx);
1687}
1688
1689static bool canUsePrivateLabel(const MCAsmInfo &AsmInfo,
1690 const MCSection &Section) {
1692 return true;
1693
1694 // FIXME: we should be able to use private labels for sections that can't be
1695 // dead-stripped (there's no issue with blocking atomization there), but `ld
1696 // -r` sometimes drops the no_dead_strip attribute from sections so for safety
1697 // we don't allow it.
1698 return false;
1699}
1700
1702 SmallVectorImpl<char> &OutName, const GlobalValue *GV,
1703 const TargetMachine &TM) const {
1704 bool CannotUsePrivateLabel = true;
1705 if (auto *GO = GV->getAliaseeObject()) {
1707 const MCSection *TheSection = SectionForGlobal(GO, GOKind, TM);
1708 CannotUsePrivateLabel = !canUsePrivateLabel(TM.getMCAsmInfo(), *TheSection);
1709 }
1710 getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
1711}
1712
1713//===----------------------------------------------------------------------===//
1714// COFF
1715//===----------------------------------------------------------------------===//
1716
1717static unsigned
1719 unsigned Flags = 0;
1721
1722 if (K.isMetadata())
1723 Flags |=
1725 else if (K.isExclude())
1726 Flags |=
1728 else if (K.isText())
1729 Flags |=
1734 else if (K.isBSS())
1735 Flags |=
1739 else if (K.isThreadLocal())
1740 Flags |=
1744 else if (K.isReadOnly() || K.isReadOnlyWithRel())
1745 Flags |=
1748 else if (K.isWriteable())
1749 Flags |=
1753
1754 return Flags;
1755}
1756
1758 const Comdat *C = GV->getComdat();
1759 assert(C && "expected GV to have a Comdat!");
1760
1761 StringRef ComdatGVName = C->getName();
1762 const GlobalValue *ComdatGV = GV->getParent()->getNamedValue(ComdatGVName);
1763 if (!ComdatGV)
1764 report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
1765 "' does not exist.");
1766
1767 if (ComdatGV->getComdat() != C)
1768 report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
1769 "' is not a key for its COMDAT.");
1770
1771 return ComdatGV;
1772}
1773
1774static int getSelectionForCOFF(const GlobalValue *GV) {
1775 if (const Comdat *C = GV->getComdat()) {
1776 const GlobalValue *ComdatKey = getComdatGVForCOFF(GV);
1777 if (const auto *GA = dyn_cast<GlobalAlias>(ComdatKey))
1778 ComdatKey = GA->getAliaseeObject();
1779 if (ComdatKey == GV) {
1780 switch (C->getSelectionKind()) {
1781 case Comdat::Any:
1783 case Comdat::ExactMatch:
1785 case Comdat::Largest:
1789 case Comdat::SameSize:
1791 }
1792 } else {
1794 }
1795 }
1796 return 0;
1797}
1798
1800 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1802 if (Name == getInstrProfSectionName(IPSK_covmap, Triple::COFF,
1803 /*AddSegmentInfo=*/false) ||
1804 Name == getInstrProfSectionName(IPSK_covfun, Triple::COFF,
1805 /*AddSegmentInfo=*/false) ||
1806 Name == getInstrProfSectionName(IPSK_covdata, Triple::COFF,
1807 /*AddSegmentInfo=*/false) ||
1808 Name == getInstrProfSectionName(IPSK_covname, Triple::COFF,
1809 /*AddSegmentInfo=*/false) ||
1810 Name == ".llvmbc" || Name == ".llvmcmd")
1811 Kind = SectionKind::getMetadata();
1812 int Selection = 0;
1813 unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1814 StringRef COMDATSymName = "";
1815 if (GO->hasComdat()) {
1817 const GlobalValue *ComdatGV;
1819 ComdatGV = getComdatGVForCOFF(GO);
1820 else
1821 ComdatGV = GO;
1822
1823 if (!ComdatGV->hasPrivateLinkage()) {
1824 MCSymbol *Sym = TM.getSymbol(ComdatGV);
1825 COMDATSymName = Sym->getName();
1826 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1827 } else {
1828 Selection = 0;
1829 }
1830 }
1831
1832 return getContext().getCOFFSection(Name, Characteristics, COMDATSymName,
1833 Selection);
1834}
1835
1837 if (Kind.isText())
1838 return ".text";
1839 if (Kind.isBSS())
1840 return ".bss";
1841 if (Kind.isThreadLocal())
1842 return ".tls$";
1843 if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
1844 return ".rdata";
1845 return ".data";
1846}
1847
1849 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1850 // If we have -ffunction-sections then we should emit the global value to a
1851 // uniqued section specifically for it.
1852 bool EmitUniquedSection;
1853 if (Kind.isText())
1854 EmitUniquedSection = TM.getFunctionSections();
1855 else
1856 EmitUniquedSection = TM.getDataSections();
1857
1858 if ((EmitUniquedSection && !Kind.isCommon()) || GO->hasComdat()) {
1860
1861 unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1862
1863 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1865 if (!Selection)
1867 const GlobalValue *ComdatGV;
1868 if (GO->hasComdat())
1869 ComdatGV = getComdatGVForCOFF(GO);
1870 else
1871 ComdatGV = GO;
1872
1874 if (EmitUniquedSection)
1875 UniqueID = NextUniqueID++;
1876
1877 if (!ComdatGV->hasPrivateLinkage()) {
1878 MCSymbol *Sym = TM.getSymbol(ComdatGV);
1879 StringRef COMDATSymName = Sym->getName();
1880
1881 if (const auto *F = dyn_cast<Function>(GO))
1882 if (std::optional<StringRef> Prefix = F->getSectionPrefix())
1883 raw_svector_ostream(Name) << '$' << *Prefix;
1884
1885 // Append "$symbol" to the section name *before* IR-level mangling is
1886 // applied when targetting mingw. This is what GCC does, and the ld.bfd
1887 // COFF linker will not properly handle comdats otherwise.
1888 if (getContext().getTargetTriple().isOSCygMing())
1889 raw_svector_ostream(Name) << '$' << ComdatGV->getName();
1890
1891 return getContext().getCOFFSection(Name, Characteristics, COMDATSymName,
1893 } else {
1894 SmallString<256> TmpData;
1895 getMangler().getNameWithPrefix(TmpData, GO, /*CannotUsePrivateLabel=*/true);
1896 return getContext().getCOFFSection(Name, Characteristics, TmpData,
1898 }
1899 }
1900
1901 if (Kind.isText())
1902 return TextSection;
1903
1904 if (Kind.isThreadLocal())
1905 return TLSDataSection;
1906
1907 if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
1908 return ReadOnlySection;
1909
1910 // Note: we claim that common symbols are put in BSSSection, but they are
1911 // really emitted with the magic .comm directive, which creates a symbol table
1912 // entry but not a section.
1913 if (Kind.isBSS() || Kind.isCommon())
1914 return BSSSection;
1915
1916 return DataSection;
1917}
1918
1920 SmallVectorImpl<char> &OutName, const GlobalValue *GV,
1921 const TargetMachine &TM) const {
1922 bool CannotUsePrivateLabel = false;
1923 if (GV->hasPrivateLinkage() &&
1924 ((isa<Function>(GV) && TM.getFunctionSections()) ||
1925 (isa<GlobalVariable>(GV) && TM.getDataSections())))
1926 CannotUsePrivateLabel = true;
1927
1928 getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
1929}
1930
1932 const Function &F, const TargetMachine &TM) const {
1933 // If the function can be removed, produce a unique section so that
1934 // the table doesn't prevent the removal.
1935 const Comdat *C = F.getComdat();
1936 bool EmitUniqueSection = TM.getFunctionSections() || C;
1937 if (!EmitUniqueSection)
1938 return ReadOnlySection;
1939
1940 // FIXME: we should produce a symbol for F instead.
1941 if (F.hasPrivateLinkage())
1942 return ReadOnlySection;
1943
1944 MCSymbol *Sym = TM.getSymbol(&F);
1945 StringRef COMDATSymName = Sym->getName();
1946
1949 unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1950 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1951 unsigned UniqueID = NextUniqueID++;
1952
1953 return getContext().getCOFFSection(SecName, Characteristics, COMDATSymName,
1955 UniqueID);
1956}
1957
1959 bool UsesLabelDifference, const Function &F) const {
1960 if (TM->getTargetTriple().getArch() == Triple::x86_64) {
1962 // We can always create relative relocations, so use another section
1963 // that can be marked non-executable.
1964 return false;
1965 }
1966 }
1968 UsesLabelDifference, F);
1969}
1970
1972 const Module &M) const {
1974
1975 unsigned Version = 0;
1976 unsigned Flags = 0;
1977 StringRef Section;
1978
1979 GetObjCImageInfo(M, Version, Flags, Section);
1980 if (!Section.empty()) {
1981 auto &C = getContext();
1982 auto *S = C.getCOFFSection(Section, COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1984 Streamer.switchSection(S);
1985 Streamer.emitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
1986 Streamer.emitInt32(Version);
1987 Streamer.emitInt32(Flags);
1988 Streamer.addBlankLine();
1989 }
1990
1993 if (MCSymbol *Sym =
1994 static_cast<MCSectionCOFF *>(Streamer.getCurrentSectionOnly())
1995 ->getCOMDATSymbol())
1996 if (Sym->isUndefined()) {
1997 // COMDAT symbol must be external to perform deduplication.
1998 Streamer.emitSymbolAttribute(Sym, MCSA_Global);
1999 Streamer.emitLabel(Sym);
2000 }
2001 });
2002}
2003
2004MCSection *
2009
2011 const Module &M) const {
2012 if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
2013 // Emit the linker options to the linker .drectve section. According to the
2014 // spec, this section is a space-separated string containing flags for
2015 // linker.
2017 Streamer.switchSection(Sec);
2018 for (const auto *Option : LinkerOptions->operands()) {
2019 for (const auto &Piece : cast<MDNode>(Option)->operands()) {
2020 // Lead with a space for consistency with our dllexport implementation.
2021 std::string Directive(" ");
2022 Directive.append(std::string(cast<MDString>(Piece)->getString()));
2023 Streamer.emitBytes(Directive);
2024 }
2025 }
2026 }
2027
2028 // Emit /EXPORT: flags for each exported global as necessary.
2029 std::string Flags;
2030 for (const GlobalValue &GV : M.global_values()) {
2031 raw_string_ostream OS(Flags);
2032 emitLinkerFlagsForGlobalCOFF(OS, &GV, getContext().getTargetTriple(),
2033 getMangler());
2034 if (!Flags.empty()) {
2035 Streamer.switchSection(getDrectveSection());
2036 Streamer.emitBytes(Flags);
2037 }
2038 Flags.clear();
2039 }
2040
2041 // Emit /INCLUDE: flags for each used global as necessary.
2042 if (const auto *LU = M.getNamedGlobal("llvm.used")) {
2043 assert(LU->hasInitializer() && "expected llvm.used to have an initializer");
2044 assert(isa<ArrayType>(LU->getValueType()) &&
2045 "expected llvm.used to be an array type");
2046 if (const auto *A = cast<ConstantArray>(LU->getInitializer())) {
2047 for (const Value *Op : A->operands()) {
2048 const auto *GV = cast<GlobalValue>(Op->stripPointerCasts());
2049 // Global symbols with internal or private linkage are not visible to
2050 // the linker, and thus would cause an error when the linker tried to
2051 // preserve the symbol due to the `/include:` directive.
2052 if (GV->hasLocalLinkage())
2053 continue;
2054
2055 raw_string_ostream OS(Flags);
2056 emitLinkerFlagsForUsedCOFF(OS, GV, getContext().getTargetTriple(),
2057 getMangler());
2058
2059 if (!Flags.empty()) {
2060 Streamer.switchSection(getDrectveSection());
2061 Streamer.emitBytes(Flags);
2062 }
2063 Flags.clear();
2064 }
2065 }
2066 }
2067}
2068
2070 const TargetMachine &TM,
2071 const Module &M) {
2073 const Triple &T = TM.getTargetTriple();
2074 if (T.isWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) {
2076 Ctx.getCOFFSection(".CRT$XCU", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
2079 Ctx.getCOFFSection(".CRT$XTX", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
2081 } else {
2082 StaticCtorSection = Ctx.getCOFFSection(
2085 StaticDtorSection = Ctx.getCOFFSection(
2088 }
2089}
2090
2092 const Triple &T, bool IsCtor,
2093 unsigned Priority,
2094 const MCSymbol *KeySym,
2096 if (T.isWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) {
2097 // If the priority is the default, use .CRT$XCU, possibly associative.
2098 if (Priority == 65535)
2099 return Ctx.getAssociativeCOFFSection(Default, KeySym, 0);
2100
2101 // Otherwise, we need to compute a new section name. Low priorities should
2102 // run earlier. The linker will sort sections ASCII-betically, and we need a
2103 // string that sorts between .CRT$XCA and .CRT$XCU. In the general case, we
2104 // make a name like ".CRT$XCT12345", since that runs before .CRT$XCU. Really
2105 // low priorities need to sort before 'L', since the CRT uses that
2106 // internally, so we use ".CRT$XCA00001" for them. We have a contract with
2107 // the frontend that "init_seg(compiler)" corresponds to priority 200 and
2108 // "init_seg(lib)" corresponds to priority 400, and those respectively use
2109 // 'C' and 'L' without the priority suffix. Priorities between 200 and 400
2110 // use 'C' with the priority as a suffix.
2111 SmallString<24> Name;
2112 char LastLetter = 'T';
2113 bool AddPrioritySuffix = Priority != 200 && Priority != 400;
2114 if (Priority < 200)
2115 LastLetter = 'A';
2116 else if (Priority < 400)
2117 LastLetter = 'C';
2118 else if (Priority == 400)
2119 LastLetter = 'L';
2120 raw_svector_ostream OS(Name);
2121 OS << ".CRT$X" << (IsCtor ? "C" : "T") << LastLetter;
2122 if (AddPrioritySuffix)
2123 OS << format("%05u", Priority);
2124 MCSectionCOFF *Sec = Ctx.getCOFFSection(
2126 return Ctx.getAssociativeCOFFSection(Sec, KeySym, 0);
2127 }
2128
2129 std::string Name = IsCtor ? ".ctors" : ".dtors";
2130 if (Priority != 65535)
2131 raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
2132
2133 return Ctx.getAssociativeCOFFSection(
2134 Ctx.getCOFFSection(Name, COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
2137 KeySym, 0);
2138}
2139
2141 unsigned Priority, const MCSymbol *KeySym) const {
2143 getContext(), getContext().getTargetTriple(), true, Priority, KeySym,
2144 static_cast<MCSectionCOFF *>(StaticCtorSection));
2145}
2146
2148 unsigned Priority, const MCSymbol *KeySym) const {
2150 getContext(), getContext().getTargetTriple(), false, Priority, KeySym,
2151 static_cast<MCSectionCOFF *>(StaticDtorSection));
2152}
2153
2155 const GlobalValue *LHS, const GlobalValue *RHS, int64_t Addend,
2156 std::optional<int64_t> PCRelativeOffset, const TargetMachine &TM) const {
2157 // Our symbols should exist in address space zero, cowardly no-op if
2158 // otherwise.
2159 if (LHS->getType()->getPointerAddressSpace() != 0 ||
2160 RHS->getType()->getPointerAddressSpace() != 0)
2161 return nullptr;
2162
2163 const auto *GA = dyn_cast<GlobalAlias>(LHS);
2164 const GlobalObject *GO = GA ? dyn_cast_or_null<GlobalObject>(GA->getAliasee())
2166
2167 // Both ptrtoint instructions must wrap global objects:
2168 // - Only global variables that are dso_local are eligible for image relative
2169 // relocations.
2170 // - FIXME: Referring to a dllimport function produces an image-relative
2171 // relocation against the local import thunk rather than the canonical
2172 // function pointer, which lacks program-wide pointer identity. This is
2173 // sufficient for use cases like MSVC exception handling metadata (where the
2174 // function is only invoked), but is not theoretically sound in general.
2175 // We probably need something like dso_local_equivalent to explicitly
2176 // request a callable local entry point.
2177 // - The subtrahend refers to the special symbol __ImageBase, a
2178 // GlobalVariable. We expect __ImageBase to be a global variable without a
2179 // section, externally defined.
2180 //
2181 // It should look something like this: @__ImageBase = external constant i8
2182 if (!GO || (isa<GlobalVariable>(GO) && !TM.shouldAssumeDSOLocal(LHS)) ||
2183 GO->isThreadLocal() || !isa<GlobalVariable>(RHS) ||
2184 RHS->isThreadLocal() || RHS->getName() != "__ImageBase" ||
2185 !RHS->hasExternalLinkage() ||
2186 cast<GlobalVariable>(RHS)->hasInitializer() || RHS->hasSection())
2187 return nullptr;
2188
2189 const MCExpr *Res = MCSymbolRefExpr::create(
2191 if (Addend != 0)
2193 Res, MCConstantExpr::create(Addend, getContext()), getContext());
2194 return Res;
2195}
2196
2197static std::string APIntToHexString(const APInt &AI) {
2198 unsigned Width = (AI.getBitWidth() / 8) * 2;
2199 std::string HexString = toString(AI, 16, /*Signed=*/false);
2200 llvm::transform(HexString, HexString.begin(), tolower);
2201 unsigned Size = HexString.size();
2202 assert(Width >= Size && "hex string is too large!");
2203 HexString.insert(HexString.begin(), Width - Size, '0');
2204
2205 return HexString;
2206}
2207
2208static std::string scalarConstantToHexString(const Constant *C) {
2209 Type *Ty = C->getType();
2210 if (isa<UndefValue>(C)) {
2211 return APIntToHexString(APInt::getZero(Ty->getPrimitiveSizeInBits()));
2212 } else if (const auto *CFP = dyn_cast<ConstantFP>(C)) {
2213 if (CFP->getType()->isFloatingPointTy())
2214 return APIntToHexString(CFP->getValueAPF().bitcastToAPInt());
2215
2216 std::string HexString;
2217 unsigned NumElements =
2218 cast<FixedVectorType>(CFP->getType())->getNumElements();
2219 for (unsigned I = 0; I < NumElements; ++I)
2220 HexString += APIntToHexString(CFP->getValueAPF().bitcastToAPInt());
2221 return HexString;
2222 } else if (const auto *CI = dyn_cast<ConstantInt>(C)) {
2223 if (CI->getType()->isIntegerTy())
2224 return APIntToHexString(CI->getValue());
2225
2226 std::string HexString;
2227 unsigned NumElements =
2228 cast<FixedVectorType>(CI->getType())->getNumElements();
2229 for (unsigned I = 0; I < NumElements; ++I)
2230 HexString += APIntToHexString(CI->getValue());
2231 return HexString;
2232 } else {
2233 unsigned NumElements;
2234 if (auto *VTy = dyn_cast<VectorType>(Ty))
2235 NumElements = cast<FixedVectorType>(VTy)->getNumElements();
2236 else
2237 NumElements = Ty->getArrayNumElements();
2238 std::string HexString;
2239 for (int I = NumElements - 1, E = -1; I != E; --I)
2240 HexString += scalarConstantToHexString(C->getAggregateElement(I));
2241 return HexString;
2242 }
2243}
2244
2246 const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment,
2247 const Function *F) const {
2248 if (Kind.isMergeableConst() && C &&
2249 getContext().getAsmInfo().hasCOFFComdatConstants()) {
2250 // This creates comdat sections with the given symbol name, but unless
2251 // AsmPrinter::GetCPISymbol actually makes the symbol global, the symbol
2252 // will be created with a null storage class, which makes GNU binutils
2253 // error out.
2254 const unsigned Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
2257 std::string COMDATSymName;
2258 if (Kind.isMergeableConst4()) {
2259 if (Alignment <= 4) {
2260 COMDATSymName = "__real@" + scalarConstantToHexString(C);
2261 Alignment = Align(4);
2262 }
2263 } else if (Kind.isMergeableConst8()) {
2264 if (Alignment <= 8) {
2265 COMDATSymName = "__real@" + scalarConstantToHexString(C);
2266 Alignment = Align(8);
2267 }
2268 } else if (Kind.isMergeableConst16()) {
2269 // FIXME: These may not be appropriate for non-x86 architectures.
2270 if (Alignment <= 16) {
2271 COMDATSymName = "__xmm@" + scalarConstantToHexString(C);
2272 Alignment = Align(16);
2273 }
2274 } else if (Kind.isMergeableConst32()) {
2275 if (Alignment <= 32) {
2276 COMDATSymName = "__ymm@" + scalarConstantToHexString(C);
2277 Alignment = Align(32);
2278 }
2279 }
2280
2281 if (!COMDATSymName.empty())
2282 return getContext().getCOFFSection(".rdata", Characteristics,
2283 COMDATSymName,
2285 }
2286
2287 return TargetLoweringObjectFile::getSectionForConstant(DL, Kind, C, Alignment,
2288 F);
2289}
2290
2291//===----------------------------------------------------------------------===//
2292// Wasm
2293//===----------------------------------------------------------------------===//
2294
2295static const Comdat *getWasmComdat(const GlobalValue *GV) {
2296 const Comdat *C = GV->getComdat();
2297 if (!C)
2298 return nullptr;
2299
2300 if (C->getSelectionKind() != Comdat::Any)
2301 report_fatal_error("WebAssembly COMDATs only support "
2302 "SelectionKind::Any, '" + C->getName() + "' cannot be "
2303 "lowered.");
2304
2305 return C;
2306}
2307
2308static unsigned getWasmSectionFlags(SectionKind K, bool Retain) {
2309 unsigned Flags = 0;
2310
2311 if (K.isThreadLocal())
2312 Flags |= wasm::WASM_SEG_FLAG_TLS;
2313
2314 if (K.isMergeableCString())
2316
2317 if (Retain)
2319
2320 // TODO(sbc): Add support for K.isMergeableConst()
2321
2322 return Flags;
2323}
2324
2326 const TargetMachine &TM,
2327 const Module &M) {
2329
2331 collectUsedGlobalVariables(M, Vec, false);
2332 for (GlobalValue *GV : Vec)
2333 if (auto *GO = dyn_cast<GlobalObject>(GV))
2334 Used.insert(GO);
2335}
2336
2337MCSection *
2339 SectionKind Kind) const {
2340 if (Kind.isMetadata())
2341 return getContext().getWasmSection(".custom_section." + Name, Kind);
2342 return getContext().getWasmSection(Name, Kind);
2343}
2344
2346 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2347 // We don't support explict section names for functions in the wasm object
2348 // format. Each function has to be in its own unique section.
2349 if (isa<Function>(GO)) {
2350 return SelectSectionForGlobal(GO, Kind, TM);
2351 }
2352
2353 StringRef Name = GO->getSection();
2354
2355 // Certain data sections we treat as named custom sections rather than
2356 // segments within the data section.
2357 // This could be avoided if all data segements (the wasm sense) were
2358 // represented as their own sections (in the llvm sense).
2359 // TODO(sbc): https://github.com/WebAssembly/tool-conventions/issues/138
2360 if (Name == getInstrProfSectionName(IPSK_covmap, Triple::Wasm,
2361 /*AddSegmentInfo=*/false) ||
2362 Name == getInstrProfSectionName(IPSK_covfun, Triple::Wasm,
2363 /*AddSegmentInfo=*/false) ||
2364 Name == ".llvmbc" || Name == ".llvmcmd")
2365 Kind = SectionKind::getMetadata();
2366
2367 StringRef Group = "";
2368 if (const Comdat *C = getWasmComdat(GO)) {
2369 Group = C->getName();
2370 }
2371
2372 unsigned Flags = getWasmSectionFlags(Kind, Used.count(GO));
2373 MCSectionWasm *Section = getContext().getWasmSection(Name, Kind, Flags, Group,
2375
2376 return Section;
2377}
2378
2379static MCSectionWasm *
2381 SectionKind Kind, Mangler &Mang,
2382 const TargetMachine &TM, bool EmitUniqueSection,
2383 unsigned *NextUniqueID, bool Retain) {
2384 StringRef Group = "";
2385 if (const Comdat *C = getWasmComdat(GO)) {
2386 Group = C->getName();
2387 }
2388
2389 bool UniqueSectionNames = TM.getUniqueSectionNames();
2390 SmallString<128> Name = getSectionPrefixForGlobal(Kind, /*IsLarge=*/false);
2391
2392 if (const auto *F = dyn_cast<Function>(GO)) {
2393 const auto &OptionalPrefix = F->getSectionPrefix();
2394 if (OptionalPrefix)
2395 raw_svector_ostream(Name) << '.' << *OptionalPrefix;
2396 }
2397
2398 if (EmitUniqueSection && UniqueSectionNames) {
2399 Name.push_back('.');
2400 TM.getNameWithPrefix(Name, GO, Mang, true);
2401 }
2403 if (EmitUniqueSection && !UniqueSectionNames) {
2404 UniqueID = *NextUniqueID;
2405 (*NextUniqueID)++;
2406 }
2407
2408 unsigned Flags = getWasmSectionFlags(Kind, Retain);
2409 return Ctx.getWasmSection(Name, Kind, Flags, Group, UniqueID);
2410}
2411
2413 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2414
2415 if (Kind.isCommon())
2416 report_fatal_error("mergable sections not supported yet on wasm");
2417
2418 // If we have -ffunction-section or -fdata-section then we should emit the
2419 // global value to a uniqued section specifically for it.
2420 bool EmitUniqueSection = false;
2421 if (Kind.isText())
2422 EmitUniqueSection = TM.getFunctionSections();
2423 else
2424 EmitUniqueSection = TM.getDataSections();
2425 EmitUniqueSection |= GO->hasComdat();
2426 bool Retain = Used.count(GO);
2427 EmitUniqueSection |= Retain;
2428
2429 return selectWasmSectionForGlobal(getContext(), GO, Kind, getMangler(), TM,
2430 EmitUniqueSection, &NextUniqueID, Retain);
2431}
2432
2434 bool UsesLabelDifference, const Function &F) const {
2435 // We can always create relative relocations, so use another section
2436 // that can be marked non-executable.
2437 return false;
2438}
2439
2443
2444 // We don't use PersonalityEncoding and LSDAEncoding because we don't emit
2445 // .cfi directives. We use TTypeEncoding to encode typeinfo global variables.
2447}
2448
2450 unsigned Priority, const MCSymbol *KeySym) const {
2451 return Priority == UINT16_MAX ?
2453 getContext().getWasmSection(".init_array." + utostr(Priority),
2455}
2456
2458 unsigned Priority, const MCSymbol *KeySym) const {
2459 report_fatal_error("@llvm.global_dtors should have been lowered already");
2460}
2461
2462//===----------------------------------------------------------------------===//
2463// XCOFF
2464//===----------------------------------------------------------------------===//
2466 const MachineFunction *MF) {
2467 if (!MF->getLandingPads().empty())
2468 return true;
2469
2470 const Function &F = MF->getFunction();
2471 if (!F.hasPersonalityFn() || !F.needsUnwindTableEntry())
2472 return false;
2473
2474 const GlobalValue *Per =
2475 dyn_cast<GlobalValue>(F.getPersonalityFn()->stripPointerCasts());
2476 assert(Per && "Personality routine is not a GlobalValue type.");
2478 return false;
2479
2480 return true;
2481}
2482
2484 const MachineFunction *MF) {
2485 const Function &F = MF->getFunction();
2486 if (!F.hasStackProtectorFnAttr())
2487 return false;
2488 // FIXME: check presence of canary word
2489 // There are cases that the stack protectors are not really inserted even if
2490 // the attributes are on.
2491 return true;
2492}
2493
2494MCSymbol *
2496 auto *EHInfoSym =
2497 static_cast<MCSymbolXCOFF *>(MF->getContext().getOrCreateSymbol(
2498 "__ehinfo." + Twine(MF->getFunctionNumber())));
2499 EHInfoSym->setEHInfo();
2500 return EHInfoSym;
2501}
2502
2503MCSymbol *
2505 const TargetMachine &TM) const {
2506 // We always use a qualname symbol for a GV that represents
2507 // a declaration, a function descriptor, or a common symbol. An IFunc is
2508 // lowered as a special trampoline function which has an entry point and a
2509 // descriptor.
2510 // If a GV represents a GlobalVariable and -fdata-sections is enabled, we
2511 // also return a qualname so that a label symbol could be avoided.
2512 // It is inherently ambiguous when the GO represents the address of a
2513 // function, as the GO could either represent a function descriptor or a
2514 // function entry point. We choose to always return a function descriptor
2515 // here.
2516 if (const GlobalObject *GO = dyn_cast<GlobalObject>(GV)) {
2517 if (GO->isDeclarationForLinker())
2518 return static_cast<const MCSectionXCOFF *>(
2520 ->getQualNameSymbol();
2521
2522 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV))
2523 if (GVar->hasAttribute("toc-data"))
2524 return static_cast<const MCSectionXCOFF *>(
2526 ->getQualNameSymbol();
2527
2528 if (isa<GlobalIFunc>(GO))
2529 return static_cast<const MCSectionXCOFF *>(
2531 ->getQualNameSymbol();
2532
2533 SectionKind GOKind = getKindForGlobal(GO, TM);
2534 if (GOKind.isText())
2535 return static_cast<const MCSectionXCOFF *>(
2537 ->getQualNameSymbol();
2538 if ((TM.getDataSections() && !GO->hasSection()) || GO->hasCommonLinkage() ||
2539 GOKind.isBSSLocal() || GOKind.isThreadBSSLocal())
2540 return static_cast<const MCSectionXCOFF *>(
2541 SectionForGlobal(GO, GOKind, TM))
2542 ->getQualNameSymbol();
2543 }
2544
2545 // For all other cases, fall back to getSymbol to return the unqualified name.
2546 return nullptr;
2547}
2548
2550 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2551 if (!GO->hasSection())
2552 report_fatal_error("#pragma clang section is not yet supported");
2553
2555
2556 // Handle the XCOFF::TD case first, then deal with the rest.
2557 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GO))
2558 if (GVar->hasAttribute("toc-data"))
2559 return getContext().getXCOFFSection(
2560 SectionName, Kind,
2562 /* MultiSymbolsAllowed*/ true);
2563
2564 XCOFF::StorageMappingClass MappingClass;
2565 if (Kind.isText())
2566 MappingClass = XCOFF::XMC_PR;
2567 else if (Kind.isData() || Kind.isBSS())
2568 MappingClass = XCOFF::XMC_RW;
2569 else if (Kind.isReadOnlyWithRel())
2570 MappingClass =
2571 TM.Options.XCOFFReadOnlyPointers ? XCOFF::XMC_RO : XCOFF::XMC_RW;
2572 else if (Kind.isReadOnly())
2573 MappingClass = XCOFF::XMC_RO;
2574 else
2575 report_fatal_error("XCOFF other section types not yet implemented.");
2576
2577 return getContext().getXCOFFSection(
2578 SectionName, Kind, XCOFF::CsectProperties(MappingClass, XCOFF::XTY_SD),
2579 /* MultiSymbolsAllowed*/ true);
2580}
2581
2583 const GlobalObject *GO, const TargetMachine &TM) const {
2585 "Tried to get ER section for a defined global.");
2586
2587 SmallString<128> Name;
2588 getNameWithPrefix(Name, GO, TM);
2589
2590 // AIX TLS local-dynamic does not need the external reference for the
2591 // "_$TLSML" symbol.
2593 GO->hasName() && GO->getName() == "_$TLSML") {
2594 return getContext().getXCOFFSection(
2595 Name, SectionKind::getData(),
2597 }
2598
2601 if (GO->isThreadLocal())
2602 SMC = XCOFF::XMC_UL;
2603
2604 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GO))
2605 if (GVar->hasAttribute("toc-data"))
2606 SMC = XCOFF::XMC_TD;
2607
2608 // Externals go into a csect of type ER.
2609 return getContext().getXCOFFSection(
2612}
2613
2615 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2616 // Handle the XCOFF::TD case first, then deal with the rest.
2617 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GO))
2618 if (GVar->hasAttribute("toc-data")) {
2619 SmallString<128> Name;
2620 getNameWithPrefix(Name, GO, TM);
2621 XCOFF::SymbolType symType =
2623 return getContext().getXCOFFSection(
2624 Name, Kind, XCOFF::CsectProperties(XCOFF::XMC_TD, symType),
2625 /* MultiSymbolsAllowed*/ true);
2626 }
2627
2628 // Common symbols go into a csect with matching name which will get mapped
2629 // into the .bss section.
2630 // Zero-initialized local TLS symbols go into a csect with matching name which
2631 // will get mapped into the .tbss section.
2632 if (Kind.isBSSLocal() || GO->hasCommonLinkage() || Kind.isThreadBSSLocal()) {
2633 SmallString<128> Name;
2634 getNameWithPrefix(Name, GO, TM);
2635 XCOFF::StorageMappingClass SMC = Kind.isBSSLocal() ? XCOFF::XMC_BS
2636 : Kind.isCommon() ? XCOFF::XMC_RW
2637 : XCOFF::XMC_UL;
2638 return getContext().getXCOFFSection(
2639 Name, Kind, XCOFF::CsectProperties(SMC, XCOFF::XTY_CM));
2640 }
2641
2642 if (Kind.isText()) {
2643 if (TM.getFunctionSections()) {
2644 return static_cast<const MCSymbolXCOFF *>(
2646 ->getRepresentedCsect();
2647 }
2648 return TextSection;
2649 }
2650
2651 if (TM.Options.XCOFFReadOnlyPointers && Kind.isReadOnlyWithRel()) {
2652 if (!TM.getDataSections())
2654 "ReadOnlyPointers is supported only if data sections is turned on");
2655
2656 SmallString<128> Name;
2657 getNameWithPrefix(Name, GO, TM);
2658 return getContext().getXCOFFSection(
2661 }
2662
2663 // For BSS kind, zero initialized data must be emitted to the .data section
2664 // because external linkage control sections that get mapped to the .bss
2665 // section will be linked as tentative definitions, which is only appropriate
2666 // for SectionKind::Common.
2667 if (Kind.isData() || Kind.isReadOnlyWithRel() || Kind.isBSS()) {
2668 if (TM.getDataSections()) {
2669 SmallString<128> Name;
2670 getNameWithPrefix(Name, GO, TM);
2671 return getContext().getXCOFFSection(
2672 Name, SectionKind::getData(),
2674 }
2675 return DataSection;
2676 }
2677
2678 if (Kind.isReadOnly()) {
2679 if (TM.getDataSections()) {
2680 SmallString<128> Name;
2681 getNameWithPrefix(Name, GO, TM);
2682 return getContext().getXCOFFSection(
2685 }
2686 return ReadOnlySection;
2687 }
2688
2689 // External/weak TLS data and initialized local TLS data are not eligible
2690 // to be put into common csect. If data sections are enabled, thread
2691 // data are emitted into separate sections. Otherwise, thread data
2692 // are emitted into the .tdata section.
2693 if (Kind.isThreadLocal()) {
2694 if (TM.getDataSections()) {
2695 SmallString<128> Name;
2696 getNameWithPrefix(Name, GO, TM);
2697 return getContext().getXCOFFSection(
2699 }
2700 return TLSDataSection;
2701 }
2702
2703 report_fatal_error("XCOFF other section types not yet implemented.");
2704}
2705
2707 const Function &F, const TargetMachine &TM) const {
2708 assert (!F.getComdat() && "Comdat not supported on XCOFF.");
2709
2710 if (!TM.getFunctionSections())
2711 return ReadOnlySection;
2712
2713 // If the function can be removed, produce a unique section so that
2714 // the table doesn't prevent the removal.
2715 SmallString<128> NameStr(".rodata.jmp..");
2716 getNameWithPrefix(NameStr, &F, TM);
2717 return getContext().getXCOFFSection(
2718 NameStr, SectionKind::getReadOnly(),
2720}
2721
2723 bool UsesLabelDifference, const Function &F) const {
2724 return false;
2725}
2726
2727/// Given a mergeable constant with the specified size and relocation
2728/// information, return a section that it should be placed in.
2730 const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment,
2731 const Function *F) const {
2732 // TODO: Enable emiting constant pool to unique sections when we support it.
2733 if (Alignment > Align(16))
2734 report_fatal_error("Alignments greater than 16 not yet supported.");
2735
2736 if (Alignment == Align(8)) {
2737 assert(ReadOnly8Section && "Section should always be initialized.");
2738 return ReadOnly8Section;
2739 }
2740
2741 if (Alignment == Align(16)) {
2742 assert(ReadOnly16Section && "Section should always be initialized.");
2743 return ReadOnly16Section;
2744 }
2745
2746 return ReadOnlySection;
2747}
2748
2750 const TargetMachine &TgtM,
2751 const Module &M) {
2755 (TgtM.getTargetTriple().isArch32Bit() ? dwarf::DW_EH_PE_sdata4
2758 LSDAEncoding = 0;
2760
2761 // AIX debug for thread local location is not ready. And for integrated as
2762 // mode, the relocatable address for the thread local variable will cause
2763 // linker error. So disable the location attribute generation for thread local
2764 // variables for now.
2765 // FIXME: when TLS debug on AIX is ready, remove this setting.
2767}
2768
2770 unsigned Priority, const MCSymbol *KeySym) const {
2771 report_fatal_error("no static constructor section on AIX");
2772}
2773
2775 unsigned Priority, const MCSymbol *KeySym) const {
2776 report_fatal_error("no static destructor section on AIX");
2777}
2778
2781 assert(!isa<GlobalIFunc>(GV) && "GlobalIFunc is not supported on AIX.");
2782
2783 switch (GV->getLinkage()) {
2786 return XCOFF::C_HIDEXT;
2790 return XCOFF::C_EXT;
2796 return XCOFF::C_WEAKEXT;
2799 "There is no mapping that implements AppendingLinkage for XCOFF.");
2800 }
2801 llvm_unreachable("Unknown linkage type!");
2802}
2803
2805 const GlobalValue *Func, const TargetMachine &TM) const {
2806 assert((isa<Function>(Func) || isa<GlobalIFunc>(Func) ||
2807 (isa<GlobalAlias>(Func) &&
2809 cast<GlobalAlias>(Func)->getAliaseeObject()))) &&
2810 "Func must be a function or an alias which has a function as base "
2811 "object.");
2812
2813 SmallString<128> NameStr;
2814 NameStr.push_back('.');
2815 getNameWithPrefix(NameStr, Func, TM);
2816
2817 // When -function-sections is enabled and explicit section is not specified,
2818 // it's not necessary to emit function entry point label any more. We will use
2819 // function entry point csect instead. And for function delcarations, the
2820 // undefined symbols gets treated as csect with XTY_ER property.
2821 if (((TM.getFunctionSections() && !Func->hasSection()) ||
2822 Func->isDeclarationForLinker()) &&
2823 (isa<Function>(Func) || isa<GlobalIFunc>(Func))) {
2824 return getContext()
2826 NameStr, SectionKind::getText(),
2827 XCOFF::CsectProperties(XCOFF::XMC_PR, Func->isDeclarationForLinker()
2829 : XCOFF::XTY_SD))
2831 }
2832
2833 return getContext().getOrCreateSymbol(NameStr);
2834}
2835
2837 const GlobalObject *F, const TargetMachine &TM) const {
2839 "F must be a function or ifunc object.");
2840 SmallString<128> NameStr;
2841 getNameWithPrefix(NameStr, F, TM);
2842 return getContext().getXCOFFSection(
2843 NameStr, SectionKind::getData(),
2845}
2846
2848 const MCSymbol *Sym, const TargetMachine &TM) const {
2849 const XCOFF::StorageMappingClass SMC = [](const MCSymbol *Sym,
2850 const TargetMachine &TM) {
2851 auto *XSym = static_cast<const MCSymbolXCOFF *>(Sym);
2852
2853 // The "_$TLSML" symbol for TLS local-dynamic mode requires XMC_TC,
2854 // otherwise the AIX assembler will complain.
2855 if (XSym->getSymbolTableName() == "_$TLSML")
2856 return XCOFF::XMC_TC;
2857
2858 // Use large code model toc entries for ehinfo symbols as they are
2859 // never referenced directly. The runtime loads their TOC entry
2860 // addresses from the trace-back table.
2861 if (XSym->isEHInfo())
2862 return XCOFF::XMC_TE;
2863
2864 // If the symbol does not have a code model specified use the module value.
2865 if (!XSym->hasPerSymbolCodeModel())
2866 return TM.getCodeModel() == CodeModel::Large ? XCOFF::XMC_TE
2867 : XCOFF::XMC_TC;
2868
2869 return XSym->getPerSymbolCodeModel() == MCSymbolXCOFF::CM_Large
2871 : XCOFF::XMC_TC;
2872 }(Sym, TM);
2873
2874 return getContext().getXCOFFSection(
2875 static_cast<const MCSymbolXCOFF *>(Sym)->getSymbolTableName(),
2877}
2878
2880 const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const {
2881 auto *LSDA = static_cast<MCSectionXCOFF *>(LSDASection);
2882 if (TM.getFunctionSections()) {
2883 // If option -ffunction-sections is on, append the function name to the
2884 // name of the LSDA csect so that each function has its own LSDA csect.
2885 // This helps the linker to garbage-collect EH info of unused functions.
2886 SmallString<128> NameStr = LSDA->getName();
2887 raw_svector_ostream(NameStr) << '.' << F.getName();
2888 LSDA = getContext().getXCOFFSection(NameStr, LSDA->getKind(),
2889 LSDA->getCsectProp());
2890 }
2891 return LSDA;
2892}
2893//===----------------------------------------------------------------------===//
2894// GOFF
2895//===----------------------------------------------------------------------===//
2897
2899 const TargetMachine &TM,
2900 const Module &M) {
2902
2903 // Construct the default names for the root SD and the ADA PR symbol.
2904 StringRef FileName = sys::path::stem(M.getSourceFileName());
2905 if (FileName.size() > 1 && FileName.starts_with('<') &&
2906 FileName.ends_with('>'))
2907 FileName = FileName.substr(1, FileName.size() - 2);
2908 DefaultRootSDName = Twine(FileName).concat("#C").str();
2909 DefaultADAPRName = Twine(FileName).concat("#S").str();
2910 MCSectionGOFF *RootSD =
2911 static_cast<MCSectionGOFF *>(TextSection)->getParent();
2912 MCSectionGOFF *ADAPR = static_cast<MCSectionGOFF *>(ADASection);
2913 RootSD->setName(DefaultRootSDName);
2914 ADAPR->setName(DefaultADAPRName);
2915 // Initialize the label for the text section.
2916 MCSymbolGOFF *TextLD = static_cast<MCSymbolGOFF *>(
2917 getContext().getOrCreateSymbol(RootSD->getName()));
2920 TextLD->setExternal(false);
2921 TextLD->setWeak(false);
2922 TextLD->setADA(ADAPR);
2923 TextSection->setBeginSymbol(TextLD);
2924 // Initialize the label for the ADA section.
2925 MCSymbolGOFF *ADASym = static_cast<MCSymbolGOFF *>(
2927 ADAPR->setBeginSymbol(ADASym);
2928}
2929
2931 bool UsesLabelDifference, const Function &F) const {
2932 return true;
2933}
2934
2936 const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment,
2937 const Function *F) const {
2938 return TextSection;
2939}
2940
2945
2947 const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const {
2948 std::string Name = "GCC_except." + F.getName().str();
2949
2950 MCSectionGOFF *SD = getContext().getGOFFSection(
2953 MCSectionGOFF *WSA = getContext().getGOFFSection(
2958 SD);
2959 WSA->setAlignment(Align(8));
2960 return getContext().getGOFFSection(
2961 SectionKind::getData(), Name,
2964 WSA);
2965}
2966
2968 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2969 auto *Symbol = TM.getSymbol(GO);
2970
2971 // Read-only data stays in the code section only if it is local: references
2972 // from other translation units are always parts in the WSA.
2973 if (Kind.isBSS() || Kind.isData() || Kind.isReadOnlyWithRel() ||
2974 (Kind.isReadOnly() && !GO->hasLocalLinkage())) {
2975 GOFF::ESDBindingScope PRBindingScope =
2976 GO->hasExternalLinkage()
2980 GOFF::ESDBindingScope SDBindingScope =
2983 MaybeAlign Alignment;
2984 if (auto *F = dyn_cast<Function>(GO))
2985 Alignment = F->getAlign();
2986 else if (auto *V = dyn_cast<GlobalVariable>(GO))
2987 Alignment = V->getAlign();
2988 MCSectionGOFF *SD = getContext().getGOFFSection(
2989 SectionKind::getMetadata(), Symbol->getName(),
2990 GOFF::SDAttr{GOFF::ESD_TA_Unspecified, SDBindingScope});
2991 MCSectionGOFF *ED = getContext().getGOFFSection(
2996 SD);
2997 ED->setAlignment(Alignment.value_or(llvm::Align(8)));
2998 MCSectionGOFF *PR = getContext().getGOFFSection(
2999 Kind, Symbol->getName(),
3000 GOFF::PRAttr{false, GOFF::ESD_EXE_DATA, GOFF::ESD_BST_Strong,
3001 GOFF::ESD_LT_XPLink, PRBindingScope, 0},
3002 ED);
3003 // The binder rejects zero-length PR sections. Mark the PR so the writer
3004 // inflates it to a valid length if needed.
3006 return PR;
3007 }
3008 return TextSection;
3009}
3010
3011MCSection *
3013 // XL C/C++ compilers on z/OS support priorities from min-int to max-int, with
3014 // sinit as source priority 0. For clang, sinit has source priority 65535.
3015 // For GOFF, the priority sortkey field is an unsigned value. So, we
3016 // add min-int to get sorting to work properly but also subtract the
3017 // clang sinit (65535) value so internally xl sinit and clang sinit have
3018 // the same unsigned GOFF priority sortkey field value (i.e. 0x80000000).
3019 static constexpr const uint32_t ClangDefaultSinitPriority = 65535;
3020 uint32_t Prio = Priority + (0x80000000 - ClangDefaultSinitPriority);
3021
3022 std::string Name(".xtor");
3023 if (Priority != ClangDefaultSinitPriority)
3024 Name = llvm::Twine(Name).concat(".").concat(llvm::utostr(Priority)).str();
3025
3026 MCContext &Ctx = getContext();
3027 MCSectionGOFF *SInit = Ctx.getGOFFSection(
3033 static_cast<const MCSectionGOFF *>(TextSection)->getParent());
3034
3035 MCSectionGOFF *Xtor = Ctx.getGOFFSection(
3036 SectionKind::getData(), Name,
3039 SInit);
3040 return Xtor;
3041}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
amdgpu AMDGPU DAG DAG Pattern Instruction Selection
static bool isThumb(const MCSubtargetInfo &STI)
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
static const Function * getParent(const Value *V)
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define LLVM_LIFETIME_BOUND
Definition Compiler.h:464
This file contains the declarations for the subclasses of Constant, which represent the different fla...
@ Default
This file contains constants used for implementing Dwarf debug support.
Module.h This file contains the declarations for the Module class.
This file declares the MCSectionGOFF class, which contains all of the necessary machine code sections...
This file contains the MCSymbolGOFF class.
#define F(x, y, z)
Definition MD5.cpp:54
#define I(x, y, z)
Definition MD5.cpp:57
This file contains the declarations for metadata subclasses.
#define T
const char * Msg
This file defines the SmallString class.
This file defines the SmallVector class.
This file contains some functions that are useful when dealing with strings.
std::unique_ptr< MCStreamer > && Streamer
static bool canUsePrivateLabel(const MCAsmInfo &AsmInfo, const MCSection &Section)
static MCSection * selectExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM, MCContext &Ctx, Mangler &Mang, unsigned &NextUniqueID, bool Retain, bool ForceUnique)
static int getSelectionForCOFF(const GlobalValue *GV)
static MCSectionCOFF * getCOFFStaticStructorSection(MCContext &Ctx, const Triple &T, bool IsCtor, unsigned Priority, const MCSymbol *KeySym, MCSectionCOFF *Default)
static unsigned getEntrySizeForKind(SectionKind Kind)
static const GlobalValue * getComdatGVForCOFF(const GlobalValue *GV)
static unsigned getCOFFSectionFlags(SectionKind K, const TargetMachine &TM)
static unsigned getELFSectionType(StringRef Name, SectionKind K)
static bool hasPrefix(StringRef SectionName, StringRef Prefix)
static MCSectionWasm * selectWasmSectionForGlobal(MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang, const TargetMachine &TM, bool EmitUniqueSection, unsigned *NextUniqueID, bool Retain)
static const MCSymbolELF * getLinkedToSymbol(const GlobalObject *GO, const TargetMachine &TM)
static void GetObjCImageInfo(const Module &M, unsigned &Version, unsigned &Flags, StringRef &Section)
static unsigned calcUniqueIDUpdateFlagsAndSize(const GlobalObject *GO, StringRef SectionName, SectionKind Kind, const TargetMachine &TM, MCContext &Ctx, Mangler &Mang, unsigned &Flags, unsigned &EntrySize, unsigned &NextUniqueID, const bool Retain, const bool ForceUnique)
Calculate an appropriate unique ID for a section, and update Flags, EntrySize and NextUniqueID where ...
static SectionKind getELFKindForNamedSection(StringRef Name, SectionKind K)
static const Comdat * getWasmComdat(const GlobalValue *GV)
static MCSectionELF * getStaticStructorSection(MCContext &Ctx, bool UseInitArray, bool IsCtor, unsigned Priority, const MCSymbol *KeySym)
static std::tuple< StringRef, bool, unsigned, unsigned, unsigned > getGlobalObjectInfo(const GlobalObject *GO, const TargetMachine &TM, StringRef SectionName, SectionKind Kind)
static unsigned getWasmSectionFlags(SectionKind K, bool Retain)
static void checkMachOComdat(const GlobalValue *GV)
static std::string APIntToHexString(const APInt &AI)
static unsigned getELFSectionFlags(SectionKind K, const Triple &T)
static SmallString< 128 > getELFSectionNameForGlobal(const GlobalObject *GO, SectionKind Kind, Mangler &Mang, const TargetMachine &TM, bool UniqueSectionName, const MachineJumpTableEntry *JTE)
static cl::opt< bool > JumpTableInFunctionSection("jumptable-in-function-section", cl::Hidden, cl::init(false), cl::desc("Putting Jump Table in function section"))
static StringRef getSectionPrefixForGlobal(SectionKind Kind, bool IsLarge)
Return the section prefix name used by options FunctionsSections and DataSections.
static std::string scalarConstantToHexString(const Constant *C)
static StringRef getCOFFSectionNameForUniqueGlobal(SectionKind Kind)
static const Comdat * getELFComdat(const GlobalValue *GV)
static MCSectionELF * selectELFSectionForGlobal(MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang, const TargetMachine &TM, bool EmitUniqueSection, unsigned Flags, unsigned *NextUniqueID, const MCSymbolELF *AssociatedSymbol, const MachineJumpTableEntry *MJTE=nullptr)
Class for arbitrary precision integers.
Definition APInt.h:78
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition APInt.h:1508
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
Definition APInt.h:196
@ Largest
The linker will choose the largest COMDAT.
Definition Comdat.h:39
@ SameSize
The data referenced by the COMDAT must be the same size.
Definition Comdat.h:41
@ Any
The linker may choose any COMDAT.
Definition Comdat.h:37
@ NoDeduplicate
No deduplication is performed.
Definition Comdat.h:40
@ ExactMatch
The data referenced by the COMDAT must be the same.
Definition Comdat.h:38
This is an important base class in LLVM.
Definition Constant.h:44
A parsed version of the target data layout string in and methods for querying it.
Definition DataLayout.h:64
StringRef getInternalSymbolPrefix() const
Definition DataLayout.h:311
LLVM_ABI Align getPreferredAlign(const GlobalVariable *GV) const
Returns the preferred alignment of the specified global.
This is the base abstract class for diagnostic reporting in the backend.
Lightweight error class with error context and mandatory checking.
Definition Error.h:159
StringRef getSection() const
Get the custom section of this global if it has one.
bool hasMetadata() const
Return true if this GlobalObject has any metadata attached to it.
bool hasComdat() const
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this GlobalObject.
bool hasSection() const
Check if this global has a custom object file section.
bool hasExternalLinkage() const
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
LinkageTypes getLinkage() const
bool hasLocalLinkage() const
bool hasDefaultVisibility() const
bool hasPrivateLinkage() const
LLVM_ABI const Comdat * getComdat() const
Definition Globals.cpp:274
ThreadLocalMode getThreadLocalMode() const
bool isDeclarationForLinker() const
Module * getParent()
Get the module that this global value is contained inside of...
LLVM_ABI const GlobalObject * getAliaseeObject() const
Definition Globals.cpp:521
LLVM_ABI const DataLayout & getDataLayout() const
Get the data layout of the module this global belongs to.
Definition Globals.cpp:205
bool hasCommonLinkage() const
static bool isWeakForLinker(LinkageTypes Linkage)
Whether the definition of this global may be replaced at link time.
@ PrivateLinkage
Like Internal, but omit from symbol table.
Definition GlobalValue.h:61
@ CommonLinkage
Tentative definitions.
Definition GlobalValue.h:63
@ InternalLinkage
Rename collisions when linking (static functions).
Definition GlobalValue.h:60
@ LinkOnceAnyLinkage
Keep one copy of function when linking (inline)
Definition GlobalValue.h:55
@ WeakODRLinkage
Same, but only replaced by something equivalent.
Definition GlobalValue.h:58
@ ExternalLinkage
Externally visible function.
Definition GlobalValue.h:53
@ WeakAnyLinkage
Keep one copy of named function when linking (weak)
Definition GlobalValue.h:57
@ AppendingLinkage
Special purpose, only applies to global arrays.
Definition GlobalValue.h:59
@ AvailableExternallyLinkage
Available for inspection, not emission.
Definition GlobalValue.h:54
@ ExternalWeakLinkage
ExternalWeak linkage description.
Definition GlobalValue.h:62
@ LinkOnceODRLinkage
Same, but only replaced by something equivalent.
Definition GlobalValue.h:56
LLVM_ABI void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
static bool isSectionAtomizableBySymbols(const MCSection &Section)
True if the section is atomized using the symbols in it.
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition MCAsmInfo.h:67
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition MCExpr.h:342
static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition MCExpr.h:427
static LLVM_ABI const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition MCExpr.cpp:212
Context object for machine code objects.
Definition MCContext.h:83
LLVM_ABI MCSectionMachO * getMachOSection(StringRef Segment, StringRef Section, unsigned TypeAndAttributes, unsigned Reserved2, SectionKind K, const char *BeginSymName=nullptr)
Return the MCSection for the specified mach-o section.
LLVM_ABI MCSectionCOFF * getCOFFSection(StringRef Section, unsigned Characteristics, StringRef COMDATSymName, int Selection, unsigned UniqueID=MCSection::NonUniqueID)
MCSectionWasm * getWasmSection(const Twine &Section, SectionKind K, unsigned Flags=0)
Definition MCContext.h:640
LLVM_ABI MCSectionELF * getELFNamedSection(const Twine &Prefix, const Twine &Suffix, unsigned Type, unsigned Flags, unsigned EntrySize=0)
Get a section with the provided group identifier.
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition MCContext.h:552
LLVM_ABI MCSectionXCOFF * getXCOFFSection(StringRef Section, SectionKind K, std::optional< XCOFF::CsectProperties > CsectProp=std::nullopt, bool MultiSymbolsAllowed=false, std::optional< XCOFF::DwarfSectionSubtypeFlags > DwarfSubtypeFlags=std::nullopt)
LLVM_ABI MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Base class for the full range of assembler expressions which are needed for parsing.
Definition MCExpr.h:34
MCSection * TLSBSSSection
Section directive for Thread Local uninitialized data.
MCSection * TextSection
Section directive for standard text.
MCSection * TLSDataSection
Section directive for Thread Local data. ELF, MachO, COFF, and Wasm.
MCSection * LSDASection
If exception handling is supported by the target, this is the section the Language Specific Data Area...
MCSection * FourByteConstantSection
MCSection * getDrectveSection() const
bool isPositionIndependent() const
MCSection * SixteenByteConstantSection
MCSection * ReadOnlySection
Section that is readonly and can contain arbitrary initialized data.
MCSection * BSSSection
Section that is default initialized to zero.
MCSection * EightByteConstantSection
MCContext & getContext() const
MCSection * DataSection
Section directive for standard data.
This represents a section on Windows.
MCSymbol * getCOMDATSymbol() const
This represents a section on linux, lots of unix variants and some bare metal systems.
unsigned getFlags() const
void setName(StringRef SectionName)
MCSectionGOFF * getParent() const
This represents a section on a Mach-O system (used by Mac OS X).
static Error ParseSectionSpecifier(StringRef Spec, StringRef &Segment, StringRef &Section, unsigned &TAA, bool &TAAParsed, unsigned &StubSize)
Parse the section specifier indicated by "Spec".
unsigned getTypeAndAttributes() const
unsigned getStubSize() const
This represents a section on wasm.
MCSymbolXCOFF * getQualNameSymbol() const
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition MCSection.h:580
void setAlignment(Align Value)
Definition MCSection.h:665
static constexpr unsigned NonUniqueID
Definition MCSection.h:585
void setBeginSymbol(MCSymbol *Sym)
Definition MCSection.h:657
StringRef getName() const
Definition MCSection.h:650
static const MCSpecifierExpr * create(const MCExpr *Expr, Spec S, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition MCExpr.cpp:743
Streaming machine code generation interface.
Definition MCStreamer.h:222
void setWeak(bool Value=true)
void setExternal(bool Value) const
void setCodeData(GOFF::ESDExecutable Value)
void setADA(MCSectionGOFF *AssociatedDataArea)
void setLinkage(GOFF::ESDLinkageType Value)
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition MCExpr.h:213
void setEHInfo() const
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition MCSymbol.h:42
StringRef getName() const
getName - Get the symbol name.
Definition MCSymbol.h:188
int64_t getConstant() const
Definition MCValue.h:44
const MCSymbol * getSubSym() const
Definition MCValue.h:51
Metadata node.
Definition Metadata.h:1081
const MDOperand & getOperand(unsigned I) const
Definition Metadata.h:1437
Metadata * get() const
Definition Metadata.h:931
unsigned getFunctionNumber() const
getFunctionNumber - Return a unique ID for the current function.
MCContext & getContext() const
Function & getFunction()
Return the LLVM function that this machine code represents.
const std::vector< LandingPadInfo > & getLandingPads() const
Return a reference to the landing pad info for the current function.
MachineModuleInfoELF - This is a MachineModuleInfoImpl implementation for ELF targets.
StubValueTy & getGVStubEntry(MCSymbol *Sym)
PointerIntPair< MCSymbol *, 1, bool > StubValueTy
MachineModuleInfoMachO - This is a MachineModuleInfoImpl implementation for MachO targets.
StubValueTy & getGVStubEntry(MCSymbol *Sym)
This class contains meta information specific to a module.
const Module * getModule() const
Ty & getObjFileInfo()
Keep track of various per-module pieces of information for backends that would like to do so.
LLVM_ABI void getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV, bool CannotUsePrivateLabel) const
Print the appropriate prefix and the specified global variable's name.
Definition Mangler.cpp:121
A Module instance is used to store all the information related to an LLVM module.
Definition Module.h:68
const Triple & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition Module.h:328
@ Require
Adds a requirement that another module flag be present and have a specified value after linking is pe...
Definition Module.h:134
const std::string & getSourceFileName() const
Get the module's original source file name.
Definition Module.h:310
GlobalValue * getNamedValue(StringRef Name) const
Return the global value in the module with the specified name, of arbitrary type.
Definition Module.cpp:177
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition Module.h:325
A tuple of MDNodes.
Definition Metadata.h:1800
PointerTy getPointer() const
SectionKind - This is a simple POD value that classifies the properties of a section.
Definition SectionKind.h:22
static SectionKind getThreadData()
static SectionKind getMetadata()
bool isThreadBSSLocal() const
static SectionKind getText()
bool isBSSLocal() const
static SectionKind getData()
bool isText() const
static SectionKind getBSS()
static SectionKind getThreadBSS()
static SectionKind getReadOnly()
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition SmallString.h:28
bool starts_with(StringRef Prefix) const
starts_with - Check if this string starts with the given Prefix.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
static LLVM_ABI bool shouldPreserveHotDataSectionPrefix(const LLVMContext &C)
Return -preserve-hot-data-section-prefix.
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition StringRef.h:597
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition StringRef.h:258
constexpr bool empty() const
Check if the string is empty.
Definition StringRef.h:141
constexpr size_t size() const
Get the string size.
Definition StringRef.h:144
bool ends_with(StringRef Suffix) const
Check if this string ends with the given Suffix.
Definition StringRef.h:270
void initialize(MCContext &Ctx, const TargetMachine &TM, const Module &M) override
This method must be called before any actual lowering is done.
MCSection * getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
Targets should implement this method to assign a section to globals with an explicit section specfied...
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
MCSection * getStaticCtorSection(unsigned Priority, const MCSymbol *KeySym) const override
const MCExpr * lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS, int64_t Addend, std::optional< int64_t > PCRelativeOffset, const TargetMachine &TM) const override
bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const override
MCSection * getNamedSection(StringRef Name, SectionKind Kind) const override
Get a section with the given name and kind, using format-appropriate defaults for section flags.
void getNameWithPrefix(SmallVectorImpl< char > &OutName, const GlobalValue *GV, const TargetMachine &TM) const override
MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment, const Function *F) const override
Given a mergeable constant with the specified size and relocation information, return a section that ...
void emitModuleMetadata(MCStreamer &Streamer, const Module &M) const override
Emit Obj-C garbage collection and linker options.
MCSection * getStaticDtorSection(unsigned Priority, const MCSymbol *KeySym) const override
MCSection * getSectionForJumpTable(const Function &F, const TargetMachine &TM) const override
void emitLinkerDirectives(MCStreamer &Streamer, const Module &M) const override
Process linker options metadata and emit platform-specific bits.
MCSection * getUniqueSectionForFunction(const Function &F, const TargetMachine &TM) const override
MCSection * getStaticCtorSection(unsigned Priority, const MCSymbol *KeySym) const override
MCSection * getSectionForJumpTable(const Function &F, const TargetMachine &TM) const override
MCSection * getSectionForConstantImpl(const DataLayout &DL, SectionKind Kind, const Constant *C, StringRef SectionSuffix) const
void emitModuleMetadata(MCStreamer &Streamer, const Module &M) const override
Emit Obj-C garbage collection and linker options.
MCSymbol * getCFIPersonalitySymbol(const GlobalValue *GV, const TargetMachine &TM, MachineModuleInfo *MMI) const override
MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment, const Function *F) const override
Given a constant with the SectionKind, return a section that it should be placed in.
MCSection * getStaticDtorSection(unsigned Priority, const MCSymbol *KeySym) const override
void emitPersonalityValue(MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym, const MachineModuleInfo *MMI) const override
void emitLinkerDirectives(MCStreamer &Streamer, const Module &M) const override
Process linker options metadata and emit platform-specific bits.
const MCExpr * getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM, MachineModuleInfo *MMI, MCStreamer &Streamer) const override
Return an MCExpr to use for a reference to the specified type info global variable from exception han...
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
const MCExpr * lowerSymbolDifference(const MCSymbol *LHS, const MCSymbol *RHS, int64_t Addend, std::optional< int64_t > PCRelativeOffset) const
MCSection * getNamedSection(StringRef Name, SectionKind Kind) const override
Get a section with the given name and kind, using format-appropriate defaults for section flags.
const MCExpr * lowerDSOLocalEquivalent(const MCSymbol *LHS, const MCSymbol *RHS, int64_t Addend, std::optional< int64_t > PCRelativeOffset, const TargetMachine &TM) const override
MCSection * getSectionForCommandLines() const override
If supported, return the section to use for the llvm.commandline metadata.
MCSection * getSectionForLSDA(const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const override
void initialize(MCContext &Ctx, const TargetMachine &TM, const Module &M) override
This method must be called before any actual lowering is done.
virtual void emitPersonalityValueImpl(MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym, const MachineModuleInfo *MMI) const
bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const override
bool isLargeConstant(const DataLayout &DL, SectionKind Kind, const Constant *C) const
Given a mergeable constant with the specified size and relocation information, return a section that ...
MCSection * getSectionForMachineBasicBlock(const Function &F, const MachineBasicBlock &MBB, const TargetMachine &TM) const override
Returns a unique section for the given machine basic block.
MCSection * getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
Targets should implement this method to assign a section to globals with an explicit section specfied...
void initialize(MCContext &Ctx, const TargetMachine &TM, const Module &M) override
This method must be called before any actual lowering is done.
MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment, const Function *F) const override
Given a constant with the SectionKind, return a section that it should be placed in.
MCSection * getStaticXtorSection(unsigned Priority) const
MCSection * getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
Targets should implement this method to assign a section to globals with an explicit section specfied...
MCSection * getSectionForLSDA(const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const override
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const override
void getNameWithPrefix(SmallVectorImpl< char > &OutName, const GlobalValue *GV, const TargetMachine &TM) const override
MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment, const Function *F) const override
Given a constant with the SectionKind, return a section that it should be placed in.
MCSymbol * getCFIPersonalitySymbol(const GlobalValue *GV, const TargetMachine &TM, MachineModuleInfo *MMI) const override
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
MCSection * getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
Targets should implement this method to assign a section to globals with an explicit section specfied...
void emitModuleMetadata(MCStreamer &Streamer, const Module &M) const override
Emit the module flags that specify the garbage collection information.
const MCExpr * getIndirectSymViaGOTPCRel(const GlobalValue *GV, const MCSymbol *Sym, const MCValue &MV, int64_t Offset, MachineModuleInfo *MMI, MCStreamer &Streamer) const override
Get MachO PC relative GOT entry relocation.
MCSection * getSectionForCommandLines() const override
If supported, return the section to use for the llvm.commandline metadata.
void emitLinkerDirectives(MCStreamer &Streamer, const Module &M) const override
Process linker options metadata and emit platform-specific bits.
void initialize(MCContext &Ctx, const TargetMachine &TM, const Module &M) override
This method must be called before any actual lowering is done.
MCSection * getStaticDtorSection(unsigned Priority, const MCSymbol *KeySym) const override
const MCExpr * getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM, MachineModuleInfo *MMI, MCStreamer &Streamer) const override
The mach-o version of this method defaults to returning a stub reference.
MCSection * getNamedSection(StringRef Name, SectionKind Kind) const override
Get a section with the given name and kind, using format-appropriate defaults for section flags.
MCSection * getStaticCtorSection(unsigned Priority, const MCSymbol *KeySym) const override
MCSection * getNamedSection(StringRef Name, SectionKind Kind) const override
Get a section with the given name and kind, using format-appropriate defaults for section flags.
void initialize(MCContext &Ctx, const TargetMachine &TM, const Module &M) override
This method must be called before any actual lowering is done.
bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const override
MCSection * getStaticDtorSection(unsigned Priority, const MCSymbol *KeySym) const override
MCSection * getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
Targets should implement this method to assign a section to globals with an explicit section specfied...
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
static bool ShouldSetSSPCanaryBitInTB(const MachineFunction *MF)
MCSection * getSectionForTOCEntry(const MCSymbol *Sym, const TargetMachine &TM) const override
On targets that support TOC entries, return a section for the entry given the symbol it refers to.
MCSection * getSectionForExternalReference(const GlobalObject *GO, const TargetMachine &TM) const override
For external functions, this will always return a function descriptor csect.
void initialize(MCContext &Ctx, const TargetMachine &TM, const Module &M) override
This method must be called before any actual lowering is done.
MCSymbol * getFunctionEntryPointSymbol(const GlobalValue *Func, const TargetMachine &TM) const override
If supported, return the function entry point symbol.
bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const override
MCSection * getSectionForJumpTable(const Function &F, const TargetMachine &TM) const override
static MCSymbol * getEHInfoTableSymbol(const MachineFunction *MF)
MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment, const Function *F) const override
Given a constant with the SectionKind, return a section that it should be placed in.
MCSection * getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
Targets should implement this method to assign a section to globals with an explicit section specfied...
MCSection * getStaticCtorSection(unsigned Priority, const MCSymbol *KeySym) const override
static XCOFF::StorageClass getStorageClassForGlobal(const GlobalValue *GV)
MCSymbol * getTargetSymbol(const GlobalValue *GV, const TargetMachine &TM) const override
For functions, this will always return a function descriptor symbol.
MCSection * getSectionForFunctionDescriptor(const GlobalObject *F, const TargetMachine &TM) const override
On targets that use separate function descriptor symbols, return a section for the descriptor given i...
static bool ShouldEmitEHBlock(const MachineFunction *MF)
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
MCSection * getStaticDtorSection(unsigned Priority, const MCSymbol *KeySym) const override
MCSection * getSectionForLSDA(const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const override
For functions, this will return the LSDA section.
virtual void getNameWithPrefix(SmallVectorImpl< char > &OutName, const GlobalValue *GV, const TargetMachine &TM) const
MCSection * StaticDtorSection
This section contains the static destructor pointer list.
unsigned PersonalityEncoding
PersonalityEncoding, LSDAEncoding, TTypeEncoding - Some encoding values for EH.
void emitCGProfileMetadata(MCStreamer &Streamer, const Module &M) const
Emit Call Graph Profile metadata.
static SectionKind getKindForGlobal(const GlobalObject *GO, const TargetMachine &TM)
Classify the specified global variable into a set of target independent categories embodied in Sectio...
virtual bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const
virtual void initialize(MCContext &ctx, const TargetMachine &TM, const Module &M)
This method must be called before any actual lowering is done.
MCSection * StaticCtorSection
This section contains the static constructor pointer list.
virtual MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment, const Function *F) const
Given a constant with the SectionKind, return a section that it should be placed in.
static StringRef getCustomSectionName(const GlobalObject *GO, const TargetMachine &TM)
Return the section name specified by 'pragma clang section' or the section attribute.
MCSymbol * getSymbolWithGlobalValueBase(const GlobalValue *GV, StringRef Suffix, const TargetMachine &TM) const
Return the MCSymbol for a private symbol with global value name as its base, with the specified suffi...
virtual const MCExpr * getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM, MachineModuleInfo *MMI, MCStreamer &Streamer) const
Return an MCExpr to use for a reference to the specified global variable from exception handling info...
void emitPseudoProbeDescMetadata(MCStreamer &Streamer, const Module &M, std::function< void(MCStreamer &Streamer)> COMDATSymEmitter=nullptr) const
Emit pseudo_probe_desc metadata.
const MCExpr * getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding, MCStreamer &Streamer) const
MCSection * SectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const
This method computes the appropriate section to emit the specified global variable or function defini...
Primary interface to the complete machine description for the target machine.
const Triple & getTargetTriple() const
bool getSeparateNamedSections() const
bool getUniqueSectionNames() const
bool getEnableStaticDataPartitioning() const
TargetOptions Options
MCSymbol * getSymbol(const GlobalValue *GV) const
CodeModel::Model getCodeModel() const
Returns the code model.
bool isLargeGlobalValue(const GlobalValue *GV) const
void getNameWithPrefix(SmallVectorImpl< char > &Name, const GlobalValue *GV, Mangler &Mang, bool MayAlwaysUsePrivate=false) const
unsigned UseInitArray
UseInitArray - Use .init_array instead of .ctors for static constructors.
MCTargetOptions MCOptions
Machine level options.
Triple - Helper class for working with autoconf configuration names.
Definition Triple.h:48
@ loongarch32
Definition Triple.h:65
@ loongarch64
Definition Triple.h:66
bool isOSSolaris() const
Definition Triple.h:757
ArchType getArch() const
Get the parsed architecture type of this triple.
Definition Triple.h:517
bool isOSFreeBSD() const
Definition Triple.h:751
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
LLVM_ABI std::string str() const
Return the twine contents as a std::string.
Definition Twine.cpp:17
Twine concat(const Twine &Suffix) const
Definition Twine.h:497
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:46
LLVM Value Representation.
Definition Value.h:75
LLVMContext & getContext() const
All values hold a context through their type.
Definition Value.h:260
bool hasName() const
Definition Value.h:263
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
Definition Value.cpp:314
A raw_ostream that writes to an std::string.
A raw_ostream that writes to an SmallVector or SmallString.
CallInst * Retain
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
SectionCharacteristics
Definition COFF.h:298
@ IMAGE_SCN_LNK_REMOVE
Definition COFF.h:308
@ IMAGE_SCN_CNT_CODE
Definition COFF.h:303
@ IMAGE_SCN_MEM_READ
Definition COFF.h:336
@ IMAGE_SCN_MEM_EXECUTE
Definition COFF.h:335
@ IMAGE_SCN_CNT_UNINITIALIZED_DATA
Definition COFF.h:305
@ IMAGE_SCN_MEM_DISCARDABLE
Definition COFF.h:331
@ IMAGE_SCN_MEM_16BIT
Definition COFF.h:312
@ IMAGE_SCN_CNT_INITIALIZED_DATA
Definition COFF.h:304
@ IMAGE_SCN_LNK_COMDAT
Definition COFF.h:309
@ IMAGE_SCN_MEM_WRITE
Definition COFF.h:337
@ IMAGE_COMDAT_SELECT_NODUPLICATES
Definition COFF.h:455
@ IMAGE_COMDAT_SELECT_LARGEST
Definition COFF.h:460
@ IMAGE_COMDAT_SELECT_SAME_SIZE
Definition COFF.h:457
@ IMAGE_COMDAT_SELECT_ASSOCIATIVE
Definition COFF.h:459
@ IMAGE_COMDAT_SELECT_EXACT_MATCH
Definition COFF.h:458
@ IMAGE_COMDAT_SELECT_ANY
Definition COFF.h:456
@ SHF_MERGE
Definition ELF.h:1104
@ SHF_STRINGS
Definition ELF.h:1107
@ SHF_AARCH64_PURECODE
Definition ELF.h:1196
@ SHF_EXCLUDE
Definition ELF.h:1132
@ SHF_ALLOC
Definition ELF.h:1098
@ SHF_LINK_ORDER
Definition ELF.h:1113
@ SHF_GROUP
Definition ELF.h:1120
@ SHF_SUNW_NODISCARD
Definition ELF.h:1139
@ SHF_X86_64_LARGE
Definition ELF.h:1161
@ SHF_GNU_RETAIN
Definition ELF.h:1129
@ SHF_WRITE
Definition ELF.h:1095
@ SHF_TLS
Definition ELF.h:1123
@ SHF_ARM_PURECODE
Definition ELF.h:1193
@ SHF_EXECINSTR
Definition ELF.h:1101
@ SHT_LLVM_DEPENDENT_LIBRARIES
Definition ELF.h:1027
@ SHT_PROGBITS
Definition ELF.h:996
@ SHT_LLVM_LINKER_OPTIONS
Definition ELF.h:1024
@ SHT_NOBITS
Definition ELF.h:1003
@ SHT_LLVM_OFFLOADING
Definition ELF.h:1035
@ SHT_LLVM_LTO
Definition ELF.h:1036
@ SHT_PREINIT_ARRAY
Definition ELF.h:1009
@ SHT_INIT_ARRAY
Definition ELF.h:1007
@ SHT_NOTE
Definition ELF.h:1002
@ SHT_FINI_ARRAY
Definition ELF.h:1008
@ ESD_LB_Deferred
Definition GOFF.h:129
@ ESD_LB_Initial
Definition GOFF.h:128
constexpr StringLiteral CLASS_WSA
@ ESD_BA_Merge
Definition GOFF.h:99
@ ESD_TS_ByteOriented
Definition GOFF.h:92
@ ESD_EXE_CODE
Definition GOFF.h:112
@ ESD_EXE_DATA
Definition GOFF.h:111
@ ESD_RQ_0
Definition GOFF.h:69
@ ESD_ALIGN_Doubleword
Definition GOFF.h:148
ESDBindingScope
Definition GOFF.h:134
@ ESD_BSC_Library
Definition GOFF.h:138
@ ESD_BSC_Unspecified
Definition GOFF.h:135
@ ESD_BSC_ImportExport
Definition GOFF.h:139
@ ESD_BSC_Section
Definition GOFF.h:136
constexpr StringLiteral CLASS_SINIT
@ ESD_LT_XPLink
Definition GOFF.h:142
@ ESD_NS_Parts
Definition GOFF.h:65
@ ESD_TA_Unspecified
Definition GOFF.h:103
@ ESD_BST_Strong
Definition GOFF.h:123
@ ESD_RMODE_64
Definition GOFF.h:88
@ S_MOD_TERM_FUNC_POINTERS
S_MOD_TERM_FUNC_POINTERS - Section with only function pointers for termination.
Definition MachO.h:150
@ S_MOD_INIT_FUNC_POINTERS
S_MOD_INIT_FUNC_POINTERS - Section with only function pointers for initialization.
Definition MachO.h:147
@ C_WEAKEXT
Definition XCOFF.h:200
StorageMappingClass
Storage Mapping Class definitions.
Definition XCOFF.h:104
@ XMC_TE
Symbol mapped at the end of TOC.
Definition XCOFF.h:129
@ XMC_DS
Descriptor csect.
Definition XCOFF.h:122
@ XMC_RW
Read Write Data.
Definition XCOFF.h:118
@ XMC_TL
Initialized thread-local variable.
Definition XCOFF.h:127
@ XMC_RO
Read Only Constant.
Definition XCOFF.h:107
@ XMC_UA
Unclassified - Treated as Read Write.
Definition XCOFF.h:123
@ XMC_TD
Scalar data item in the TOC.
Definition XCOFF.h:121
@ XMC_UL
Uninitialized thread-local variable.
Definition XCOFF.h:128
@ XMC_PR
Program Code.
Definition XCOFF.h:106
@ XMC_BS
BSS class (uninitialized static internal)
Definition XCOFF.h:124
@ XMC_TC
General TOC item.
Definition XCOFF.h:120
@ XTY_CM
Common csect definition. For uninitialized storage.
Definition XCOFF.h:246
@ XTY_SD
Csect definition for initialized storage.
Definition XCOFF.h:243
@ XTY_ER
External reference.
Definition XCOFF.h:242
initializer< Ty > init(const Ty &Val)
Calculates the starting offsets for various sections within the .debug_names section.
Definition Dwarf.h:35
@ DW_EH_PE_datarel
Definition Dwarf.h:984
@ DW_EH_PE_pcrel
Definition Dwarf.h:982
@ DW_EH_PE_sdata4
Definition Dwarf.h:979
@ DW_EH_PE_sdata8
Definition Dwarf.h:980
@ DW_EH_PE_absptr
Definition Dwarf.h:971
@ DW_EH_PE_udata4
Definition Dwarf.h:975
@ DW_EH_PE_udata8
Definition Dwarf.h:976
@ DW_EH_PE_indirect
Definition Dwarf.h:987
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > dyn_extract(Y &&MD)
Extract a Value from Metadata, if any.
Definition Metadata.h:707
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract(Y &&MD)
Extract a Value from Metadata.
Definition Metadata.h:679
LLVM_ABI StringRef stem(StringRef path LLVM_LIFETIME_BOUND, Style style=Style::native)
Get stem.
Definition Path.cpp:596
@ WASM_SEG_FLAG_RETAIN
Definition Wasm.h:242
@ WASM_SEG_FLAG_TLS
Definition Wasm.h:241
@ WASM_SEG_FLAG_STRINGS
Definition Wasm.h:240
This is an optimization pass for GlobalISel generic memory operations.
@ Offset
Definition DWP.cpp:577
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:643
std::string utostr(uint64_t X, bool isNeg=false)
bool isa_and_nonnull(const Y &Val)
Definition Casting.h:676
LLVM_ABI std::string getInstrProfSectionName(InstrProfSectKind IPSK, Triple::ObjectFormatType OF, bool AddSegmentInfo=true)
Return the name of the profile section corresponding to IPSK.
@ DK_Lowering
bool isNoOpWithoutInvoke(EHPersonality Pers)
Return true if this personality may be safely removed if there are no invoke instructions remaining i...
auto dyn_cast_or_null(const Y &Val)
Definition Casting.h:753
OutputIt transform(R &&Range, OutputIt d_first, UnaryFunction F)
Wrapper function around std::transform to apply a function to a range and store the result elsewhere.
Definition STLExtras.h:2042
std::string encodeBase64(InputBytes const &Bytes)
Definition Base64.h:24
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
Definition Error.cpp:163
LLVM_ABI EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
LLVM_ABI void emitLinkerFlagsForUsedCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &T, Mangler &M)
Definition Mangler.cpp:278
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
Definition Casting.h:547
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition Format.h:102
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
DWARFExpression::Operation Op
std::string toString(const APInt &I, unsigned Radix, bool Signed, bool formatAsCLiteral=false, bool UpperCase=true, bool InsertSeparators=false)
DiagnosticSeverity
Defines the different supported severity of a diagnostic.
LLVM_ABI void emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &TT, Mangler &Mangler)
Definition Mangler.cpp:214
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:559
LLVM_ABI cl::opt< std::string > BBSectionsColdTextPrefix
@ MCSA_Weak
.weak
@ MCSA_Global
.type _foo, @gnu_unique_object
@ MCSA_ELF_TypeObject
.type _foo, STT_OBJECT # aka @object
@ MCSA_Hidden
.hidden (ELF)
LLVM_ABI GlobalVariable * collectUsedGlobalVariables(const Module &M, SmallVectorImpl< GlobalValue * > &Vec, bool CompilerUsed)
Given "llvm.used" or "llvm.compiler.used" as a global name, collect the initializer elements of that ...
Definition Module.cpp:991
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition Alignment.h:39
LLVM_ABI static const MBBSectionID ExceptionSectionID
LLVM_ABI static const MBBSectionID ColdSectionID
MachineJumpTableEntry - One jump table in the jump table info.
MachineFunctionDataHotness Hotness
The hotness of MJTE is inferred from the hotness of the source basic block(s) that reference it.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition Alignment.h:111