LLVM 19.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"
29#include "llvm/IR/Comdat.h"
30#include "llvm/IR/Constants.h"
31#include "llvm/IR/DataLayout.h"
35#include "llvm/IR/Function.h"
36#include "llvm/IR/GlobalAlias.h"
38#include "llvm/IR/GlobalValue.h"
40#include "llvm/IR/Mangler.h"
41#include "llvm/IR/Metadata.h"
42#include "llvm/IR/Module.h"
43#include "llvm/IR/PseudoProbe.h"
44#include "llvm/IR/Type.h"
45#include "llvm/MC/MCAsmInfo.h"
46#include "llvm/MC/MCContext.h"
47#include "llvm/MC/MCExpr.h"
54#include "llvm/MC/MCStreamer.h"
55#include "llvm/MC/MCSymbol.h"
56#include "llvm/MC/MCSymbolELF.h"
57#include "llvm/MC/MCValue.h"
58#include "llvm/MC/SectionKind.h"
60#include "llvm/Support/Base64.h"
64#include "llvm/Support/Format.h"
68#include <cassert>
69#include <string>
70
71using namespace llvm;
72using namespace dwarf;
73
75 "jumptable-in-function-section", cl::Hidden, cl::init(false),
76 cl::desc("Putting Jump Table in function section"));
77
78static void GetObjCImageInfo(Module &M, unsigned &Version, unsigned &Flags,
79 StringRef &Section) {
81 M.getModuleFlagsMetadata(ModuleFlags);
82
83 for (const auto &MFE: ModuleFlags) {
84 // Ignore flags with 'Require' behaviour.
85 if (MFE.Behavior == Module::Require)
86 continue;
87
88 StringRef Key = MFE.Key->getString();
89 if (Key == "Objective-C Image Info Version") {
90 Version = mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
91 } else if (Key == "Objective-C Garbage Collection" ||
92 Key == "Objective-C GC Only" ||
93 Key == "Objective-C Is Simulated" ||
94 Key == "Objective-C Class Properties" ||
95 Key == "Objective-C Image Swift Version") {
96 Flags |= mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
97 } else if (Key == "Objective-C Image Info Section") {
98 Section = cast<MDString>(MFE.Val)->getString();
99 }
100 // Backend generates L_OBJC_IMAGE_INFO from Swift ABI version + major + minor +
101 // "Objective-C Garbage Collection".
102 else if (Key == "Swift ABI Version") {
103 Flags |= (mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue()) << 8;
104 } else if (Key == "Swift Major Version") {
105 Flags |= (mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue()) << 24;
106 } else if (Key == "Swift Minor Version") {
107 Flags |= (mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue()) << 16;
108 }
109 }
110}
111
112//===----------------------------------------------------------------------===//
113// ELF
114//===----------------------------------------------------------------------===//
115
118}
119
121 const TargetMachine &TgtM) {
123
124 CodeModel::Model CM = TgtM.getCodeModel();
126
127 switch (TgtM.getTargetTriple().getArch()) {
128 case Triple::arm:
129 case Triple::armeb:
130 case Triple::thumb:
131 case Triple::thumbeb:
133 break;
134 // Fallthrough if not using EHABI
135 [[fallthrough]];
136 case Triple::ppc:
137 case Triple::ppcle:
138 case Triple::x86:
151 break;
152 case Triple::x86_64:
153 if (isPositionIndependent()) {
155 ((CM == CodeModel::Small || CM == CodeModel::Medium)
158 (CM == CodeModel::Small
161 ((CM == CodeModel::Small || CM == CodeModel::Medium)
163 } else {
165 (CM == CodeModel::Small || CM == CodeModel::Medium)
171 }
172 break;
173 case Triple::hexagon:
177 if (isPositionIndependent()) {
181 }
182 break;
183 case Triple::aarch64:
186 // The small model guarantees static code/data size < 4GB, but not where it
187 // will be in memory. Most of these could end up >2GB away so even a signed
188 // pc-relative 32-bit address is insufficient, theoretically.
189 //
190 // Use DW_EH_PE_indirect even for -fno-pic to avoid copy relocations.
197 break;
198 case Triple::lanai:
202 break;
203 case Triple::mips:
204 case Triple::mipsel:
205 case Triple::mips64:
206 case Triple::mips64el:
207 // MIPS uses indirect pointer to refer personality functions and types, so
208 // that the eh_frame section can be read-only. DW.ref.personality will be
209 // generated for relocation.
211 // FIXME: The N64 ABI probably ought to use DW_EH_PE_sdata8 but we can't
212 // identify N64 from just a triple.
215 // We don't support PC-relative LSDA references in GAS so we use the default
216 // DW_EH_PE_absptr for those.
217
218 // FreeBSD must be explicit about the data size and using pcrel since it's
219 // assembler/linker won't do the automatic conversion that the Linux tools
220 // do.
221 if (TgtM.getTargetTriple().isOSFreeBSD()) {
224 }
225 break;
226 case Triple::ppc64:
227 case Triple::ppc64le:
233 break;
234 case Triple::sparcel:
235 case Triple::sparc:
236 if (isPositionIndependent()) {
242 } else {
246 }
248 break;
249 case Triple::riscv32:
250 case Triple::riscv64:
257 break;
258 case Triple::sparcv9:
260 if (isPositionIndependent()) {
265 } else {
268 }
269 break;
270 case Triple::systemz:
271 // All currently-defined code models guarantee that 4-byte PC-relative
272 // values will be in range.
273 if (isPositionIndependent()) {
279 } else {
283 }
284 break;
292 break;
293 default:
294 break;
295 }
296}
297
300 collectUsedGlobalVariables(M, Vec, false);
301 for (GlobalValue *GV : Vec)
302 if (auto *GO = dyn_cast<GlobalObject>(GV))
303 Used.insert(GO);
304}
305
307 Module &M) const {
308 auto &C = getContext();
309
310 if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
311 auto *S = C.getELFSection(".linker-options", ELF::SHT_LLVM_LINKER_OPTIONS,
313
314 Streamer.switchSection(S);
315
316 for (const auto *Operand : LinkerOptions->operands()) {
317 if (cast<MDNode>(Operand)->getNumOperands() != 2)
318 report_fatal_error("invalid llvm.linker.options");
319 for (const auto &Option : cast<MDNode>(Operand)->operands()) {
320 Streamer.emitBytes(cast<MDString>(Option)->getString());
321 Streamer.emitInt8(0);
322 }
323 }
324 }
325
326 if (NamedMDNode *DependentLibraries = M.getNamedMetadata("llvm.dependent-libraries")) {
327 auto *S = C.getELFSection(".deplibs", ELF::SHT_LLVM_DEPENDENT_LIBRARIES,
329
330 Streamer.switchSection(S);
331
332 for (const auto *Operand : DependentLibraries->operands()) {
333 Streamer.emitBytes(
334 cast<MDString>(cast<MDNode>(Operand)->getOperand(0))->getString());
335 Streamer.emitInt8(0);
336 }
337 }
338
339 if (NamedMDNode *FuncInfo = M.getNamedMetadata(PseudoProbeDescMetadataName)) {
340 // Emit a descriptor for every function including functions that have an
341 // available external linkage. We may not want this for imported functions
342 // that has code in another thinLTO module but we don't have a good way to
343 // tell them apart from inline functions defined in header files. Therefore
344 // we put each descriptor in a separate comdat section and rely on the
345 // linker to deduplicate.
346 for (const auto *Operand : FuncInfo->operands()) {
347 const auto *MD = cast<MDNode>(Operand);
348 auto *GUID = mdconst::dyn_extract<ConstantInt>(MD->getOperand(0));
349 auto *Hash = mdconst::dyn_extract<ConstantInt>(MD->getOperand(1));
350 auto *Name = cast<MDString>(MD->getOperand(2));
351 auto *S = C.getObjectFileInfo()->getPseudoProbeDescSection(
352 TM->getFunctionSections() ? Name->getString() : StringRef());
353
354 Streamer.switchSection(S);
355 Streamer.emitInt64(GUID->getZExtValue());
356 Streamer.emitInt64(Hash->getZExtValue());
357 Streamer.emitULEB128IntValue(Name->getString().size());
358 Streamer.emitBytes(Name->getString());
359 }
360 }
361
362 if (NamedMDNode *LLVMStats = M.getNamedMetadata("llvm.stats")) {
363 // Emit the metadata for llvm statistics into .llvm_stats section, which is
364 // formatted as a list of key/value pair, the value is base64 encoded.
365 auto *S = C.getObjectFileInfo()->getLLVMStatsSection();
366 Streamer.switchSection(S);
367 for (const auto *Operand : LLVMStats->operands()) {
368 const auto *MD = cast<MDNode>(Operand);
369 assert(MD->getNumOperands() % 2 == 0 &&
370 ("Operand num should be even for a list of key/value pair"));
371 for (size_t I = 0; I < MD->getNumOperands(); I += 2) {
372 // Encode the key string size.
373 auto *Key = cast<MDString>(MD->getOperand(I));
374 Streamer.emitULEB128IntValue(Key->getString().size());
375 Streamer.emitBytes(Key->getString());
376 // Encode the value into a Base64 string.
377 std::string Value = encodeBase64(
378 Twine(mdconst::dyn_extract<ConstantInt>(MD->getOperand(I + 1))
379 ->getZExtValue())
380 .str());
381 Streamer.emitULEB128IntValue(Value.size());
382 Streamer.emitBytes(Value);
383 }
384 }
385 }
386
387 unsigned Version = 0;
388 unsigned Flags = 0;
389 StringRef Section;
390
391 GetObjCImageInfo(M, Version, Flags, Section);
392 if (!Section.empty()) {
393 auto *S = C.getELFSection(Section, ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
394 Streamer.switchSection(S);
395 Streamer.emitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
396 Streamer.emitInt32(Version);
397 Streamer.emitInt32(Flags);
398 Streamer.addBlankLine();
399 }
400
401 emitCGProfileMetadata(Streamer, M);
402}
403
405 const GlobalValue *GV, const TargetMachine &TM,
406 MachineModuleInfo *MMI) const {
407 unsigned Encoding = getPersonalityEncoding();
408 if ((Encoding & 0x80) == DW_EH_PE_indirect)
409 return getContext().getOrCreateSymbol(StringRef("DW.ref.") +
410 TM.getSymbol(GV)->getName());
411 if ((Encoding & 0x70) == DW_EH_PE_absptr)
412 return TM.getSymbol(GV);
413 report_fatal_error("We do not support this DWARF encoding yet!");
414}
415
417 MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym) const {
418 SmallString<64> NameData("DW.ref.");
419 NameData += Sym->getName();
420 MCSymbolELF *Label =
421 cast<MCSymbolELF>(getContext().getOrCreateSymbol(NameData));
422 Streamer.emitSymbolAttribute(Label, MCSA_Hidden);
423 Streamer.emitSymbolAttribute(Label, MCSA_Weak);
424 unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
425 MCSection *Sec = getContext().getELFNamedSection(".data", Label->getName(),
426 ELF::SHT_PROGBITS, Flags, 0);
427 unsigned Size = DL.getPointerSize();
428 Streamer.switchSection(Sec);
429 Streamer.emitValueToAlignment(DL.getPointerABIAlignment(0));
432 Streamer.emitELFSize(Label, E);
433 Streamer.emitLabel(Label);
434
435 Streamer.emitSymbolValue(Sym, Size);
436}
437
439 const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
440 MachineModuleInfo *MMI, MCStreamer &Streamer) const {
441 if (Encoding & DW_EH_PE_indirect) {
443
444 MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", TM);
445
446 // Add information about the stub reference to ELFMMI so that the stub
447 // gets emitted by the asmprinter.
449 if (!StubSym.getPointer()) {
450 MCSymbol *Sym = TM.getSymbol(GV);
452 }
453
456 Encoding & ~DW_EH_PE_indirect, Streamer);
457 }
458
460 MMI, Streamer);
461}
462
464 // N.B.: The defaults used in here are not the same ones used in MC.
465 // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
466 // both gas and MC will produce a section with no flags. Given
467 // section(".eh_frame") gcc will produce:
468 //
469 // .section .eh_frame,"a",@progbits
470
471 if (Name == getInstrProfSectionName(IPSK_covmap, Triple::ELF,
472 /*AddSegmentInfo=*/false) ||
474 /*AddSegmentInfo=*/false) ||
476 /*AddSegmentInfo=*/false) ||
478 /*AddSegmentInfo=*/false) ||
479 Name == ".llvmbc" || Name == ".llvmcmd")
481
482 if (!Name.starts_with(".")) return K;
483
484 // Default implementation based on some magic section names.
485 if (Name == ".bss" || Name.starts_with(".bss.") ||
486 Name.starts_with(".gnu.linkonce.b.") ||
487 Name.starts_with(".llvm.linkonce.b.") || Name == ".sbss" ||
488 Name.starts_with(".sbss.") || Name.starts_with(".gnu.linkonce.sb.") ||
489 Name.starts_with(".llvm.linkonce.sb."))
490 return SectionKind::getBSS();
491
492 if (Name == ".tdata" || Name.starts_with(".tdata.") ||
493 Name.starts_with(".gnu.linkonce.td.") ||
494 Name.starts_with(".llvm.linkonce.td."))
496
497 if (Name == ".tbss" || Name.starts_with(".tbss.") ||
498 Name.starts_with(".gnu.linkonce.tb.") ||
499 Name.starts_with(".llvm.linkonce.tb."))
501
502 return K;
503}
504
506 return SectionName.consume_front(Prefix) &&
507 (SectionName.empty() || SectionName[0] == '.');
508}
509
511 // Use SHT_NOTE for section whose name starts with ".note" to allow
512 // emitting ELF notes from C variable declaration.
513 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77609
514 if (Name.starts_with(".note"))
515 return ELF::SHT_NOTE;
516
517 if (hasPrefix(Name, ".init_array"))
518 return ELF::SHT_INIT_ARRAY;
519
520 if (hasPrefix(Name, ".fini_array"))
521 return ELF::SHT_FINI_ARRAY;
522
523 if (hasPrefix(Name, ".preinit_array"))
525
526 if (hasPrefix(Name, ".llvm.offloading"))
528
529 if (K.isBSS() || K.isThreadBSS())
530 return ELF::SHT_NOBITS;
531
532 return ELF::SHT_PROGBITS;
533}
534
535static unsigned getELFSectionFlags(SectionKind K) {
536 unsigned Flags = 0;
537
538 if (!K.isMetadata() && !K.isExclude())
539 Flags |= ELF::SHF_ALLOC;
540
541 if (K.isExclude())
542 Flags |= ELF::SHF_EXCLUDE;
543
544 if (K.isText())
545 Flags |= ELF::SHF_EXECINSTR;
546
547 if (K.isExecuteOnly())
548 Flags |= ELF::SHF_ARM_PURECODE;
549
550 if (K.isWriteable())
551 Flags |= ELF::SHF_WRITE;
552
553 if (K.isThreadLocal())
554 Flags |= ELF::SHF_TLS;
555
556 if (K.isMergeableCString() || K.isMergeableConst())
557 Flags |= ELF::SHF_MERGE;
558
559 if (K.isMergeableCString())
560 Flags |= ELF::SHF_STRINGS;
561
562 return Flags;
563}
564
565static const Comdat *getELFComdat(const GlobalValue *GV) {
566 const Comdat *C = GV->getComdat();
567 if (!C)
568 return nullptr;
569
570 if (C->getSelectionKind() != Comdat::Any &&
571 C->getSelectionKind() != Comdat::NoDeduplicate)
572 report_fatal_error("ELF COMDATs only support SelectionKind::Any and "
573 "SelectionKind::NoDeduplicate, '" +
574 C->getName() + "' cannot be lowered.");
575
576 return C;
577}
578
580 const TargetMachine &TM) {
581 MDNode *MD = GO->getMetadata(LLVMContext::MD_associated);
582 if (!MD)
583 return nullptr;
584
585 auto *VM = cast<ValueAsMetadata>(MD->getOperand(0).get());
586 auto *OtherGV = dyn_cast<GlobalValue>(VM->getValue());
587 return OtherGV ? dyn_cast<MCSymbolELF>(TM.getSymbol(OtherGV)) : nullptr;
588}
589
590static unsigned getEntrySizeForKind(SectionKind Kind) {
591 if (Kind.isMergeable1ByteCString())
592 return 1;
593 else if (Kind.isMergeable2ByteCString())
594 return 2;
595 else if (Kind.isMergeable4ByteCString())
596 return 4;
597 else if (Kind.isMergeableConst4())
598 return 4;
599 else if (Kind.isMergeableConst8())
600 return 8;
601 else if (Kind.isMergeableConst16())
602 return 16;
603 else if (Kind.isMergeableConst32())
604 return 32;
605 else {
606 // We shouldn't have mergeable C strings or mergeable constants that we
607 // didn't handle above.
608 assert(!Kind.isMergeableCString() && "unknown string width");
609 assert(!Kind.isMergeableConst() && "unknown data width");
610 return 0;
611 }
612}
613
614/// Return the section prefix name used by options FunctionsSections and
615/// DataSections.
617 if (Kind.isText())
618 return IsLarge ? ".ltext" : ".text";
619 if (Kind.isReadOnly())
620 return IsLarge ? ".lrodata" : ".rodata";
621 if (Kind.isBSS())
622 return IsLarge ? ".lbss" : ".bss";
623 if (Kind.isThreadData())
624 return ".tdata";
625 if (Kind.isThreadBSS())
626 return ".tbss";
627 if (Kind.isData())
628 return IsLarge ? ".ldata" : ".data";
629 if (Kind.isReadOnlyWithRel())
630 return IsLarge ? ".ldata.rel.ro" : ".data.rel.ro";
631 llvm_unreachable("Unknown section kind");
632}
633
634static SmallString<128>
636 Mangler &Mang, const TargetMachine &TM,
637 unsigned EntrySize, bool UniqueSectionName) {
639 getSectionPrefixForGlobal(Kind, TM.isLargeGlobalValue(GO));
640 if (Kind.isMergeableCString()) {
641 // We also need alignment here.
642 // FIXME: this is getting the alignment of the character, not the
643 // alignment of the global!
644 Align Alignment = GO->getParent()->getDataLayout().getPreferredAlign(
645 cast<GlobalVariable>(GO));
646
647 Name += ".str";
648 Name += utostr(EntrySize);
649 Name += ".";
650 Name += utostr(Alignment.value());
651 } else if (Kind.isMergeableConst()) {
652 Name += ".cst";
653 Name += utostr(EntrySize);
654 }
655
656 bool HasPrefix = false;
657 if (const auto *F = dyn_cast<Function>(GO)) {
658 if (std::optional<StringRef> Prefix = F->getSectionPrefix()) {
659 raw_svector_ostream(Name) << '.' << *Prefix;
660 HasPrefix = true;
661 }
662 }
663
664 if (UniqueSectionName) {
665 Name.push_back('.');
666 TM.getNameWithPrefix(Name, GO, Mang, /*MayAlwaysUsePrivate*/true);
667 } else if (HasPrefix)
668 // For distinguishing between .text.${text-section-prefix}. (with trailing
669 // dot) and .text.${function-name}
670 Name.push_back('.');
671 return Name;
672}
673
674namespace {
675class LoweringDiagnosticInfo : public DiagnosticInfo {
676 const Twine &Msg;
677
678public:
679 LoweringDiagnosticInfo(const Twine &DiagMsg,
680 DiagnosticSeverity Severity = DS_Error)
681 : DiagnosticInfo(DK_Lowering, Severity), Msg(DiagMsg) {}
682 void print(DiagnosticPrinter &DP) const override { DP << Msg; }
683};
684}
685
686/// Calculate an appropriate unique ID for a section, and update Flags,
687/// EntrySize and NextUniqueID where appropriate.
688static unsigned
690 SectionKind Kind, const TargetMachine &TM,
691 MCContext &Ctx, Mangler &Mang, unsigned &Flags,
692 unsigned &EntrySize, unsigned &NextUniqueID,
693 const bool Retain, const bool ForceUnique) {
694 // Increment uniqueID if we are forced to emit a unique section.
695 // This works perfectly fine with section attribute or pragma section as the
696 // sections with the same name are grouped together by the assembler.
697 if (ForceUnique)
698 return NextUniqueID++;
699
700 // A section can have at most one associated section. Put each global with
701 // MD_associated in a unique section.
702 const bool Associated = GO->getMetadata(LLVMContext::MD_associated);
703 if (Associated) {
704 Flags |= ELF::SHF_LINK_ORDER;
705 return NextUniqueID++;
706 }
707
708 if (Retain) {
709 if (TM.getTargetTriple().isOSSolaris())
711 else if (Ctx.getAsmInfo()->useIntegratedAssembler() ||
712 Ctx.getAsmInfo()->binutilsIsAtLeast(2, 36))
713 Flags |= ELF::SHF_GNU_RETAIN;
714 return NextUniqueID++;
715 }
716
717 // If two symbols with differing sizes end up in the same mergeable section
718 // that section can be assigned an incorrect entry size. To avoid this we
719 // usually put symbols of the same size into distinct mergeable sections with
720 // the same name. Doing so relies on the ",unique ," assembly feature. This
721 // feature is not avalible until bintuils version 2.35
722 // (https://sourceware.org/bugzilla/show_bug.cgi?id=25380).
723 const bool SupportsUnique = Ctx.getAsmInfo()->useIntegratedAssembler() ||
724 Ctx.getAsmInfo()->binutilsIsAtLeast(2, 35);
725 if (!SupportsUnique) {
726 Flags &= ~ELF::SHF_MERGE;
727 EntrySize = 0;
729 }
730
731 const bool SymbolMergeable = Flags & ELF::SHF_MERGE;
732 const bool SeenSectionNameBefore =
734 // If this is the first ocurrence of this section name, treat it as the
735 // generic section
736 if (!SymbolMergeable && !SeenSectionNameBefore)
738
739 // Symbols must be placed into sections with compatible entry sizes. Generate
740 // unique sections for symbols that have not been assigned to compatible
741 // sections.
742 const auto PreviousID =
743 Ctx.getELFUniqueIDForEntsize(SectionName, Flags, EntrySize);
744 if (PreviousID)
745 return *PreviousID;
746
747 // If the user has specified the same section name as would be created
748 // implicitly for this symbol e.g. .rodata.str1.1, then we don't need
749 // to unique the section as the entry size for this symbol will be
750 // compatible with implicitly created sections.
751 SmallString<128> ImplicitSectionNameStem =
752 getELFSectionNameForGlobal(GO, Kind, Mang, TM, EntrySize, false);
753 if (SymbolMergeable &&
755 SectionName.starts_with(ImplicitSectionNameStem))
757
758 // We have seen this section name before, but with different flags or entity
759 // size. Create a new unique ID.
760 return NextUniqueID++;
761}
762
763static std::tuple<StringRef, bool, unsigned>
765 StringRef Group = "";
766 bool IsComdat = false;
767 unsigned Flags = 0;
768 if (const Comdat *C = getELFComdat(GO)) {
769 Flags |= ELF::SHF_GROUP;
770 Group = C->getName();
771 IsComdat = C->getSelectionKind() == Comdat::Any;
772 }
773 if (TM.isLargeGlobalValue(GO))
774 Flags |= ELF::SHF_X86_64_LARGE;
775 return {Group, IsComdat, Flags};
776}
777
779 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM,
780 MCContext &Ctx, Mangler &Mang, unsigned &NextUniqueID,
781 bool Retain, bool ForceUnique) {
783
784 // Check if '#pragma clang section' name is applicable.
785 // Note that pragma directive overrides -ffunction-section, -fdata-section
786 // and so section name is exactly as user specified and not uniqued.
787 const GlobalVariable *GV = dyn_cast<GlobalVariable>(GO);
788 if (GV && GV->hasImplicitSection()) {
789 auto Attrs = GV->getAttributes();
790 if (Attrs.hasAttribute("bss-section") && Kind.isBSS()) {
791 SectionName = Attrs.getAttribute("bss-section").getValueAsString();
792 } else if (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly()) {
793 SectionName = Attrs.getAttribute("rodata-section").getValueAsString();
794 } else if (Attrs.hasAttribute("relro-section") && Kind.isReadOnlyWithRel()) {
795 SectionName = Attrs.getAttribute("relro-section").getValueAsString();
796 } else if (Attrs.hasAttribute("data-section") && Kind.isData()) {
797 SectionName = Attrs.getAttribute("data-section").getValueAsString();
798 }
799 }
800 const Function *F = dyn_cast<Function>(GO);
801 if (F && F->hasFnAttribute("implicit-section-name")) {
802 SectionName = F->getFnAttribute("implicit-section-name").getValueAsString();
803 }
804
805 // Infer section flags from the section name if we can.
807
808 unsigned Flags = getELFSectionFlags(Kind);
809 auto [Group, IsComdat, ExtraFlags] = getGlobalObjectInfo(GO, TM);
810 Flags |= ExtraFlags;
811
812 unsigned EntrySize = getEntrySizeForKind(Kind);
813 const unsigned UniqueID = calcUniqueIDUpdateFlagsAndSize(
814 GO, SectionName, Kind, TM, Ctx, Mang, Flags, EntrySize, NextUniqueID,
815 Retain, ForceUnique);
816
817 const MCSymbolELF *LinkedToSym = getLinkedToSymbol(GO, TM);
818 MCSectionELF *Section = Ctx.getELFSection(
819 SectionName, getELFSectionType(SectionName, Kind), Flags, EntrySize,
820 Group, IsComdat, UniqueID, LinkedToSym);
821 // Make sure that we did not get some other section with incompatible sh_link.
822 // This should not be possible due to UniqueID code above.
823 assert(Section->getLinkedToSymbol() == LinkedToSym &&
824 "Associated symbol mismatch between sections");
825
826 if (!(Ctx.getAsmInfo()->useIntegratedAssembler() ||
827 Ctx.getAsmInfo()->binutilsIsAtLeast(2, 35))) {
828 // If we are using GNU as before 2.35, then this symbol might have
829 // been placed in an incompatible mergeable section. Emit an error if this
830 // is the case to avoid creating broken output.
831 if ((Section->getFlags() & ELF::SHF_MERGE) &&
832 (Section->getEntrySize() != getEntrySizeForKind(Kind)))
833 GO->getContext().diagnose(LoweringDiagnosticInfo(
834 "Symbol '" + GO->getName() + "' from module '" +
835 (GO->getParent() ? GO->getParent()->getSourceFileName() : "unknown") +
836 "' required a section with entry-size=" +
837 Twine(getEntrySizeForKind(Kind)) + " but was placed in section '" +
838 SectionName + "' with entry-size=" + Twine(Section->getEntrySize()) +
839 ": Explicit assignment by pragma or attribute of an incompatible "
840 "symbol to this section?"));
841 }
842
843 return Section;
844}
845
847 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
849 NextUniqueID, Used.count(GO),
850 /* ForceUnique = */false);
851}
852
854 MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
855 const TargetMachine &TM, bool EmitUniqueSection, unsigned Flags,
856 unsigned *NextUniqueID, const MCSymbolELF *AssociatedSymbol) {
857
858 auto [Group, IsComdat, ExtraFlags] = getGlobalObjectInfo(GO, TM);
859 Flags |= ExtraFlags;
860
861 // Get the section entry size based on the kind.
862 unsigned EntrySize = getEntrySizeForKind(Kind);
863
864 bool UniqueSectionName = false;
865 unsigned UniqueID = MCContext::GenericSectionID;
866 if (EmitUniqueSection) {
867 if (TM.getUniqueSectionNames()) {
868 UniqueSectionName = true;
869 } else {
870 UniqueID = *NextUniqueID;
871 (*NextUniqueID)++;
872 }
873 }
875 GO, Kind, Mang, TM, EntrySize, UniqueSectionName);
876
877 // Use 0 as the unique ID for execute-only text.
878 if (Kind.isExecuteOnly())
879 UniqueID = 0;
880 return Ctx.getELFSection(Name, getELFSectionType(Name, Kind), Flags,
881 EntrySize, Group, IsComdat, UniqueID,
882 AssociatedSymbol);
883}
884
886 MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
887 const TargetMachine &TM, bool Retain, bool EmitUniqueSection,
888 unsigned Flags, unsigned *NextUniqueID) {
889 const MCSymbolELF *LinkedToSym = getLinkedToSymbol(GO, TM);
890 if (LinkedToSym) {
891 EmitUniqueSection = true;
892 Flags |= ELF::SHF_LINK_ORDER;
893 }
894 if (Retain) {
895 if (TM.getTargetTriple().isOSSolaris()) {
896 EmitUniqueSection = true;
898 } else if (Ctx.getAsmInfo()->useIntegratedAssembler() ||
899 Ctx.getAsmInfo()->binutilsIsAtLeast(2, 36)) {
900 EmitUniqueSection = true;
901 Flags |= ELF::SHF_GNU_RETAIN;
902 }
903 }
904
906 Ctx, GO, Kind, Mang, TM, EmitUniqueSection, Flags,
907 NextUniqueID, LinkedToSym);
908 assert(Section->getLinkedToSymbol() == LinkedToSym);
909 return Section;
910}
911
913 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
914 unsigned Flags = getELFSectionFlags(Kind);
915
916 // If we have -ffunction-section or -fdata-section then we should emit the
917 // global value to a uniqued section specifically for it.
918 bool EmitUniqueSection = false;
919 if (!(Flags & ELF::SHF_MERGE) && !Kind.isCommon()) {
920 if (Kind.isText())
921 EmitUniqueSection = TM.getFunctionSections();
922 else
923 EmitUniqueSection = TM.getDataSections();
924 }
925 EmitUniqueSection |= GO->hasComdat();
926 return selectELFSectionForGlobal(getContext(), GO, Kind, getMangler(), TM,
927 Used.count(GO), EmitUniqueSection, Flags,
928 &NextUniqueID);
929}
930
932 const Function &F, const TargetMachine &TM) const {
934 unsigned Flags = getELFSectionFlags(Kind);
935 // If the function's section names is pre-determined via pragma or a
936 // section attribute, call selectExplicitSectionGlobal.
937 if (F.hasSection() || F.hasFnAttribute("implicit-section-name"))
939 &F, Kind, TM, getContext(), getMangler(), NextUniqueID,
940 Used.count(&F), /* ForceUnique = */true);
941 else
943 getContext(), &F, Kind, getMangler(), TM, Used.count(&F),
944 /*EmitUniqueSection=*/true, Flags, &NextUniqueID);
945}
946
948 const Function &F, const TargetMachine &TM) const {
949 // If the function can be removed, produce a unique section so that
950 // the table doesn't prevent the removal.
951 const Comdat *C = F.getComdat();
952 bool EmitUniqueSection = TM.getFunctionSections() || C;
953 if (!EmitUniqueSection)
954 return ReadOnlySection;
955
957 getMangler(), TM, EmitUniqueSection,
958 ELF::SHF_ALLOC, &NextUniqueID,
959 /* AssociatedSymbol */ nullptr);
960}
961
963 const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const {
964 // If neither COMDAT nor function sections, use the monolithic LSDA section.
965 // Re-use this path if LSDASection is null as in the Arm EHABI.
966 if (!LSDASection || (!F.hasComdat() && !TM.getFunctionSections()))
967 return LSDASection;
968
969 const auto *LSDA = cast<MCSectionELF>(LSDASection);
970 unsigned Flags = LSDA->getFlags();
971 const MCSymbolELF *LinkedToSym = nullptr;
972 StringRef Group;
973 bool IsComdat = false;
974 if (const Comdat *C = getELFComdat(&F)) {
975 Flags |= ELF::SHF_GROUP;
976 Group = C->getName();
977 IsComdat = C->getSelectionKind() == Comdat::Any;
978 }
979 // Use SHF_LINK_ORDER to facilitate --gc-sections if we can use GNU ld>=2.36
980 // or LLD, which support mixed SHF_LINK_ORDER & non-SHF_LINK_ORDER.
981 if (TM.getFunctionSections() &&
982 (getContext().getAsmInfo()->useIntegratedAssembler() &&
983 getContext().getAsmInfo()->binutilsIsAtLeast(2, 36))) {
984 Flags |= ELF::SHF_LINK_ORDER;
985 LinkedToSym = cast<MCSymbolELF>(&FnSym);
986 }
987
988 // Append the function name as the suffix like GCC, assuming
989 // -funique-section-names applies to .gcc_except_table sections.
990 return getContext().getELFSection(
991 (TM.getUniqueSectionNames() ? LSDA->getName() + "." + F.getName()
992 : LSDA->getName()),
993 LSDA->getType(), Flags, 0, Group, IsComdat, MCSection::NonUniqueID,
994 LinkedToSym);
995}
996
998 bool UsesLabelDifference, const Function &F) const {
999 // We can always create relative relocations, so use another section
1000 // that can be marked non-executable.
1001 return false;
1002}
1003
1004/// Given a mergeable constant with the specified size and relocation
1005/// information, return a section that it should be placed in.
1007 const DataLayout &DL, SectionKind Kind, const Constant *C,
1008 Align &Alignment) const {
1009 if (Kind.isMergeableConst4() && MergeableConst4Section)
1011 if (Kind.isMergeableConst8() && MergeableConst8Section)
1013 if (Kind.isMergeableConst16() && MergeableConst16Section)
1015 if (Kind.isMergeableConst32() && MergeableConst32Section)
1017 if (Kind.isReadOnly())
1018 return ReadOnlySection;
1019
1020 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
1021 return DataRelROSection;
1022}
1023
1024/// Returns a unique section for the given machine basic block.
1026 const Function &F, const MachineBasicBlock &MBB,
1027 const TargetMachine &TM) const {
1028 assert(MBB.isBeginSection() && "Basic block does not start a section!");
1029 unsigned UniqueID = MCContext::GenericSectionID;
1030
1031 // For cold sections use the .text.split. prefix along with the parent
1032 // function name. All cold blocks for the same function go to the same
1033 // section. Similarly all exception blocks are grouped by symbol name
1034 // under the .text.eh prefix. For regular sections, we either use a unique
1035 // name, or a unique ID for the section.
1037 StringRef FunctionSectionName = MBB.getParent()->getSection()->getName();
1038 if (FunctionSectionName.equals(".text") ||
1039 FunctionSectionName.starts_with(".text.")) {
1040 // Function is in a regular .text section.
1041 StringRef FunctionName = MBB.getParent()->getName();
1044 Name += FunctionName;
1046 Name += ".text.eh.";
1047 Name += FunctionName;
1048 } else {
1049 Name += FunctionSectionName;
1051 if (!Name.ends_with("."))
1052 Name += ".";
1053 Name += MBB.getSymbol()->getName();
1054 } else {
1055 UniqueID = NextUniqueID++;
1056 }
1057 }
1058 } else {
1059 // If the original function has a custom non-dot-text section, then emit
1060 // all basic block sections into that section too, each with a unique id.
1061 Name = FunctionSectionName;
1062 UniqueID = NextUniqueID++;
1063 }
1064
1065 unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_EXECINSTR;
1066 std::string GroupName;
1067 if (F.hasComdat()) {
1068 Flags |= ELF::SHF_GROUP;
1069 GroupName = F.getComdat()->getName().str();
1070 }
1072 0 /* Entry Size */, GroupName,
1073 F.hasComdat(), UniqueID, nullptr);
1074}
1075
1076static MCSectionELF *getStaticStructorSection(MCContext &Ctx, bool UseInitArray,
1077 bool IsCtor, unsigned Priority,
1078 const MCSymbol *KeySym) {
1079 std::string Name;
1080 unsigned Type;
1081 unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE;
1082 StringRef Comdat = KeySym ? KeySym->getName() : "";
1083
1084 if (KeySym)
1085 Flags |= ELF::SHF_GROUP;
1086
1087 if (UseInitArray) {
1088 if (IsCtor) {
1090 Name = ".init_array";
1091 } else {
1093 Name = ".fini_array";
1094 }
1095 if (Priority != 65535) {
1096 Name += '.';
1097 Name += utostr(Priority);
1098 }
1099 } else {
1100 // The default scheme is .ctor / .dtor, so we have to invert the priority
1101 // numbering.
1102 if (IsCtor)
1103 Name = ".ctors";
1104 else
1105 Name = ".dtors";
1106 if (Priority != 65535)
1107 raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
1109 }
1110
1111 return Ctx.getELFSection(Name, Type, Flags, 0, Comdat, /*IsComdat=*/true);
1112}
1113
1115 unsigned Priority, const MCSymbol *KeySym) const {
1116 return getStaticStructorSection(getContext(), UseInitArray, true, Priority,
1117 KeySym);
1118}
1119
1121 unsigned Priority, const MCSymbol *KeySym) const {
1122 return getStaticStructorSection(getContext(), UseInitArray, false, Priority,
1123 KeySym);
1124}
1125
1127 const GlobalValue *LHS, const GlobalValue *RHS,
1128 const TargetMachine &TM) const {
1129 // We may only use a PLT-relative relocation to refer to unnamed_addr
1130 // functions.
1131 if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
1132 return nullptr;
1133
1134 // Basic correctness checks.
1135 if (LHS->getType()->getPointerAddressSpace() != 0 ||
1136 RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
1137 RHS->isThreadLocal())
1138 return nullptr;
1139
1142 getContext()),
1144}
1145
1147 const DSOLocalEquivalent *Equiv, const TargetMachine &TM) const {
1149
1150 const auto *GV = Equiv->getGlobalValue();
1151
1152 // A PLT entry is not needed for dso_local globals.
1153 if (GV->isDSOLocal() || GV->isImplicitDSOLocal())
1155
1157 getContext());
1158}
1159
1161 // Use ".GCC.command.line" since this feature is to support clang's
1162 // -frecord-gcc-switches which in turn attempts to mimic GCC's switch of the
1163 // same name.
1164 return getContext().getELFSection(".GCC.command.line", ELF::SHT_PROGBITS,
1166}
1167
1168void
1170 UseInitArray = UseInitArray_;
1171 MCContext &Ctx = getContext();
1172 if (!UseInitArray) {
1175
1178 return;
1179 }
1180
1185}
1186
1187//===----------------------------------------------------------------------===//
1188// MachO
1189//===----------------------------------------------------------------------===//
1190
1193}
1194
1196 const TargetMachine &TM) {
1199 StaticCtorSection = Ctx.getMachOSection("__TEXT", "__constructor", 0,
1201 StaticDtorSection = Ctx.getMachOSection("__TEXT", "__destructor", 0,
1203 } else {
1204 StaticCtorSection = Ctx.getMachOSection("__DATA", "__mod_init_func",
1207 StaticDtorSection = Ctx.getMachOSection("__DATA", "__mod_term_func",
1210 }
1211
1217}
1218
1220 unsigned Priority, const MCSymbol *KeySym) const {
1221 return StaticDtorSection;
1222 // In userspace, we lower global destructors via atexit(), but kernel/kext
1223 // environments do not provide this function so we still need to support the
1224 // legacy way here.
1225 // See the -disable-atexit-based-global-dtor-lowering CodeGen flag for more
1226 // context.
1227}
1228
1230 Module &M) const {
1231 // Emit the linker options if present.
1232 if (auto *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
1233 for (const auto *Option : LinkerOptions->operands()) {
1234 SmallVector<std::string, 4> StrOptions;
1235 for (const auto &Piece : cast<MDNode>(Option)->operands())
1236 StrOptions.push_back(std::string(cast<MDString>(Piece)->getString()));
1237 Streamer.emitLinkerOptions(StrOptions);
1238 }
1239 }
1240
1241 unsigned VersionVal = 0;
1242 unsigned ImageInfoFlags = 0;
1243 StringRef SectionVal;
1244
1245 GetObjCImageInfo(M, VersionVal, ImageInfoFlags, SectionVal);
1246 emitCGProfileMetadata(Streamer, M);
1247
1248 // The section is mandatory. If we don't have it, then we don't have GC info.
1249 if (SectionVal.empty())
1250 return;
1251
1252 StringRef Segment, Section;
1253 unsigned TAA = 0, StubSize = 0;
1254 bool TAAParsed;
1256 SectionVal, Segment, Section, TAA, TAAParsed, StubSize)) {
1257 // If invalid, report the error with report_fatal_error.
1258 report_fatal_error("Invalid section specifier '" + Section +
1259 "': " + toString(std::move(E)) + ".");
1260 }
1261
1262 // Get the section.
1264 Segment, Section, TAA, StubSize, SectionKind::getData());
1265 Streamer.switchSection(S);
1266 Streamer.emitLabel(getContext().
1267 getOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
1268 Streamer.emitInt32(VersionVal);
1269 Streamer.emitInt32(ImageInfoFlags);
1270 Streamer.addBlankLine();
1271}
1272
1273static void checkMachOComdat(const GlobalValue *GV) {
1274 const Comdat *C = GV->getComdat();
1275 if (!C)
1276 return;
1277
1278 report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() +
1279 "' cannot be lowered.");
1280}
1281
1283 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1284
1286
1287 const GlobalVariable *GV = dyn_cast<GlobalVariable>(GO);
1288 if (GV && GV->hasImplicitSection()) {
1289 auto Attrs = GV->getAttributes();
1290 if (Attrs.hasAttribute("bss-section") && Kind.isBSS()) {
1291 SectionName = Attrs.getAttribute("bss-section").getValueAsString();
1292 } else if (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly()) {
1293 SectionName = Attrs.getAttribute("rodata-section").getValueAsString();
1294 } else if (Attrs.hasAttribute("relro-section") && Kind.isReadOnlyWithRel()) {
1295 SectionName = Attrs.getAttribute("relro-section").getValueAsString();
1296 } else if (Attrs.hasAttribute("data-section") && Kind.isData()) {
1297 SectionName = Attrs.getAttribute("data-section").getValueAsString();
1298 }
1299 }
1300
1301 const Function *F = dyn_cast<Function>(GO);
1302 if (F && F->hasFnAttribute("implicit-section-name")) {
1303 SectionName = F->getFnAttribute("implicit-section-name").getValueAsString();
1304 }
1305
1306 // Parse the section specifier and create it if valid.
1307 StringRef Segment, Section;
1308 unsigned TAA = 0, StubSize = 0;
1309 bool TAAParsed;
1310
1311 checkMachOComdat(GO);
1312
1314 SectionName, Segment, Section, TAA, TAAParsed, StubSize)) {
1315 // If invalid, report the error with report_fatal_error.
1316 report_fatal_error("Global variable '" + GO->getName() +
1317 "' has an invalid section specifier '" +
1318 GO->getSection() + "': " + toString(std::move(E)) + ".");
1319 }
1320
1321 // Get the section.
1322 MCSectionMachO *S =
1323 getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
1324
1325 // If TAA wasn't set by ParseSectionSpecifier() above,
1326 // use the value returned by getMachOSection() as a default.
1327 if (!TAAParsed)
1328 TAA = S->getTypeAndAttributes();
1329
1330 // Okay, now that we got the section, verify that the TAA & StubSize agree.
1331 // If the user declared multiple globals with different section flags, we need
1332 // to reject it here.
1333 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
1334 // If invalid, report the error with report_fatal_error.
1335 report_fatal_error("Global variable '" + GO->getName() +
1336 "' section type or attributes does not match previous"
1337 " section specifier");
1338 }
1339
1340 return S;
1341}
1342
1344 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1345 checkMachOComdat(GO);
1346
1347 // Handle thread local data.
1348 if (Kind.isThreadBSS()) return TLSBSSSection;
1349 if (Kind.isThreadData()) return TLSDataSection;
1350
1351 if (Kind.isText())
1353
1354 // If this is weak/linkonce, put this in a coalescable section, either in text
1355 // or data depending on if it is writable.
1356 if (GO->isWeakForLinker()) {
1357 if (Kind.isReadOnly())
1358 return ConstTextCoalSection;
1359 if (Kind.isReadOnlyWithRel())
1360 return ConstDataCoalSection;
1361 return DataCoalSection;
1362 }
1363
1364 // FIXME: Alignment check should be handled by section classifier.
1365 if (Kind.isMergeable1ByteCString() &&
1367 cast<GlobalVariable>(GO)) < Align(32))
1368 return CStringSection;
1369
1370 // Do not put 16-bit arrays in the UString section if they have an
1371 // externally visible label, this runs into issues with certain linker
1372 // versions.
1373 if (Kind.isMergeable2ByteCString() && !GO->hasExternalLinkage() &&
1375 cast<GlobalVariable>(GO)) < Align(32))
1376 return UStringSection;
1377
1378 // With MachO only variables whose corresponding symbol starts with 'l' or
1379 // 'L' can be merged, so we only try merging GVs with private linkage.
1380 if (GO->hasPrivateLinkage() && Kind.isMergeableConst()) {
1381 if (Kind.isMergeableConst4())
1383 if (Kind.isMergeableConst8())
1385 if (Kind.isMergeableConst16())
1387 }
1388
1389 // Otherwise, if it is readonly, but not something we can specially optimize,
1390 // just drop it in .const.
1391 if (Kind.isReadOnly())
1392 return ReadOnlySection;
1393
1394 // If this is marked const, put it into a const section. But if the dynamic
1395 // linker needs to write to it, put it in the data segment.
1396 if (Kind.isReadOnlyWithRel())
1397 return ConstDataSection;
1398
1399 // Put zero initialized globals with strong external linkage in the
1400 // DATA, __common section with the .zerofill directive.
1401 if (Kind.isBSSExtern())
1402 return DataCommonSection;
1403
1404 // Put zero initialized globals with local linkage in __DATA,__bss directive
1405 // with the .zerofill directive (aka .lcomm).
1406 if (Kind.isBSSLocal())
1407 return DataBSSSection;
1408
1409 // Otherwise, just drop the variable in the normal data section.
1410 return DataSection;
1411}
1412
1414 const DataLayout &DL, SectionKind Kind, const Constant *C,
1415 Align &Alignment) const {
1416 // If this constant requires a relocation, we have to put it in the data
1417 // segment, not in the text segment.
1418 if (Kind.isData() || Kind.isReadOnlyWithRel())
1419 return ConstDataSection;
1420
1421 if (Kind.isMergeableConst4())
1423 if (Kind.isMergeableConst8())
1425 if (Kind.isMergeableConst16())
1427 return ReadOnlySection; // .const
1428}
1429
1431 return getContext().getMachOSection("__TEXT", "__command_line", 0,
1433}
1434
1436 const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
1437 MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1438 // The mach-o version of this method defaults to returning a stub reference.
1439
1440 if (Encoding & DW_EH_PE_indirect) {
1441 MachineModuleInfoMachO &MachOMMI =
1443
1444 MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
1445
1446 // Add information about the stub reference to MachOMMI so that the stub
1447 // gets emitted by the asmprinter.
1448 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
1449 if (!StubSym.getPointer()) {
1450 MCSymbol *Sym = TM.getSymbol(GV);
1452 }
1453
1456 Encoding & ~DW_EH_PE_indirect, Streamer);
1457 }
1458
1460 MMI, Streamer);
1461}
1462
1464 const GlobalValue *GV, const TargetMachine &TM,
1465 MachineModuleInfo *MMI) const {
1466 // The mach-o version of this method defaults to returning a stub reference.
1467 MachineModuleInfoMachO &MachOMMI =
1469
1470 MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
1471
1472 // Add information about the stub reference to MachOMMI so that the stub
1473 // gets emitted by the asmprinter.
1474 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
1475 if (!StubSym.getPointer()) {
1476 MCSymbol *Sym = TM.getSymbol(GV);
1478 }
1479
1480 return SSym;
1481}
1482
1484 const GlobalValue *GV, const MCSymbol *Sym, const MCValue &MV,
1485 int64_t Offset, MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1486 // Although MachO 32-bit targets do not explicitly have a GOTPCREL relocation
1487 // as 64-bit do, we replace the GOT equivalent by accessing the final symbol
1488 // through a non_lazy_ptr stub instead. One advantage is that it allows the
1489 // computation of deltas to final external symbols. Example:
1490 //
1491 // _extgotequiv:
1492 // .long _extfoo
1493 //
1494 // _delta:
1495 // .long _extgotequiv-_delta
1496 //
1497 // is transformed to:
1498 //
1499 // _delta:
1500 // .long L_extfoo$non_lazy_ptr-(_delta+0)
1501 //
1502 // .section __IMPORT,__pointers,non_lazy_symbol_pointers
1503 // L_extfoo$non_lazy_ptr:
1504 // .indirect_symbol _extfoo
1505 // .long 0
1506 //
1507 // The indirect symbol table (and sections of non_lazy_symbol_pointers type)
1508 // may point to both local (same translation unit) and global (other
1509 // translation units) symbols. Example:
1510 //
1511 // .section __DATA,__pointers,non_lazy_symbol_pointers
1512 // L1:
1513 // .indirect_symbol _myGlobal
1514 // .long 0
1515 // L2:
1516 // .indirect_symbol _myLocal
1517 // .long _myLocal
1518 //
1519 // If the symbol is local, instead of the symbol's index, the assembler
1520 // places the constant INDIRECT_SYMBOL_LOCAL into the indirect symbol table.
1521 // Then the linker will notice the constant in the table and will look at the
1522 // content of the symbol.
1523 MachineModuleInfoMachO &MachOMMI =
1525 MCContext &Ctx = getContext();
1526
1527 // The offset must consider the original displacement from the base symbol
1528 // since 32-bit targets don't have a GOTPCREL to fold the PC displacement.
1529 Offset = -MV.getConstant();
1530 const MCSymbol *BaseSym = &MV.getSymB()->getSymbol();
1531
1532 // Access the final symbol via sym$non_lazy_ptr and generate the appropriated
1533 // non_lazy_ptr stubs.
1535 StringRef Suffix = "$non_lazy_ptr";
1537 Name += Sym->getName();
1538 Name += Suffix;
1539 MCSymbol *Stub = Ctx.getOrCreateSymbol(Name);
1540
1541 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Stub);
1542
1543 if (!StubSym.getPointer())
1544 StubSym = MachineModuleInfoImpl::StubValueTy(const_cast<MCSymbol *>(Sym),
1545 !GV->hasLocalLinkage());
1546
1547 const MCExpr *BSymExpr =
1549 const MCExpr *LHS =
1551
1552 if (!Offset)
1553 return MCBinaryExpr::createSub(LHS, BSymExpr, Ctx);
1554
1555 const MCExpr *RHS =
1557 return MCBinaryExpr::createSub(LHS, RHS, Ctx);
1558}
1559
1560static bool canUsePrivateLabel(const MCAsmInfo &AsmInfo,
1561 const MCSection &Section) {
1562 if (!AsmInfo.isSectionAtomizableBySymbols(Section))
1563 return true;
1564
1565 // FIXME: we should be able to use private labels for sections that can't be
1566 // dead-stripped (there's no issue with blocking atomization there), but `ld
1567 // -r` sometimes drops the no_dead_strip attribute from sections so for safety
1568 // we don't allow it.
1569 return false;
1570}
1571
1573 SmallVectorImpl<char> &OutName, const GlobalValue *GV,
1574 const TargetMachine &TM) const {
1575 bool CannotUsePrivateLabel = true;
1576 if (auto *GO = GV->getAliaseeObject()) {
1578 const MCSection *TheSection = SectionForGlobal(GO, GOKind, TM);
1579 CannotUsePrivateLabel =
1580 !canUsePrivateLabel(*TM.getMCAsmInfo(), *TheSection);
1581 }
1582 getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
1583}
1584
1585//===----------------------------------------------------------------------===//
1586// COFF
1587//===----------------------------------------------------------------------===//
1588
1589static unsigned
1591 unsigned Flags = 0;
1592 bool isThumb = TM.getTargetTriple().getArch() == Triple::thumb;
1593
1594 if (K.isMetadata())
1595 Flags |=
1597 else if (K.isExclude())
1598 Flags |=
1600 else if (K.isText())
1601 Flags |=
1606 else if (K.isBSS())
1607 Flags |=
1611 else if (K.isThreadLocal())
1612 Flags |=
1616 else if (K.isReadOnly() || K.isReadOnlyWithRel())
1617 Flags |=
1620 else if (K.isWriteable())
1621 Flags |=
1625
1626 return Flags;
1627}
1628
1630 const Comdat *C = GV->getComdat();
1631 assert(C && "expected GV to have a Comdat!");
1632
1633 StringRef ComdatGVName = C->getName();
1634 const GlobalValue *ComdatGV = GV->getParent()->getNamedValue(ComdatGVName);
1635 if (!ComdatGV)
1636 report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
1637 "' does not exist.");
1638
1639 if (ComdatGV->getComdat() != C)
1640 report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
1641 "' is not a key for its COMDAT.");
1642
1643 return ComdatGV;
1644}
1645
1646static int getSelectionForCOFF(const GlobalValue *GV) {
1647 if (const Comdat *C = GV->getComdat()) {
1648 const GlobalValue *ComdatKey = getComdatGVForCOFF(GV);
1649 if (const auto *GA = dyn_cast<GlobalAlias>(ComdatKey))
1650 ComdatKey = GA->getAliaseeObject();
1651 if (ComdatKey == GV) {
1652 switch (C->getSelectionKind()) {
1653 case Comdat::Any:
1655 case Comdat::ExactMatch:
1657 case Comdat::Largest:
1661 case Comdat::SameSize:
1663 }
1664 } else {
1666 }
1667 }
1668 return 0;
1669}
1670
1672 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1673 StringRef Name = GO->getSection();
1674 if (Name == getInstrProfSectionName(IPSK_covmap, Triple::COFF,
1675 /*AddSegmentInfo=*/false) ||
1677 /*AddSegmentInfo=*/false) ||
1678 Name == getInstrProfSectionName(IPSK_covdata, Triple::COFF,
1679 /*AddSegmentInfo=*/false) ||
1680 Name == getInstrProfSectionName(IPSK_covname, Triple::COFF,
1681 /*AddSegmentInfo=*/false))
1682 Kind = SectionKind::getMetadata();
1683 int Selection = 0;
1684 unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1685 StringRef COMDATSymName = "";
1686 if (GO->hasComdat()) {
1688 const GlobalValue *ComdatGV;
1690 ComdatGV = getComdatGVForCOFF(GO);
1691 else
1692 ComdatGV = GO;
1693
1694 if (!ComdatGV->hasPrivateLinkage()) {
1695 MCSymbol *Sym = TM.getSymbol(ComdatGV);
1696 COMDATSymName = Sym->getName();
1698 } else {
1699 Selection = 0;
1700 }
1701 }
1702
1703 return getContext().getCOFFSection(Name, Characteristics, Kind, COMDATSymName,
1704 Selection);
1705}
1706
1708 if (Kind.isText())
1709 return ".text";
1710 if (Kind.isBSS())
1711 return ".bss";
1712 if (Kind.isThreadLocal())
1713 return ".tls$";
1714 if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
1715 return ".rdata";
1716 return ".data";
1717}
1718
1720 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1721 // If we have -ffunction-sections then we should emit the global value to a
1722 // uniqued section specifically for it.
1723 bool EmitUniquedSection;
1724 if (Kind.isText())
1725 EmitUniquedSection = TM.getFunctionSections();
1726 else
1727 EmitUniquedSection = TM.getDataSections();
1728
1729 if ((EmitUniquedSection && !Kind.isCommon()) || GO->hasComdat()) {
1731
1732 unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1733
1736 if (!Selection)
1738 const GlobalValue *ComdatGV;
1739 if (GO->hasComdat())
1740 ComdatGV = getComdatGVForCOFF(GO);
1741 else
1742 ComdatGV = GO;
1743
1744 unsigned UniqueID = MCContext::GenericSectionID;
1745 if (EmitUniquedSection)
1746 UniqueID = NextUniqueID++;
1747
1748 if (!ComdatGV->hasPrivateLinkage()) {
1749 MCSymbol *Sym = TM.getSymbol(ComdatGV);
1750 StringRef COMDATSymName = Sym->getName();
1751
1752 if (const auto *F = dyn_cast<Function>(GO))
1753 if (std::optional<StringRef> Prefix = F->getSectionPrefix())
1754 raw_svector_ostream(Name) << '$' << *Prefix;
1755
1756 // Append "$symbol" to the section name *before* IR-level mangling is
1757 // applied when targetting mingw. This is what GCC does, and the ld.bfd
1758 // COFF linker will not properly handle comdats otherwise.
1759 if (getContext().getTargetTriple().isWindowsGNUEnvironment())
1760 raw_svector_ostream(Name) << '$' << ComdatGV->getName();
1761
1763 COMDATSymName, Selection, UniqueID);
1764 } else {
1765 SmallString<256> TmpData;
1766 getMangler().getNameWithPrefix(TmpData, GO, /*CannotUsePrivateLabel=*/true);
1767 return getContext().getCOFFSection(Name, Characteristics, Kind, TmpData,
1768 Selection, UniqueID);
1769 }
1770 }
1771
1772 if (Kind.isText())
1773 return TextSection;
1774
1775 if (Kind.isThreadLocal())
1776 return TLSDataSection;
1777
1778 if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
1779 return ReadOnlySection;
1780
1781 // Note: we claim that common symbols are put in BSSSection, but they are
1782 // really emitted with the magic .comm directive, which creates a symbol table
1783 // entry but not a section.
1784 if (Kind.isBSS() || Kind.isCommon())
1785 return BSSSection;
1786
1787 return DataSection;
1788}
1789
1791 SmallVectorImpl<char> &OutName, const GlobalValue *GV,
1792 const TargetMachine &TM) const {
1793 bool CannotUsePrivateLabel = false;
1794 if (GV->hasPrivateLinkage() &&
1795 ((isa<Function>(GV) && TM.getFunctionSections()) ||
1796 (isa<GlobalVariable>(GV) && TM.getDataSections())))
1797 CannotUsePrivateLabel = true;
1798
1799 getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
1800}
1801
1803 const Function &F, const TargetMachine &TM) const {
1804 // If the function can be removed, produce a unique section so that
1805 // the table doesn't prevent the removal.
1806 const Comdat *C = F.getComdat();
1807 bool EmitUniqueSection = TM.getFunctionSections() || C;
1808 if (!EmitUniqueSection)
1809 return ReadOnlySection;
1810
1811 // FIXME: we should produce a symbol for F instead.
1812 if (F.hasPrivateLinkage())
1813 return ReadOnlySection;
1814
1815 MCSymbol *Sym = TM.getSymbol(&F);
1816 StringRef COMDATSymName = Sym->getName();
1817
1820 unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1822 unsigned UniqueID = NextUniqueID++;
1823
1824 return getContext().getCOFFSection(
1825 SecName, Characteristics, Kind, COMDATSymName,
1827}
1828
1830 bool UsesLabelDifference, const Function &F) const {
1831 if (TM->getTargetTriple().getArch() == Triple::x86_64) {
1833 // We can always create relative relocations, so use another section
1834 // that can be marked non-executable.
1835 return false;
1836 }
1837 }
1839 UsesLabelDifference, F);
1840}
1841
1843 Module &M) const {
1844 emitLinkerDirectives(Streamer, M);
1845
1846 unsigned Version = 0;
1847 unsigned Flags = 0;
1848 StringRef Section;
1849
1850 GetObjCImageInfo(M, Version, Flags, Section);
1851 if (!Section.empty()) {
1852 auto &C = getContext();
1853 auto *S = C.getCOFFSection(Section,
1857 Streamer.switchSection(S);
1858 Streamer.emitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
1859 Streamer.emitInt32(Version);
1860 Streamer.emitInt32(Flags);
1861 Streamer.addBlankLine();
1862 }
1863
1864 emitCGProfileMetadata(Streamer, M);
1865}
1866
1867void TargetLoweringObjectFileCOFF::emitLinkerDirectives(
1868 MCStreamer &Streamer, Module &M) const {
1869 if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
1870 // Emit the linker options to the linker .drectve section. According to the
1871 // spec, this section is a space-separated string containing flags for
1872 // linker.
1874 Streamer.switchSection(Sec);
1875 for (const auto *Option : LinkerOptions->operands()) {
1876 for (const auto &Piece : cast<MDNode>(Option)->operands()) {
1877 // Lead with a space for consistency with our dllexport implementation.
1878 std::string Directive(" ");
1879 Directive.append(std::string(cast<MDString>(Piece)->getString()));
1880 Streamer.emitBytes(Directive);
1881 }
1882 }
1883 }
1884
1885 // Emit /EXPORT: flags for each exported global as necessary.
1886 std::string Flags;
1887 for (const GlobalValue &GV : M.global_values()) {
1888 raw_string_ostream OS(Flags);
1889 emitLinkerFlagsForGlobalCOFF(OS, &GV, getContext().getTargetTriple(),
1890 getMangler());
1891 OS.flush();
1892 if (!Flags.empty()) {
1893 Streamer.switchSection(getDrectveSection());
1894 Streamer.emitBytes(Flags);
1895 }
1896 Flags.clear();
1897 }
1898
1899 // Emit /INCLUDE: flags for each used global as necessary.
1900 if (const auto *LU = M.getNamedGlobal("llvm.used")) {
1901 assert(LU->hasInitializer() && "expected llvm.used to have an initializer");
1902 assert(isa<ArrayType>(LU->getValueType()) &&
1903 "expected llvm.used to be an array type");
1904 if (const auto *A = cast<ConstantArray>(LU->getInitializer())) {
1905 for (const Value *Op : A->operands()) {
1906 const auto *GV = cast<GlobalValue>(Op->stripPointerCasts());
1907 // Global symbols with internal or private linkage are not visible to
1908 // the linker, and thus would cause an error when the linker tried to
1909 // preserve the symbol due to the `/include:` directive.
1910 if (GV->hasLocalLinkage())
1911 continue;
1912
1913 raw_string_ostream OS(Flags);
1914 emitLinkerFlagsForUsedCOFF(OS, GV, getContext().getTargetTriple(),
1915 getMangler());
1916 OS.flush();
1917
1918 if (!Flags.empty()) {
1919 Streamer.switchSection(getDrectveSection());
1920 Streamer.emitBytes(Flags);
1921 }
1922 Flags.clear();
1923 }
1924 }
1925 }
1926}
1927
1929 const TargetMachine &TM) {
1931 this->TM = &TM;
1932 const Triple &T = TM.getTargetTriple();
1933 if (T.isWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) {
1942 } else {
1951 }
1952}
1953
1955 const Triple &T, bool IsCtor,
1956 unsigned Priority,
1957 const MCSymbol *KeySym,
1959 if (T.isWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) {
1960 // If the priority is the default, use .CRT$XCU, possibly associative.
1961 if (Priority == 65535)
1962 return Ctx.getAssociativeCOFFSection(Default, KeySym, 0);
1963
1964 // Otherwise, we need to compute a new section name. Low priorities should
1965 // run earlier. The linker will sort sections ASCII-betically, and we need a
1966 // string that sorts between .CRT$XCA and .CRT$XCU. In the general case, we
1967 // make a name like ".CRT$XCT12345", since that runs before .CRT$XCU. Really
1968 // low priorities need to sort before 'L', since the CRT uses that
1969 // internally, so we use ".CRT$XCA00001" for them. We have a contract with
1970 // the frontend that "init_seg(compiler)" corresponds to priority 200 and
1971 // "init_seg(lib)" corresponds to priority 400, and those respectively use
1972 // 'C' and 'L' without the priority suffix. Priorities between 200 and 400
1973 // use 'C' with the priority as a suffix.
1975 char LastLetter = 'T';
1976 bool AddPrioritySuffix = Priority != 200 && Priority != 400;
1977 if (Priority < 200)
1978 LastLetter = 'A';
1979 else if (Priority < 400)
1980 LastLetter = 'C';
1981 else if (Priority == 400)
1982 LastLetter = 'L';
1984 OS << ".CRT$X" << (IsCtor ? "C" : "T") << LastLetter;
1985 if (AddPrioritySuffix)
1986 OS << format("%05u", Priority);
1987 MCSectionCOFF *Sec = Ctx.getCOFFSection(
1990 return Ctx.getAssociativeCOFFSection(Sec, KeySym, 0);
1991 }
1992
1993 std::string Name = IsCtor ? ".ctors" : ".dtors";
1994 if (Priority != 65535)
1995 raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
1996
1997 return Ctx.getAssociativeCOFFSection(
2002 KeySym, 0);
2003}
2004
2006 unsigned Priority, const MCSymbol *KeySym) const {
2008 getContext(), getContext().getTargetTriple(), true, Priority, KeySym,
2009 cast<MCSectionCOFF>(StaticCtorSection));
2010}
2011
2013 unsigned Priority, const MCSymbol *KeySym) const {
2015 getContext(), getContext().getTargetTriple(), false, Priority, KeySym,
2016 cast<MCSectionCOFF>(StaticDtorSection));
2017}
2018
2020 const GlobalValue *LHS, const GlobalValue *RHS,
2021 const TargetMachine &TM) const {
2022 const Triple &T = TM.getTargetTriple();
2023 if (T.isOSCygMing())
2024 return nullptr;
2025
2026 // Our symbols should exist in address space zero, cowardly no-op if
2027 // otherwise.
2028 if (LHS->getType()->getPointerAddressSpace() != 0 ||
2030 return nullptr;
2031
2032 // Both ptrtoint instructions must wrap global objects:
2033 // - Only global variables are eligible for image relative relocations.
2034 // - The subtrahend refers to the special symbol __ImageBase, a GlobalVariable.
2035 // We expect __ImageBase to be a global variable without a section, externally
2036 // defined.
2037 //
2038 // It should look something like this: @__ImageBase = external constant i8
2039 if (!isa<GlobalObject>(LHS) || !isa<GlobalVariable>(RHS) ||
2040 LHS->isThreadLocal() || RHS->isThreadLocal() ||
2041 RHS->getName() != "__ImageBase" || !RHS->hasExternalLinkage() ||
2042 cast<GlobalVariable>(RHS)->hasInitializer() || RHS->hasSection())
2043 return nullptr;
2044
2045 return MCSymbolRefExpr::create(TM.getSymbol(LHS),
2047 getContext());
2048}
2049
2050static std::string APIntToHexString(const APInt &AI) {
2051 unsigned Width = (AI.getBitWidth() / 8) * 2;
2052 std::string HexString = toString(AI, 16, /*Signed=*/false);
2053 llvm::transform(HexString, HexString.begin(), tolower);
2054 unsigned Size = HexString.size();
2055 assert(Width >= Size && "hex string is too large!");
2056 HexString.insert(HexString.begin(), Width - Size, '0');
2057
2058 return HexString;
2059}
2060
2061static std::string scalarConstantToHexString(const Constant *C) {
2062 Type *Ty = C->getType();
2063 if (isa<UndefValue>(C)) {
2065 } else if (const auto *CFP = dyn_cast<ConstantFP>(C)) {
2066 return APIntToHexString(CFP->getValueAPF().bitcastToAPInt());
2067 } else if (const auto *CI = dyn_cast<ConstantInt>(C)) {
2068 return APIntToHexString(CI->getValue());
2069 } else {
2070 unsigned NumElements;
2071 if (auto *VTy = dyn_cast<VectorType>(Ty))
2072 NumElements = cast<FixedVectorType>(VTy)->getNumElements();
2073 else
2074 NumElements = Ty->getArrayNumElements();
2075 std::string HexString;
2076 for (int I = NumElements - 1, E = -1; I != E; --I)
2077 HexString += scalarConstantToHexString(C->getAggregateElement(I));
2078 return HexString;
2079 }
2080}
2081
2083 const DataLayout &DL, SectionKind Kind, const Constant *C,
2084 Align &Alignment) const {
2085 if (Kind.isMergeableConst() && C &&
2086 getContext().getAsmInfo()->hasCOFFComdatConstants()) {
2087 // This creates comdat sections with the given symbol name, but unless
2088 // AsmPrinter::GetCPISymbol actually makes the symbol global, the symbol
2089 // will be created with a null storage class, which makes GNU binutils
2090 // error out.
2094 std::string COMDATSymName;
2095 if (Kind.isMergeableConst4()) {
2096 if (Alignment <= 4) {
2097 COMDATSymName = "__real@" + scalarConstantToHexString(C);
2098 Alignment = Align(4);
2099 }
2100 } else if (Kind.isMergeableConst8()) {
2101 if (Alignment <= 8) {
2102 COMDATSymName = "__real@" + scalarConstantToHexString(C);
2103 Alignment = Align(8);
2104 }
2105 } else if (Kind.isMergeableConst16()) {
2106 // FIXME: These may not be appropriate for non-x86 architectures.
2107 if (Alignment <= 16) {
2108 COMDATSymName = "__xmm@" + scalarConstantToHexString(C);
2109 Alignment = Align(16);
2110 }
2111 } else if (Kind.isMergeableConst32()) {
2112 if (Alignment <= 32) {
2113 COMDATSymName = "__ymm@" + scalarConstantToHexString(C);
2114 Alignment = Align(32);
2115 }
2116 }
2117
2118 if (!COMDATSymName.empty())
2119 return getContext().getCOFFSection(".rdata", Characteristics, Kind,
2120 COMDATSymName,
2122 }
2123
2125 Alignment);
2126}
2127
2128//===----------------------------------------------------------------------===//
2129// Wasm
2130//===----------------------------------------------------------------------===//
2131
2132static const Comdat *getWasmComdat(const GlobalValue *GV) {
2133 const Comdat *C = GV->getComdat();
2134 if (!C)
2135 return nullptr;
2136
2137 if (C->getSelectionKind() != Comdat::Any)
2138 report_fatal_error("WebAssembly COMDATs only support "
2139 "SelectionKind::Any, '" + C->getName() + "' cannot be "
2140 "lowered.");
2141
2142 return C;
2143}
2144
2145static unsigned getWasmSectionFlags(SectionKind K, bool Retain) {
2146 unsigned Flags = 0;
2147
2148 if (K.isThreadLocal())
2149 Flags |= wasm::WASM_SEG_FLAG_TLS;
2150
2151 if (K.isMergeableCString())
2153
2154 if (Retain)
2156
2157 // TODO(sbc): Add suport for K.isMergeableConst()
2158
2159 return Flags;
2160}
2161
2164 collectUsedGlobalVariables(M, Vec, false);
2165 for (GlobalValue *GV : Vec)
2166 if (auto *GO = dyn_cast<GlobalObject>(GV))
2167 Used.insert(GO);
2168}
2169
2171 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2172 // We don't support explict section names for functions in the wasm object
2173 // format. Each function has to be in its own unique section.
2174 if (isa<Function>(GO)) {
2175 return SelectSectionForGlobal(GO, Kind, TM);
2176 }
2177
2178 StringRef Name = GO->getSection();
2179
2180 // Certain data sections we treat as named custom sections rather than
2181 // segments within the data section.
2182 // This could be avoided if all data segements (the wasm sense) were
2183 // represented as their own sections (in the llvm sense).
2184 // TODO(sbc): https://github.com/WebAssembly/tool-conventions/issues/138
2185 if (Name == ".llvmcmd" || Name == ".llvmbc")
2186 Kind = SectionKind::getMetadata();
2187
2188 StringRef Group = "";
2189 if (const Comdat *C = getWasmComdat(GO)) {
2190 Group = C->getName();
2191 }
2192
2193 unsigned Flags = getWasmSectionFlags(Kind, Used.count(GO));
2195 Name, Kind, Flags, Group, MCContext::GenericSectionID);
2196
2197 return Section;
2198}
2199
2200static MCSectionWasm *
2202 SectionKind Kind, Mangler &Mang,
2203 const TargetMachine &TM, bool EmitUniqueSection,
2204 unsigned *NextUniqueID, bool Retain) {
2205 StringRef Group = "";
2206 if (const Comdat *C = getWasmComdat(GO)) {
2207 Group = C->getName();
2208 }
2209
2210 bool UniqueSectionNames = TM.getUniqueSectionNames();
2211 SmallString<128> Name = getSectionPrefixForGlobal(Kind, /*IsLarge=*/false);
2212
2213 if (const auto *F = dyn_cast<Function>(GO)) {
2214 const auto &OptionalPrefix = F->getSectionPrefix();
2215 if (OptionalPrefix)
2216 raw_svector_ostream(Name) << '.' << *OptionalPrefix;
2217 }
2218
2219 if (EmitUniqueSection && UniqueSectionNames) {
2220 Name.push_back('.');
2221 TM.getNameWithPrefix(Name, GO, Mang, true);
2222 }
2223 unsigned UniqueID = MCContext::GenericSectionID;
2224 if (EmitUniqueSection && !UniqueSectionNames) {
2225 UniqueID = *NextUniqueID;
2226 (*NextUniqueID)++;
2227 }
2228
2229 unsigned Flags = getWasmSectionFlags(Kind, Retain);
2230 return Ctx.getWasmSection(Name, Kind, Flags, Group, UniqueID);
2231}
2232
2234 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2235
2236 if (Kind.isCommon())
2237 report_fatal_error("mergable sections not supported yet on wasm");
2238
2239 // If we have -ffunction-section or -fdata-section then we should emit the
2240 // global value to a uniqued section specifically for it.
2241 bool EmitUniqueSection = false;
2242 if (Kind.isText())
2243 EmitUniqueSection = TM.getFunctionSections();
2244 else
2245 EmitUniqueSection = TM.getDataSections();
2246 EmitUniqueSection |= GO->hasComdat();
2247 bool Retain = Used.count(GO);
2248 EmitUniqueSection |= Retain;
2249
2250 return selectWasmSectionForGlobal(getContext(), GO, Kind, getMangler(), TM,
2251 EmitUniqueSection, &NextUniqueID, Retain);
2252}
2253
2255 bool UsesLabelDifference, const Function &F) const {
2256 // We can always create relative relocations, so use another section
2257 // that can be marked non-executable.
2258 return false;
2259}
2260
2262 const GlobalValue *LHS, const GlobalValue *RHS,
2263 const TargetMachine &TM) const {
2264 // We may only use a PLT-relative relocation to refer to unnamed_addr
2265 // functions.
2266 if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
2267 return nullptr;
2268
2269 // Basic correctness checks.
2270 if (LHS->getType()->getPointerAddressSpace() != 0 ||
2271 RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
2272 RHS->isThreadLocal())
2273 return nullptr;
2274
2277 getContext()),
2279}
2280
2284
2285 // We don't use PersonalityEncoding and LSDAEncoding because we don't emit
2286 // .cfi directives. We use TTypeEncoding to encode typeinfo global variables.
2288}
2289
2291 unsigned Priority, const MCSymbol *KeySym) const {
2292 return Priority == UINT16_MAX ?
2294 getContext().getWasmSection(".init_array." + utostr(Priority),
2296}
2297
2299 unsigned Priority, const MCSymbol *KeySym) const {
2300 report_fatal_error("@llvm.global_dtors should have been lowered already");
2301}
2302
2303//===----------------------------------------------------------------------===//
2304// XCOFF
2305//===----------------------------------------------------------------------===//
2307 const MachineFunction *MF) {
2308 if (!MF->getLandingPads().empty())
2309 return true;
2310
2311 const Function &F = MF->getFunction();
2312 if (!F.hasPersonalityFn() || !F.needsUnwindTableEntry())
2313 return false;
2314
2315 const GlobalValue *Per =
2316 dyn_cast<GlobalValue>(F.getPersonalityFn()->stripPointerCasts());
2317 assert(Per && "Personality routine is not a GlobalValue type.");
2319 return false;
2320
2321 return true;
2322}
2323
2325 const MachineFunction *MF) {
2326 const Function &F = MF->getFunction();
2327 if (!F.hasStackProtectorFnAttr())
2328 return false;
2329 // FIXME: check presence of canary word
2330 // There are cases that the stack protectors are not really inserted even if
2331 // the attributes are on.
2332 return true;
2333}
2334
2335MCSymbol *
2337 MCSymbol *EHInfoSym = MF->getMMI().getContext().getOrCreateSymbol(
2338 "__ehinfo." + Twine(MF->getFunctionNumber()));
2339 cast<MCSymbolXCOFF>(EHInfoSym)->setEHInfo();
2340 return EHInfoSym;
2341}
2342
2343MCSymbol *
2345 const TargetMachine &TM) const {
2346 // We always use a qualname symbol for a GV that represents
2347 // a declaration, a function descriptor, or a common symbol.
2348 // If a GV represents a GlobalVariable and -fdata-sections is enabled, we
2349 // also return a qualname so that a label symbol could be avoided.
2350 // It is inherently ambiguous when the GO represents the address of a
2351 // function, as the GO could either represent a function descriptor or a
2352 // function entry point. We choose to always return a function descriptor
2353 // here.
2354 if (const GlobalObject *GO = dyn_cast<GlobalObject>(GV)) {
2355 if (GO->isDeclarationForLinker())
2356 return cast<MCSectionXCOFF>(getSectionForExternalReference(GO, TM))
2357 ->getQualNameSymbol();
2358
2359 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV))
2360 if (GVar->hasAttribute("toc-data"))
2361 return cast<MCSectionXCOFF>(
2363 ->getQualNameSymbol();
2364
2365 SectionKind GOKind = getKindForGlobal(GO, TM);
2366 if (GOKind.isText())
2367 return cast<MCSectionXCOFF>(
2368 getSectionForFunctionDescriptor(cast<Function>(GO), TM))
2369 ->getQualNameSymbol();
2370 if ((TM.getDataSections() && !GO->hasSection()) || GO->hasCommonLinkage() ||
2371 GOKind.isBSSLocal() || GOKind.isThreadBSSLocal())
2372 return cast<MCSectionXCOFF>(SectionForGlobal(GO, GOKind, TM))
2373 ->getQualNameSymbol();
2374 }
2375
2376 // For all other cases, fall back to getSymbol to return the unqualified name.
2377 return nullptr;
2378}
2379
2381 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2382 if (!GO->hasSection())
2383 report_fatal_error("#pragma clang section is not yet supported");
2384
2386
2387 // Handle the XCOFF::TD case first, then deal with the rest.
2388 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GO))
2389 if (GVar->hasAttribute("toc-data"))
2390 return getContext().getXCOFFSection(
2391 SectionName, Kind,
2393 /* MultiSymbolsAllowed*/ true);
2394
2395 XCOFF::StorageMappingClass MappingClass;
2396 if (Kind.isText())
2397 MappingClass = XCOFF::XMC_PR;
2398 else if (Kind.isData() || Kind.isBSS())
2399 MappingClass = XCOFF::XMC_RW;
2400 else if (Kind.isReadOnlyWithRel())
2401 MappingClass =
2403 else if (Kind.isReadOnly())
2404 MappingClass = XCOFF::XMC_RO;
2405 else
2406 report_fatal_error("XCOFF other section types not yet implemented.");
2407
2408 return getContext().getXCOFFSection(
2409 SectionName, Kind, XCOFF::CsectProperties(MappingClass, XCOFF::XTY_SD),
2410 /* MultiSymbolsAllowed*/ true);
2411}
2412
2414 const GlobalObject *GO, const TargetMachine &TM) const {
2416 "Tried to get ER section for a defined global.");
2417
2420
2422 isa<Function>(GO) ? XCOFF::XMC_DS : XCOFF::XMC_UA;
2423 if (GO->isThreadLocal())
2424 SMC = XCOFF::XMC_UL;
2425
2426 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GO))
2427 if (GVar->hasAttribute("toc-data"))
2428 SMC = XCOFF::XMC_TD;
2429
2430 // Externals go into a csect of type ER.
2431 return getContext().getXCOFFSection(
2434}
2435
2437 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2438 // Handle the XCOFF::TD case first, then deal with the rest.
2439 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GO))
2440 if (GVar->hasAttribute("toc-data")) {
2443 XCOFF::SymbolType symType =
2445 return getContext().getXCOFFSection(
2446 Name, Kind, XCOFF::CsectProperties(XCOFF::XMC_TD, symType),
2447 /* MultiSymbolsAllowed*/ true);
2448 }
2449
2450 // Common symbols go into a csect with matching name which will get mapped
2451 // into the .bss section.
2452 // Zero-initialized local TLS symbols go into a csect with matching name which
2453 // will get mapped into the .tbss section.
2454 if (Kind.isBSSLocal() || GO->hasCommonLinkage() || Kind.isThreadBSSLocal()) {
2457 XCOFF::StorageMappingClass SMC = Kind.isBSSLocal() ? XCOFF::XMC_BS
2458 : Kind.isCommon() ? XCOFF::XMC_RW
2459 : XCOFF::XMC_UL;
2460 return getContext().getXCOFFSection(
2462 }
2463
2464 if (Kind.isText()) {
2465 if (TM.getFunctionSections()) {
2466 return cast<MCSymbolXCOFF>(getFunctionEntryPointSymbol(GO, TM))
2467 ->getRepresentedCsect();
2468 }
2469 return TextSection;
2470 }
2471
2472 if (TM.Options.XCOFFReadOnlyPointers && Kind.isReadOnlyWithRel()) {
2473 if (!TM.getDataSections())
2475 "ReadOnlyPointers is supported only if data sections is turned on");
2476
2479 return getContext().getXCOFFSection(
2482 }
2483
2484 // For BSS kind, zero initialized data must be emitted to the .data section
2485 // because external linkage control sections that get mapped to the .bss
2486 // section will be linked as tentative defintions, which is only appropriate
2487 // for SectionKind::Common.
2488 if (Kind.isData() || Kind.isReadOnlyWithRel() || Kind.isBSS()) {
2489 if (TM.getDataSections()) {
2492 return getContext().getXCOFFSection(
2495 }
2496 return DataSection;
2497 }
2498
2499 if (Kind.isReadOnly()) {
2500 if (TM.getDataSections()) {
2503 return getContext().getXCOFFSection(
2506 }
2507 return ReadOnlySection;
2508 }
2509
2510 // External/weak TLS data and initialized local TLS data are not eligible
2511 // to be put into common csect. If data sections are enabled, thread
2512 // data are emitted into separate sections. Otherwise, thread data
2513 // are emitted into the .tdata section.
2514 if (Kind.isThreadLocal()) {
2515 if (TM.getDataSections()) {
2518 return getContext().getXCOFFSection(
2520 }
2521 return TLSDataSection;
2522 }
2523
2524 report_fatal_error("XCOFF other section types not yet implemented.");
2525}
2526
2528 const Function &F, const TargetMachine &TM) const {
2529 assert (!F.getComdat() && "Comdat not supported on XCOFF.");
2530
2531 if (!TM.getFunctionSections())
2532 return ReadOnlySection;
2533
2534 // If the function can be removed, produce a unique section so that
2535 // the table doesn't prevent the removal.
2536 SmallString<128> NameStr(".rodata.jmp..");
2537 getNameWithPrefix(NameStr, &F, TM);
2538 return getContext().getXCOFFSection(
2539 NameStr, SectionKind::getReadOnly(),
2541}
2542
2544 bool UsesLabelDifference, const Function &F) const {
2545 return false;
2546}
2547
2548/// Given a mergeable constant with the specified size and relocation
2549/// information, return a section that it should be placed in.
2551 const DataLayout &DL, SectionKind Kind, const Constant *C,
2552 Align &Alignment) const {
2553 // TODO: Enable emiting constant pool to unique sections when we support it.
2554 if (Alignment > Align(16))
2555 report_fatal_error("Alignments greater than 16 not yet supported.");
2556
2557 if (Alignment == Align(8)) {
2558 assert(ReadOnly8Section && "Section should always be initialized.");
2559 return ReadOnly8Section;
2560 }
2561
2562 if (Alignment == Align(16)) {
2563 assert(ReadOnly16Section && "Section should always be initialized.");
2564 return ReadOnly16Section;
2565 }
2566
2567 return ReadOnlySection;
2568}
2569
2571 const TargetMachine &TgtM) {
2578 LSDAEncoding = 0;
2580
2581 // AIX debug for thread local location is not ready. And for integrated as
2582 // mode, the relocatable address for the thread local variable will cause
2583 // linker error. So disable the location attribute generation for thread local
2584 // variables for now.
2585 // FIXME: when TLS debug on AIX is ready, remove this setting.
2587}
2588
2590 unsigned Priority, const MCSymbol *KeySym) const {
2591 report_fatal_error("no static constructor section on AIX");
2592}
2593
2595 unsigned Priority, const MCSymbol *KeySym) const {
2596 report_fatal_error("no static destructor section on AIX");
2597}
2598
2600 const GlobalValue *LHS, const GlobalValue *RHS,
2601 const TargetMachine &TM) const {
2602 /* Not implemented yet, but don't crash, return nullptr. */
2603 return nullptr;
2604}
2605
2608 assert(!isa<GlobalIFunc>(GV) && "GlobalIFunc is not supported on AIX.");
2609
2610 switch (GV->getLinkage()) {
2613 return XCOFF::C_HIDEXT;
2617 return XCOFF::C_EXT;
2623 return XCOFF::C_WEAKEXT;
2626 "There is no mapping that implements AppendingLinkage for XCOFF.");
2627 }
2628 llvm_unreachable("Unknown linkage type!");
2629}
2630
2632 const GlobalValue *Func, const TargetMachine &TM) const {
2633 assert((isa<Function>(Func) ||
2634 (isa<GlobalAlias>(Func) &&
2635 isa_and_nonnull<Function>(
2636 cast<GlobalAlias>(Func)->getAliaseeObject()))) &&
2637 "Func must be a function or an alias which has a function as base "
2638 "object.");
2639
2640 SmallString<128> NameStr;
2641 NameStr.push_back('.');
2642 getNameWithPrefix(NameStr, Func, TM);
2643
2644 // When -function-sections is enabled and explicit section is not specified,
2645 // it's not necessary to emit function entry point label any more. We will use
2646 // function entry point csect instead. And for function delcarations, the
2647 // undefined symbols gets treated as csect with XTY_ER property.
2648 if (((TM.getFunctionSections() && !Func->hasSection()) ||
2649 Func->isDeclarationForLinker()) &&
2650 isa<Function>(Func)) {
2651 return getContext()
2653 NameStr, SectionKind::getText(),
2654 XCOFF::CsectProperties(XCOFF::XMC_PR, Func->isDeclarationForLinker()
2656 : XCOFF::XTY_SD))
2658 }
2659
2660 return getContext().getOrCreateSymbol(NameStr);
2661}
2662
2664 const Function *F, const TargetMachine &TM) const {
2665 SmallString<128> NameStr;
2666 getNameWithPrefix(NameStr, F, TM);
2667 return getContext().getXCOFFSection(
2668 NameStr, SectionKind::getData(),
2670}
2671
2673 const MCSymbol *Sym, const TargetMachine &TM) const {
2674 // Use TE storage-mapping class when large code model is enabled so that
2675 // the chance of needing -bbigtoc is decreased. Also, the toc-entry for
2676 // EH info is never referenced directly using instructions so it can be
2677 // allocated with TE storage-mapping class.
2678 return getContext().getXCOFFSection(
2679 cast<MCSymbolXCOFF>(Sym)->getSymbolTableName(), SectionKind::getData(),
2681 cast<MCSymbolXCOFF>(Sym)->isEHInfo())
2683 : XCOFF::XMC_TC,
2684 XCOFF::XTY_SD));
2685}
2686
2688 const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const {
2689 auto *LSDA = cast<MCSectionXCOFF>(LSDASection);
2690 if (TM.getFunctionSections()) {
2691 // If option -ffunction-sections is on, append the function name to the
2692 // name of the LSDA csect so that each function has its own LSDA csect.
2693 // This helps the linker to garbage-collect EH info of unused functions.
2694 SmallString<128> NameStr = LSDA->getName();
2695 raw_svector_ostream(NameStr) << '.' << F.getName();
2696 LSDA = getContext().getXCOFFSection(NameStr, LSDA->getKind(),
2697 LSDA->getCsectProp());
2698 }
2699 return LSDA;
2700}
2701//===----------------------------------------------------------------------===//
2702// GOFF
2703//===----------------------------------------------------------------------===//
2705
2707 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2708 return SelectSectionForGlobal(GO, Kind, TM);
2709}
2710
2712 const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const {
2713 std::string Name = ".gcc_exception_table." + F.getName().str();
2715 nullptr);
2716}
2717
2719 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2720 auto *Symbol = TM.getSymbol(GO);
2721 if (Kind.isBSS())
2722 return getContext().getGOFFSection(Symbol->getName(), SectionKind::getBSS(),
2723 nullptr, nullptr);
2724
2726}
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
amdgpu AMDGPU DAG DAG Pattern Instruction Selection
static bool isThumb(const MCSubtargetInfo &STI)
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
COFFYAML::WeakExternalCharacteristics Characteristics
Definition: COFFYAML.cpp:331
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file contains constants used for implementing Dwarf debug support.
std::string Name
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
This file declares the MCSectionGOFF class, which contains all of the necessary machine code sections...
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
This file contains the declarations for metadata subclasses.
Module.h This file contains the declarations for the Module class.
const char LLVMTargetMachineRef TM
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
This file defines the SmallString class.
This file defines the SmallVector class.
This file contains some functions that are useful when dealing with strings.
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 void GetObjCImageInfo(Module &M, unsigned &Version, unsigned &Flags, StringRef &Section)
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 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 unsigned getWasmSectionFlags(SectionKind K, bool Retain)
static void checkMachOComdat(const GlobalValue *GV)
static std::string APIntToHexString(const APInt &AI)
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 MCSectionELF * selectELFSectionForGlobal(MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang, const TargetMachine &TM, bool EmitUniqueSection, unsigned Flags, unsigned *NextUniqueID, const MCSymbolELF *AssociatedSymbol)
static SmallString< 128 > getELFSectionNameForGlobal(const GlobalObject *GO, SectionKind Kind, Mangler &Mang, const TargetMachine &TM, unsigned EntrySize, bool UniqueSectionName)
static std::string scalarConstantToHexString(const Constant *C)
static StringRef getCOFFSectionNameForUniqueGlobal(SectionKind Kind)
static const Comdat * getELFComdat(const GlobalValue *GV)
static std::tuple< StringRef, bool, unsigned > getGlobalObjectInfo(const GlobalObject *GO, const TargetMachine &TM)
static unsigned getELFSectionFlags(SectionKind K)
Value * RHS
Value * LHS
Class for arbitrary precision integers.
Definition: APInt.h:76
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1433
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
Definition: APInt.h:178
@ Largest
The linker will choose the largest COMDAT.
Definition: Comdat.h:38
@ SameSize
The data referenced by the COMDAT must be the same size.
Definition: Comdat.h:40
@ Any
The linker may choose any COMDAT.
Definition: Comdat.h:36
@ NoDeduplicate
No deduplication is performed.
Definition: Comdat.h:39
@ ExactMatch
The data referenced by the COMDAT must be the same.
Definition: Comdat.h:37
This is an important base class in LLVM.
Definition: Constant.h:41
Wrapper for a function that represents a value that functionally represents the original function.
Definition: Constants.h:934
GlobalValue * getGlobalValue() const
Definition: Constants.h:953
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
Align getPreferredAlign(const GlobalVariable *GV) const
Returns the preferred alignment of the specified global.
StringRef getPrivateGlobalPrefix() const
Definition: DataLayout.h:332
This is the base abstract class for diagnostic reporting in the backend.
Interface for custom diagnostic printing.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
StringRef getSection() const
Get the custom section of this global if it has one.
Definition: GlobalObject.h:118
bool hasComdat() const
Definition: GlobalObject.h:128
bool hasSection() const
Check if this global has a custom object file section.
Definition: GlobalObject.h:110
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
Definition: Value.h:565
bool hasExternalLinkage() const
Definition: GlobalValue.h:510
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
Definition: GlobalValue.h:263
LinkageTypes getLinkage() const
Definition: GlobalValue.h:545
bool hasLocalLinkage() const
Definition: GlobalValue.h:527
bool hasPrivateLinkage() const
Definition: GlobalValue.h:526
const Comdat * getComdat() const
Definition: Globals.cpp:184
bool isDeclarationForLinker() const
Definition: GlobalValue.h:617
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:655
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:368
bool hasCommonLinkage() const
Definition: GlobalValue.h:531
static bool isWeakForLinker(LinkageTypes Linkage)
Whether the definition of this global may be replaced at link time.
Definition: GlobalValue.h:457
@ PrivateLinkage
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:60
@ CommonLinkage
Tentative definitions.
Definition: GlobalValue.h:62
@ InternalLinkage
Rename collisions when linking (static functions).
Definition: GlobalValue.h:59
@ LinkOnceAnyLinkage
Keep one copy of function when linking (inline)
Definition: GlobalValue.h:54
@ WeakODRLinkage
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:57
@ ExternalLinkage
Externally visible function.
Definition: GlobalValue.h:52
@ WeakAnyLinkage
Keep one copy of named function when linking (weak)
Definition: GlobalValue.h:56
@ AppendingLinkage
Special purpose, only applies to global arrays.
Definition: GlobalValue.h:58
@ AvailableExternallyLinkage
Available for inspection, not emission.
Definition: GlobalValue.h:53
@ ExternalWeakLinkage
ExternalWeak linkage description.
Definition: GlobalValue.h:61
@ LinkOnceODRLinkage
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:55
AttributeSet getAttributes() const
Return the attribute set for this global.
bool hasImplicitSection() const
Check if section name is present.
void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:56
bool useIntegratedAssembler() const
Return true if assembly (inline or otherwise) should be parsed.
Definition: MCAsmInfo.h:849
virtual bool isSectionAtomizableBySymbols(const MCSection &Section) const
True if the section is atomized using the symbols in it.
Definition: MCAsmInfo.cpp:79
bool binutilsIsAtLeast(int Major, int Minor) const
Definition: MCAsmInfo.h:856
ExceptionHandling getExceptionHandlingType() const
Definition: MCAsmInfo.h:787
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:534
static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:619
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition: MCExpr.cpp:194
Context object for machine code objects.
Definition: MCContext.h:76
const MCObjectFileInfo * getObjectFileInfo() const
Definition: MCContext.h:450
MCSectionMachO * getMachOSection(StringRef Segment, StringRef Section, unsigned TypeAndAttributes, unsigned Reserved2, SectionKind K, const char *BeginSymName=nullptr)
Return the MCSection for the specified mach-o section.
Definition: MCContext.cpp:437
MCSectionWasm * getWasmSection(const Twine &Section, SectionKind K, unsigned Flags=0)
Definition: MCContext.h:646
MCSectionELF * getELFNamedSection(const Twine &Prefix, const Twine &Suffix, unsigned Type, unsigned Flags, unsigned EntrySize=0)
Get a section with the provided group identifier.
Definition: MCContext.cpp:516
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:565
bool isELFGenericMergeableSection(StringRef Name)
Definition: MCContext.cpp:635
@ GenericSectionID
Pass this value as the UniqueID during section creation to get the generic section with the given nam...
Definition: MCContext.h:548
MCSectionXCOFF * getXCOFFSection(StringRef Section, SectionKind K, std::optional< XCOFF::CsectProperties > CsectProp=std::nullopt, bool MultiSymbolsAllowed=false, const char *BeginSymName=nullptr, std::optional< XCOFF::DwarfSectionSubtypeFlags > DwarfSubtypeFlags=std::nullopt)
Definition: MCContext.cpp:779
std::optional< unsigned > getELFUniqueIDForEntsize(StringRef SectionName, unsigned Flags, unsigned EntrySize)
Return the unique ID of the section with the given name, flags and entry size, if it exists.
Definition: MCContext.cpp:641
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:446
MCSectionCOFF * getCOFFSection(StringRef Section, unsigned Characteristics, SectionKind Kind, StringRef COMDATSymName, int Selection, unsigned UniqueID=GenericSectionID, const char *BeginSymName=nullptr)
Definition: MCContext.cpp:667
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:200
bool isELFImplicitMergeableSectionNamePrefix(StringRef Name)
Definition: MCContext.cpp:630
MCSectionGOFF * getGOFFSection(StringRef Section, SectionKind Kind, MCSection *Parent, const MCExpr *SubsectionId)
Definition: MCContext.cpp:649
MCSectionCOFF * getAssociativeCOFFSection(MCSectionCOFF *Sec, const MCSymbol *KeySym, unsigned UniqueID=GenericSectionID)
Gets or creates a section equivalent to Sec that is associated with the section containing KeySym.
Definition: MCContext.cpp:706
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
MCSection * TLSBSSSection
Section directive for Thread Local uninitialized data.
MCSection * MergeableConst16Section
MCSection * MergeableConst4Section
MCSection * TextSection
Section directive for standard text.
MCSection * ConstDataCoalSection
MCSection * ConstTextCoalSection
MCSection * TLSDataSection
Section directive for Thread Local data. ELF, MachO, COFF, and Wasm.
MCSection * MergeableConst8Section
MCSection * 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 * MergeableConst32Section
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
MCSection * getTextSection() const
MCContext & getContext() const
MCSection * DataSection
Section directive for standard data.
This represents a section on Windows.
Definition: MCSectionCOFF.h:26
This represents a section on linux, lots of unix variants and some bare metal systems.
Definition: MCSectionELF.h:26
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.
Definition: MCSectionWasm.h:26
MCSymbolXCOFF * getQualNameSymbol() const
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
static constexpr unsigned NonUniqueID
Definition: MCSection.h:41
StringRef getName() const
Definition: MCSection.h:124
Streaming machine code generation interface.
Definition: MCStreamer.h:212
virtual void addBlankLine()
Emit a blank line to a .s file to pretty it up.
Definition: MCStreamer.h:380
virtual bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute)=0
Add the given Attribute to Symbol.
virtual void emitELFSize(MCSymbol *Symbol, const MCExpr *Value)
Emit an ELF .size directive.
void emitSymbolValue(const MCSymbol *Sym, unsigned Size, bool IsSectionRelative=false)
Special case of EmitValue that avoids the client having to pass in a MCExpr for MCSymbols.
Definition: MCStreamer.cpp:184
virtual void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc())
Emit a label for Symbol into the current section.
Definition: MCStreamer.cpp:424
virtual void emitValueToAlignment(Align Alignment, int64_t Value=0, unsigned ValueSize=1, unsigned MaxBytesToEmit=0)
Emit some number of copies of Value until the byte alignment ByteAlignment is reached.
unsigned emitULEB128IntValue(uint64_t Value, unsigned PadTo=0)
Special case of EmitULEB128Value that avoids the client having to pass in a MCExpr for constant integ...
Definition: MCStreamer.cpp:162
virtual void emitLinkerOptions(ArrayRef< std::string > Kind)
Emit the given list Options of strings as linker options into the output.
Definition: MCStreamer.h:500
void emitInt64(uint64_t Value)
Definition: MCStreamer.h:755
virtual void switchSection(MCSection *Section, const MCExpr *Subsection=nullptr)
Set the current section where code is being emitted to Section.
void emitInt32(uint64_t Value)
Definition: MCStreamer.h:754
void emitInt8(uint64_t Value)
Definition: MCStreamer.h:752
virtual void emitBytes(StringRef Data)
Emit the bytes in Data into the output.
const MCSymbol & getSymbol() const
Definition: MCExpr.h:408
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:395
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:205
This represents an "assembler immediate".
Definition: MCValue.h:36
int64_t getConstant() const
Definition: MCValue.h:43
const MCSymbolRefExpr * getSymB() const
Definition: MCValue.h:45
Metadata node.
Definition: Metadata.h:1067
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1428
Metadata * get() const
Definition: Metadata.h:918
MCSymbol * getSymbol() const
Return the MCSymbol for this basic block.
MBBSectionID getSectionID() const
Returns the section ID of this basic block.
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
bool isBeginSection() const
Returns true if this block begins any section.
unsigned getFunctionNumber() const
getFunctionNumber - Return a unique ID for the current function.
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
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.
MCSection * getSection() const
Returns the Section this function belongs to.
MachineModuleInfo & getMMI() const
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 MCContext & getContext() const
const Module * getModule() const
Ty & getObjFileInfo()
Keep track of various per-module pieces of information for backends that would like to do so.
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:119
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
@ Require
Adds a requirement that another module flag be present and have a specified value after linking is pe...
Definition: Module.h:131
const std::string & getSourceFileName() const
Get the module's original source file name.
Definition: Module.h:272
GlobalValue * getNamedValue(StringRef Name) const
Return the global value in the module with the specified name, of arbitrary type.
Definition: Module.cpp:133
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.h:287
A tuple of MDNodes.
Definition: Metadata.h:1729
PointerIntPair - This class implements a pair of a pointer and small integer.
PointerTy getPointer() const
SectionKind - This is a simple POD value that classifies the properties of a section.
Definition: SectionKind.h:22
static SectionKind getThreadData()
Definition: SectionKind.h:207
static SectionKind getMetadata()
Definition: SectionKind.h:188
bool isThreadBSSLocal() const
Definition: SectionKind.h:163
static SectionKind getText()
Definition: SectionKind.h:190
bool isBSSLocal() const
Definition: SectionKind.h:170
static SectionKind getData()
Definition: SectionKind.h:213
bool isText() const
Definition: SectionKind.h:127
static SectionKind getBSS()
Definition: SectionKind.h:209
static SectionKind getThreadBSS()
Definition: SectionKind.h:206
static SectionKind getReadOnly()
Definition: SectionKind.h:192
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:257
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:164
const MCExpr * lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS, 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...
MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment) const override
Given a mergeable constant with the specified size and relocation information, return a section that ...
void Initialize(MCContext &Ctx, const TargetMachine &TM) override
This method must be called before any actual lowering is done.
void emitModuleMetadata(MCStreamer &Streamer, Module &M) const override
Emit Obj-C garbage collection and linker options.
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
MCSection * getStaticCtorSection(unsigned Priority, const MCSymbol *KeySym) 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 * getStaticDtorSection(unsigned Priority, const MCSymbol *KeySym) const override
MCSection * getSectionForJumpTable(const Function &F, const TargetMachine &TM) const override
MCSection * getUniqueSectionForFunction(const Function &F, const TargetMachine &TM) const override
void Initialize(MCContext &Ctx, const TargetMachine &TM) 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 override
Given a constant with the SectionKind, return a section that it should be placed in.
MCSection * getStaticCtorSection(unsigned Priority, const MCSymbol *KeySym) const override
MCSection * getSectionForJumpTable(const Function &F, const TargetMachine &TM) const override
void emitModuleMetadata(MCStreamer &Streamer, 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 * getStaticDtorSection(unsigned Priority, const MCSymbol *KeySym) const override
void emitPersonalityValue(MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym) const override
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...
void getModuleMetadata(Module &M) override
Get the module-level metadata that the platform cares about.
const MCExpr * lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS, const TargetMachine &TM) const override
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
const MCExpr * lowerDSOLocalEquivalent(const DSOLocalEquivalent *Equiv, 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
bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const override
MCSection * getSectionForMachineBasicBlock(const Function &F, const MachineBasicBlock &MBB, const TargetMachine &TM) const override
Returns a unique section for the given machine basic block.
MCSymbolRefExpr::VariantKind PLTRelativeVariantKind
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 * 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
MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment) const override
Given a constant with the SectionKind, return a section that it should be placed in.
void getNameWithPrefix(SmallVectorImpl< char > &OutName, const GlobalValue *GV, const TargetMachine &TM) const override
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...
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.
void emitModuleMetadata(MCStreamer &Streamer, Module &M) const override
Emit the module flags that specify the garbage collection information.
void Initialize(MCContext &Ctx, const TargetMachine &TM) override
This method must be called before any actual lowering is done.
MCSection * getSectionForCommandLines() const override
If supported, return the section to use for the llvm.commandline metadata.
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.
void getModuleMetadata(Module &M) override
Get the module-level metadata that the platform cares about.
const MCExpr * lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS, const TargetMachine &TM) const override
MCSection * getStaticCtorSection(unsigned Priority, const MCSymbol *KeySym) const override
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)
void Initialize(MCContext &Ctx, const TargetMachine &TM) override
This method must be called before any actual lowering is done.
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.
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
const MCExpr * lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS, const TargetMachine &TM) const override
MCSection * getSectionForJumpTable(const Function &F, const TargetMachine &TM) const override
static MCSymbol * getEHInfoTableSymbol(const MachineFunction *MF)
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)
MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment) const override
Given a constant with the SectionKind, return a section that it should be placed in.
MCSymbol * getTargetSymbol(const GlobalValue *GV, const TargetMachine &TM) const override
For functions, this will always return a function descriptor symbol.
MCSection * getSectionForFunctionDescriptor(const Function *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.
void emitCGProfileMetadata(MCStreamer &Streamer, Module &M) const
Emit Call Graph Profile metadata.
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.
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
bool supportDSOLocalEquivalentLowering() const
Target supports a native lowering of a dso_local_equivalent constant without needing to replace it wi...
virtual void Initialize(MCContext &ctx, const TargetMachine &TM)
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
Given a constant with the SectionKind, return a section that it should be placed in.
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...
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.
Definition: TargetMachine.h:76
const Triple & getTargetTriple() const
bool getUniqueBasicBlockSectionNames() const
Return true if unique basic block section names must be generated.
bool getUniqueSectionNames() const
Reloc::Model getRelocationModel() const
Returns the code generation relocation model.
TargetOptions Options
MCSymbol * getSymbol(const GlobalValue *GV) const
bool getDataSections() const
Return true if data objects should be emitted into their own section, corresponds to -fdata-sections.
CodeModel::Model getCodeModel() const
Returns the code model.
bool getFunctionSections() const
Return true if functions should be emitted into their own section, corresponding to -ffunction-sectio...
const MCAsmInfo * getMCAsmInfo() const
Return target specific asm information.
unsigned XCOFFReadOnlyPointers
When set to true, const objects with relocatable address values are put into the RO data section.
unsigned UseInitArray
UseInitArray - Use .init_array instead of .ctors for static constructors.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
@ loongarch32
Definition: Triple.h:61
@ aarch64_be
Definition: Triple.h:52
@ loongarch64
Definition: Triple.h:62
@ mips64el
Definition: Triple.h:67
@ aarch64_32
Definition: Triple.h:53
ArchType getArch() const
Get the parsed architecture type of this triple.
Definition: Triple.h:361
EnvironmentType getEnvironment() const
Get the parsed environment type of this triple.
Definition: Triple.h:378
bool isOSFreeBSD() const
Definition: Triple.h:568
bool isArch32Bit() const
Test whether the architecture is 32-bit.
Definition: Triple.cpp:1542
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
std::string str() const
Return the twine contents as a std::string.
Definition: Twine.cpp:17
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
uint64_t getArrayNumElements() const
TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
LLVM Value Representation.
Definition: Value.h:74
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:1074
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:660
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:690
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.
const CustomOperand< const MCSubtargetInfo & > Msg[]
SectionCharacteristics
Definition: COFF.h:297
@ IMAGE_SCN_LNK_REMOVE
Definition: COFF.h:307
@ IMAGE_SCN_CNT_CODE
Definition: COFF.h:302
@ IMAGE_SCN_MEM_READ
Definition: COFF.h:335
@ IMAGE_SCN_MEM_EXECUTE
Definition: COFF.h:334
@ IMAGE_SCN_CNT_UNINITIALIZED_DATA
Definition: COFF.h:304
@ IMAGE_SCN_MEM_DISCARDABLE
Definition: COFF.h:330
@ IMAGE_SCN_MEM_16BIT
Definition: COFF.h:311
@ IMAGE_SCN_CNT_INITIALIZED_DATA
Definition: COFF.h:303
@ IMAGE_SCN_LNK_COMDAT
Definition: COFF.h:308
@ IMAGE_SCN_MEM_WRITE
Definition: COFF.h:336
@ IMAGE_COMDAT_SELECT_NODUPLICATES
Definition: COFF.h:421
@ IMAGE_COMDAT_SELECT_LARGEST
Definition: COFF.h:426
@ IMAGE_COMDAT_SELECT_SAME_SIZE
Definition: COFF.h:423
@ IMAGE_COMDAT_SELECT_ASSOCIATIVE
Definition: COFF.h:425
@ IMAGE_COMDAT_SELECT_EXACT_MATCH
Definition: COFF.h:424
@ IMAGE_COMDAT_SELECT_ANY
Definition: COFF.h:422
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
@ SHF_MERGE
Definition: ELF.h:1161
@ SHF_STRINGS
Definition: ELF.h:1164
@ SHF_EXCLUDE
Definition: ELF.h:1189
@ SHF_ALLOC
Definition: ELF.h:1155
@ SHF_LINK_ORDER
Definition: ELF.h:1170
@ SHF_GROUP
Definition: ELF.h:1177
@ SHF_SUNW_NODISCARD
Definition: ELF.h:1196
@ SHF_X86_64_LARGE
Definition: ELF.h:1218
@ SHF_GNU_RETAIN
Definition: ELF.h:1186
@ SHF_WRITE
Definition: ELF.h:1152
@ SHF_TLS
Definition: ELF.h:1180
@ SHF_ARM_PURECODE
Definition: ELF.h:1250
@ SHF_EXECINSTR
Definition: ELF.h:1158
@ SHT_LLVM_DEPENDENT_LIBRARIES
Definition: ELF.h:1091
@ SHT_PROGBITS
Definition: ELF.h:1063
@ SHT_LLVM_LINKER_OPTIONS
Definition: ELF.h:1088
@ SHT_NOBITS
Definition: ELF.h:1070
@ SHT_LLVM_OFFLOADING
Definition: ELF.h:1101
@ SHT_PREINIT_ARRAY
Definition: ELF.h:1076
@ SHT_INIT_ARRAY
Definition: ELF.h:1074
@ SHT_NOTE
Definition: ELF.h:1069
@ SHT_FINI_ARRAY
Definition: ELF.h:1075
@ 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
StorageClass
Definition: XCOFF.h:170
@ C_WEAKEXT
Definition: XCOFF.h:199
@ C_HIDEXT
Definition: XCOFF.h:206
StorageMappingClass
Storage Mapping Class definitions.
Definition: XCOFF.h:103
@ XMC_TE
Symbol mapped at the end of TOC.
Definition: XCOFF.h:128
@ XMC_DS
Descriptor csect.
Definition: XCOFF.h:121
@ XMC_RW
Read Write Data.
Definition: XCOFF.h:117
@ XMC_TL
Initialized thread-local variable.
Definition: XCOFF.h:126
@ XMC_RO
Read Only Constant.
Definition: XCOFF.h:106
@ XMC_UA
Unclassified - Treated as Read Write.
Definition: XCOFF.h:122
@ XMC_TD
Scalar data item in the TOC.
Definition: XCOFF.h:120
@ XMC_UL
Uninitialized thread-local variable.
Definition: XCOFF.h:127
@ XMC_PR
Program Code.
Definition: XCOFF.h:105
@ XMC_BS
BSS class (uninitialized static internal)
Definition: XCOFF.h:123
@ XMC_TC
General TOC item.
Definition: XCOFF.h:119
@ XTY_CM
Common csect definition. For uninitialized storage.
Definition: XCOFF.h:245
@ XTY_SD
Csect definition for initialized storage.
Definition: XCOFF.h:242
@ XTY_ER
External reference.
Definition: XCOFF.h:241
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:450
std::optional< const char * > toString(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
@ DW_EH_PE_datarel
Definition: Dwarf.h:536
@ DW_EH_PE_pcrel
Definition: Dwarf.h:534
@ DW_EH_PE_sdata4
Definition: Dwarf.h:531
@ DW_EH_PE_sdata8
Definition: Dwarf.h:532
@ DW_EH_PE_absptr
Definition: Dwarf.h:523
@ DW_EH_PE_udata4
Definition: Dwarf.h:527
@ DW_EH_PE_udata8
Definition: Dwarf.h:528
@ DW_EH_PE_indirect
Definition: Dwarf.h:539
@ WASM_SEG_FLAG_RETAIN
Definition: Wasm.h:219
@ WASM_SEG_FLAG_TLS
Definition: Wasm.h:218
@ WASM_SEG_FLAG_STRINGS
Definition: Wasm.h:217
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
std::string getInstrProfSectionName(InstrProfSectKind IPSK, Triple::ObjectFormatType OF, bool AddSegmentInfo=true)
Return the name of the profile section corresponding to IPSK.
Definition: InstrProf.cpp:222
@ DK_Lowering
bool isNoOpWithoutInvoke(EHPersonality Pers)
Return true if this personality may be safely removed if there are no invoke instructions remaining i...
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:1937
std::string encodeBase64(InputBytes const &Bytes)
Definition: Base64.h:23
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:156
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
void emitLinkerFlagsForUsedCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &T, Mangler &M)
Definition: Mangler.cpp:268
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:125
DiagnosticSeverity
Defines the different supported severity of a diagnostic.
@ DS_Error
void emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &TT, Mangler &Mangler)
Definition: Mangler.cpp:212
cl::opt< std::string > BBSectionsColdTextPrefix
@ Default
The result values are uniform if and only if all operands are uniform.
@ MCSA_Weak
.weak
Definition: MCDirectives.h:45
@ MCSA_ELF_TypeObject
.type _foo, STT_OBJECT # aka @object
Definition: MCDirectives.h:25
@ MCSA_Hidden
.hidden (ELF)
Definition: MCDirectives.h:33
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:843
constexpr const char * PseudoProbeDescMetadataName
Definition: PseudoProbe.h:25
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
uint64_t value() const
This is a hole in the type system and should not be abused.
Definition: Alignment.h:85
static const MBBSectionID ExceptionSectionID
static const MBBSectionID ColdSectionID