LLVM 18.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) ||
475 Name == ".llvmbc" || Name == ".llvmcmd")
477
478 if (Name.empty() || Name[0] != '.') return K;
479
480 // Default implementation based on some magic section names.
481 if (Name == ".bss" ||
482 Name.startswith(".bss.") ||
483 Name.startswith(".gnu.linkonce.b.") ||
484 Name.startswith(".llvm.linkonce.b.") ||
485 Name == ".sbss" ||
486 Name.startswith(".sbss.") ||
487 Name.startswith(".gnu.linkonce.sb.") ||
488 Name.startswith(".llvm.linkonce.sb."))
489 return SectionKind::getBSS();
490
491 if (Name == ".tdata" ||
492 Name.startswith(".tdata.") ||
493 Name.startswith(".gnu.linkonce.td.") ||
494 Name.startswith(".llvm.linkonce.td."))
496
497 if (Name == ".tbss" ||
498 Name.startswith(".tbss.") ||
499 Name.startswith(".gnu.linkonce.tb.") ||
500 Name.startswith(".llvm.linkonce.tb."))
502
503 return K;
504}
505
507 return SectionName.consume_front(Prefix) &&
508 (SectionName.empty() || SectionName[0] == '.');
509}
510
512 // Use SHT_NOTE for section whose name starts with ".note" to allow
513 // emitting ELF notes from C variable declaration.
514 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77609
515 if (Name.startswith(".note"))
516 return ELF::SHT_NOTE;
517
518 if (hasPrefix(Name, ".init_array"))
519 return ELF::SHT_INIT_ARRAY;
520
521 if (hasPrefix(Name, ".fini_array"))
522 return ELF::SHT_FINI_ARRAY;
523
524 if (hasPrefix(Name, ".preinit_array"))
526
527 if (hasPrefix(Name, ".llvm.offloading"))
529
530 if (K.isBSS() || K.isThreadBSS())
531 return ELF::SHT_NOBITS;
532
533 return ELF::SHT_PROGBITS;
534}
535
536static unsigned getELFSectionFlags(SectionKind K) {
537 unsigned Flags = 0;
538
539 if (!K.isMetadata() && !K.isExclude())
540 Flags |= ELF::SHF_ALLOC;
541
542 if (K.isExclude())
543 Flags |= ELF::SHF_EXCLUDE;
544
545 if (K.isText())
546 Flags |= ELF::SHF_EXECINSTR;
547
548 if (K.isExecuteOnly())
549 Flags |= ELF::SHF_ARM_PURECODE;
550
551 if (K.isWriteable())
552 Flags |= ELF::SHF_WRITE;
553
554 if (K.isThreadLocal())
555 Flags |= ELF::SHF_TLS;
556
557 if (K.isMergeableCString() || K.isMergeableConst())
558 Flags |= ELF::SHF_MERGE;
559
560 if (K.isMergeableCString())
561 Flags |= ELF::SHF_STRINGS;
562
563 return Flags;
564}
565
566static const Comdat *getELFComdat(const GlobalValue *GV) {
567 const Comdat *C = GV->getComdat();
568 if (!C)
569 return nullptr;
570
571 if (C->getSelectionKind() != Comdat::Any &&
572 C->getSelectionKind() != Comdat::NoDeduplicate)
573 report_fatal_error("ELF COMDATs only support SelectionKind::Any and "
574 "SelectionKind::NoDeduplicate, '" +
575 C->getName() + "' cannot be lowered.");
576
577 return C;
578}
579
581 const TargetMachine &TM) {
582 MDNode *MD = GO->getMetadata(LLVMContext::MD_associated);
583 if (!MD)
584 return nullptr;
585
586 auto *VM = cast<ValueAsMetadata>(MD->getOperand(0).get());
587 auto *OtherGV = dyn_cast<GlobalValue>(VM->getValue());
588 return OtherGV ? dyn_cast<MCSymbolELF>(TM.getSymbol(OtherGV)) : nullptr;
589}
590
591static unsigned getEntrySizeForKind(SectionKind Kind) {
592 if (Kind.isMergeable1ByteCString())
593 return 1;
594 else if (Kind.isMergeable2ByteCString())
595 return 2;
596 else if (Kind.isMergeable4ByteCString())
597 return 4;
598 else if (Kind.isMergeableConst4())
599 return 4;
600 else if (Kind.isMergeableConst8())
601 return 8;
602 else if (Kind.isMergeableConst16())
603 return 16;
604 else if (Kind.isMergeableConst32())
605 return 32;
606 else {
607 // We shouldn't have mergeable C strings or mergeable constants that we
608 // didn't handle above.
609 assert(!Kind.isMergeableCString() && "unknown string width");
610 assert(!Kind.isMergeableConst() && "unknown data width");
611 return 0;
612 }
613}
614
615/// Return the section prefix name used by options FunctionsSections and
616/// DataSections.
618 if (Kind.isText())
619 return ".text";
620 if (Kind.isReadOnly())
621 return IsLarge ? ".lrodata" : ".rodata";
622 if (Kind.isBSS())
623 return IsLarge ? ".lbss" : ".bss";
624 if (Kind.isThreadData())
625 return ".tdata";
626 if (Kind.isThreadBSS())
627 return ".tbss";
628 if (Kind.isData())
629 return IsLarge ? ".ldata" : ".data";
630 if (Kind.isReadOnlyWithRel())
631 return IsLarge ? ".ldata.rel.ro" : ".data.rel.ro";
632 llvm_unreachable("Unknown section kind");
633}
634
635static SmallString<128>
637 Mangler &Mang, const TargetMachine &TM,
638 unsigned EntrySize, bool UniqueSectionName) {
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 std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
648 Name = SizeSpec + utostr(Alignment.value());
649 } else if (Kind.isMergeableConst()) {
650 Name = ".rodata.cst";
651 Name += utostr(EntrySize);
652 } else {
653 bool IsLarge = false;
654 if (auto *GV = dyn_cast<GlobalVariable>(GO))
655 IsLarge = TM.isLargeData(GV);
656 Name = getSectionPrefixForGlobal(Kind, IsLarge);
657 }
658
659 bool HasPrefix = false;
660 if (const auto *F = dyn_cast<Function>(GO)) {
661 if (std::optional<StringRef> Prefix = F->getSectionPrefix()) {
662 raw_svector_ostream(Name) << '.' << *Prefix;
663 HasPrefix = true;
664 }
665 }
666
667 if (UniqueSectionName) {
668 Name.push_back('.');
669 TM.getNameWithPrefix(Name, GO, Mang, /*MayAlwaysUsePrivate*/true);
670 } else if (HasPrefix)
671 // For distinguishing between .text.${text-section-prefix}. (with trailing
672 // dot) and .text.${function-name}
673 Name.push_back('.');
674 return Name;
675}
676
677namespace {
678class LoweringDiagnosticInfo : public DiagnosticInfo {
679 const Twine &Msg;
680
681public:
682 LoweringDiagnosticInfo(const Twine &DiagMsg,
683 DiagnosticSeverity Severity = DS_Error)
684 : DiagnosticInfo(DK_Lowering, Severity), Msg(DiagMsg) {}
685 void print(DiagnosticPrinter &DP) const override { DP << Msg; }
686};
687}
688
689/// Calculate an appropriate unique ID for a section, and update Flags,
690/// EntrySize and NextUniqueID where appropriate.
691static unsigned
693 SectionKind Kind, const TargetMachine &TM,
694 MCContext &Ctx, Mangler &Mang, unsigned &Flags,
695 unsigned &EntrySize, unsigned &NextUniqueID,
696 const bool Retain, const bool ForceUnique) {
697 // Increment uniqueID if we are forced to emit a unique section.
698 // This works perfectly fine with section attribute or pragma section as the
699 // sections with the same name are grouped together by the assembler.
700 if (ForceUnique)
701 return NextUniqueID++;
702
703 // A section can have at most one associated section. Put each global with
704 // MD_associated in a unique section.
705 const bool Associated = GO->getMetadata(LLVMContext::MD_associated);
706 if (Associated) {
707 Flags |= ELF::SHF_LINK_ORDER;
708 return NextUniqueID++;
709 }
710
711 if (Retain) {
712 if (TM.getTargetTriple().isOSSolaris())
714 else if (Ctx.getAsmInfo()->useIntegratedAssembler() ||
715 Ctx.getAsmInfo()->binutilsIsAtLeast(2, 36))
716 Flags |= ELF::SHF_GNU_RETAIN;
717 return NextUniqueID++;
718 }
719
720 // If two symbols with differing sizes end up in the same mergeable section
721 // that section can be assigned an incorrect entry size. To avoid this we
722 // usually put symbols of the same size into distinct mergeable sections with
723 // the same name. Doing so relies on the ",unique ," assembly feature. This
724 // feature is not avalible until bintuils version 2.35
725 // (https://sourceware.org/bugzilla/show_bug.cgi?id=25380).
726 const bool SupportsUnique = Ctx.getAsmInfo()->useIntegratedAssembler() ||
727 Ctx.getAsmInfo()->binutilsIsAtLeast(2, 35);
728 if (!SupportsUnique) {
729 Flags &= ~ELF::SHF_MERGE;
730 EntrySize = 0;
732 }
733
734 const bool SymbolMergeable = Flags & ELF::SHF_MERGE;
735 const bool SeenSectionNameBefore =
737 // If this is the first ocurrence of this section name, treat it as the
738 // generic section
739 if (!SymbolMergeable && !SeenSectionNameBefore)
741
742 // Symbols must be placed into sections with compatible entry sizes. Generate
743 // unique sections for symbols that have not been assigned to compatible
744 // sections.
745 const auto PreviousID =
746 Ctx.getELFUniqueIDForEntsize(SectionName, Flags, EntrySize);
747 if (PreviousID)
748 return *PreviousID;
749
750 // If the user has specified the same section name as would be created
751 // implicitly for this symbol e.g. .rodata.str1.1, then we don't need
752 // to unique the section as the entry size for this symbol will be
753 // compatible with implicitly created sections.
754 SmallString<128> ImplicitSectionNameStem =
755 getELFSectionNameForGlobal(GO, Kind, Mang, TM, EntrySize, false);
756 if (SymbolMergeable &&
758 SectionName.startswith(ImplicitSectionNameStem))
760
761 // We have seen this section name before, but with different flags or entity
762 // size. Create a new unique ID.
763 return NextUniqueID++;
764}
765
767 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM,
768 MCContext &Ctx, Mangler &Mang, unsigned &NextUniqueID,
769 bool Retain, bool ForceUnique) {
771
772 // Check if '#pragma clang section' name is applicable.
773 // Note that pragma directive overrides -ffunction-section, -fdata-section
774 // and so section name is exactly as user specified and not uniqued.
775 const GlobalVariable *GV = dyn_cast<GlobalVariable>(GO);
776 if (GV && GV->hasImplicitSection()) {
777 auto Attrs = GV->getAttributes();
778 if (Attrs.hasAttribute("bss-section") && Kind.isBSS()) {
779 SectionName = Attrs.getAttribute("bss-section").getValueAsString();
780 } else if (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly()) {
781 SectionName = Attrs.getAttribute("rodata-section").getValueAsString();
782 } else if (Attrs.hasAttribute("relro-section") && Kind.isReadOnlyWithRel()) {
783 SectionName = Attrs.getAttribute("relro-section").getValueAsString();
784 } else if (Attrs.hasAttribute("data-section") && Kind.isData()) {
785 SectionName = Attrs.getAttribute("data-section").getValueAsString();
786 }
787 }
788 const Function *F = dyn_cast<Function>(GO);
789 if (F && F->hasFnAttribute("implicit-section-name")) {
790 SectionName = F->getFnAttribute("implicit-section-name").getValueAsString();
791 }
792
793 // Infer section flags from the section name if we can.
795
796 StringRef Group = "";
797 bool IsComdat = false;
798 unsigned Flags = getELFSectionFlags(Kind);
799 if (const Comdat *C = getELFComdat(GO)) {
800 Group = C->getName();
801 IsComdat = C->getSelectionKind() == Comdat::Any;
802 Flags |= ELF::SHF_GROUP;
803 }
804
805 unsigned EntrySize = getEntrySizeForKind(Kind);
806 const unsigned UniqueID = calcUniqueIDUpdateFlagsAndSize(
807 GO, SectionName, Kind, TM, Ctx, Mang, Flags, EntrySize, NextUniqueID,
808 Retain, ForceUnique);
809
810 const MCSymbolELF *LinkedToSym = getLinkedToSymbol(GO, TM);
811 MCSectionELF *Section = Ctx.getELFSection(
812 SectionName, getELFSectionType(SectionName, Kind), Flags, EntrySize,
813 Group, IsComdat, UniqueID, LinkedToSym);
814 // Make sure that we did not get some other section with incompatible sh_link.
815 // This should not be possible due to UniqueID code above.
816 assert(Section->getLinkedToSymbol() == LinkedToSym &&
817 "Associated symbol mismatch between sections");
818
819 if (!(Ctx.getAsmInfo()->useIntegratedAssembler() ||
820 Ctx.getAsmInfo()->binutilsIsAtLeast(2, 35))) {
821 // If we are using GNU as before 2.35, then this symbol might have
822 // been placed in an incompatible mergeable section. Emit an error if this
823 // is the case to avoid creating broken output.
824 if ((Section->getFlags() & ELF::SHF_MERGE) &&
825 (Section->getEntrySize() != getEntrySizeForKind(Kind)))
826 GO->getContext().diagnose(LoweringDiagnosticInfo(
827 "Symbol '" + GO->getName() + "' from module '" +
828 (GO->getParent() ? GO->getParent()->getSourceFileName() : "unknown") +
829 "' required a section with entry-size=" +
830 Twine(getEntrySizeForKind(Kind)) + " but was placed in section '" +
831 SectionName + "' with entry-size=" + Twine(Section->getEntrySize()) +
832 ": Explicit assignment by pragma or attribute of an incompatible "
833 "symbol to this section?"));
834 }
835
836 return Section;
837}
838
840 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
842 NextUniqueID, Used.count(GO),
843 /* ForceUnique = */false);
844}
845
847 MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
848 const TargetMachine &TM, bool EmitUniqueSection, unsigned Flags,
849 unsigned *NextUniqueID, const MCSymbolELF *AssociatedSymbol) {
850
851 StringRef Group = "";
852 bool IsComdat = false;
853 if (const Comdat *C = getELFComdat(GO)) {
854 Flags |= ELF::SHF_GROUP;
855 Group = C->getName();
856 IsComdat = C->getSelectionKind() == Comdat::Any;
857 }
858 if (auto *GV = dyn_cast<GlobalVariable>(GO)) {
859 if (TM.isLargeData(GV)) {
860 assert(TM.getTargetTriple().getArch() == Triple::x86_64);
861 Flags |= ELF::SHF_X86_64_LARGE;
862 }
863 }
864
865 // Get the section entry size based on the kind.
866 unsigned EntrySize = getEntrySizeForKind(Kind);
867
868 bool UniqueSectionName = false;
869 unsigned UniqueID = MCContext::GenericSectionID;
870 if (EmitUniqueSection) {
871 if (TM.getUniqueSectionNames()) {
872 UniqueSectionName = true;
873 } else {
874 UniqueID = *NextUniqueID;
875 (*NextUniqueID)++;
876 }
877 }
879 GO, Kind, Mang, TM, EntrySize, UniqueSectionName);
880
881 // Use 0 as the unique ID for execute-only text.
882 if (Kind.isExecuteOnly())
883 UniqueID = 0;
884 return Ctx.getELFSection(Name, getELFSectionType(Name, Kind), Flags,
885 EntrySize, Group, IsComdat, UniqueID,
886 AssociatedSymbol);
887}
888
890 MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
891 const TargetMachine &TM, bool Retain, bool EmitUniqueSection,
892 unsigned Flags, unsigned *NextUniqueID) {
893 const MCSymbolELF *LinkedToSym = getLinkedToSymbol(GO, TM);
894 if (LinkedToSym) {
895 EmitUniqueSection = true;
896 Flags |= ELF::SHF_LINK_ORDER;
897 }
898 if (Retain) {
899 if (TM.getTargetTriple().isOSSolaris()) {
900 EmitUniqueSection = true;
902 } else if (Ctx.getAsmInfo()->useIntegratedAssembler() ||
903 Ctx.getAsmInfo()->binutilsIsAtLeast(2, 36)) {
904 EmitUniqueSection = true;
905 Flags |= ELF::SHF_GNU_RETAIN;
906 }
907 }
908
910 Ctx, GO, Kind, Mang, TM, EmitUniqueSection, Flags,
911 NextUniqueID, LinkedToSym);
912 assert(Section->getLinkedToSymbol() == LinkedToSym);
913 return Section;
914}
915
917 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
918 unsigned Flags = getELFSectionFlags(Kind);
919
920 // If we have -ffunction-section or -fdata-section then we should emit the
921 // global value to a uniqued section specifically for it.
922 bool EmitUniqueSection = false;
923 if (!(Flags & ELF::SHF_MERGE) && !Kind.isCommon()) {
924 if (Kind.isText())
925 EmitUniqueSection = TM.getFunctionSections();
926 else
927 EmitUniqueSection = TM.getDataSections();
928 }
929 EmitUniqueSection |= GO->hasComdat();
930 return selectELFSectionForGlobal(getContext(), GO, Kind, getMangler(), TM,
931 Used.count(GO), EmitUniqueSection, Flags,
932 &NextUniqueID);
933}
934
936 const Function &F, const TargetMachine &TM) const {
938 unsigned Flags = getELFSectionFlags(Kind);
939 // If the function's section names is pre-determined via pragma or a
940 // section attribute, call selectExplicitSectionGlobal.
941 if (F.hasSection() || F.hasFnAttribute("implicit-section-name"))
943 &F, Kind, TM, getContext(), getMangler(), NextUniqueID,
944 Used.count(&F), /* ForceUnique = */true);
945 else
947 getContext(), &F, Kind, getMangler(), TM, Used.count(&F),
948 /*EmitUniqueSection=*/true, Flags, &NextUniqueID);
949}
950
952 const Function &F, const TargetMachine &TM) const {
953 // If the function can be removed, produce a unique section so that
954 // the table doesn't prevent the removal.
955 const Comdat *C = F.getComdat();
956 bool EmitUniqueSection = TM.getFunctionSections() || C;
957 if (!EmitUniqueSection)
958 return ReadOnlySection;
959
961 getMangler(), TM, EmitUniqueSection,
962 ELF::SHF_ALLOC, &NextUniqueID,
963 /* AssociatedSymbol */ nullptr);
964}
965
967 const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const {
968 // If neither COMDAT nor function sections, use the monolithic LSDA section.
969 // Re-use this path if LSDASection is null as in the Arm EHABI.
970 if (!LSDASection || (!F.hasComdat() && !TM.getFunctionSections()))
971 return LSDASection;
972
973 const auto *LSDA = cast<MCSectionELF>(LSDASection);
974 unsigned Flags = LSDA->getFlags();
975 const MCSymbolELF *LinkedToSym = nullptr;
976 StringRef Group;
977 bool IsComdat = false;
978 if (const Comdat *C = getELFComdat(&F)) {
979 Flags |= ELF::SHF_GROUP;
980 Group = C->getName();
981 IsComdat = C->getSelectionKind() == Comdat::Any;
982 }
983 // Use SHF_LINK_ORDER to facilitate --gc-sections if we can use GNU ld>=2.36
984 // or LLD, which support mixed SHF_LINK_ORDER & non-SHF_LINK_ORDER.
985 if (TM.getFunctionSections() &&
986 (getContext().getAsmInfo()->useIntegratedAssembler() &&
987 getContext().getAsmInfo()->binutilsIsAtLeast(2, 36))) {
988 Flags |= ELF::SHF_LINK_ORDER;
989 LinkedToSym = cast<MCSymbolELF>(&FnSym);
990 }
991
992 // Append the function name as the suffix like GCC, assuming
993 // -funique-section-names applies to .gcc_except_table sections.
994 return getContext().getELFSection(
995 (TM.getUniqueSectionNames() ? LSDA->getName() + "." + F.getName()
996 : LSDA->getName()),
997 LSDA->getType(), Flags, 0, Group, IsComdat, MCSection::NonUniqueID,
998 LinkedToSym);
999}
1000
1002 bool UsesLabelDifference, const Function &F) const {
1003 // We can always create relative relocations, so use another section
1004 // that can be marked non-executable.
1005 return false;
1006}
1007
1008/// Given a mergeable constant with the specified size and relocation
1009/// information, return a section that it should be placed in.
1011 const DataLayout &DL, SectionKind Kind, const Constant *C,
1012 Align &Alignment) const {
1013 if (Kind.isMergeableConst4() && MergeableConst4Section)
1015 if (Kind.isMergeableConst8() && MergeableConst8Section)
1017 if (Kind.isMergeableConst16() && MergeableConst16Section)
1019 if (Kind.isMergeableConst32() && MergeableConst32Section)
1021 if (Kind.isReadOnly())
1022 return ReadOnlySection;
1023
1024 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
1025 return DataRelROSection;
1026}
1027
1028/// Returns a unique section for the given machine basic block.
1030 const Function &F, const MachineBasicBlock &MBB,
1031 const TargetMachine &TM) const {
1032 assert(MBB.isBeginSection() && "Basic block does not start a section!");
1033 unsigned UniqueID = MCContext::GenericSectionID;
1034
1035 // For cold sections use the .text.split. prefix along with the parent
1036 // function name. All cold blocks for the same function go to the same
1037 // section. Similarly all exception blocks are grouped by symbol name
1038 // under the .text.eh prefix. For regular sections, we either use a unique
1039 // name, or a unique ID for the section.
1041 StringRef FunctionSectionName = MBB.getParent()->getSection()->getName();
1042 if (FunctionSectionName.equals(".text") ||
1043 FunctionSectionName.startswith(".text.")) {
1044 // Function is in a regular .text section.
1045 StringRef FunctionName = MBB.getParent()->getName();
1048 Name += FunctionName;
1050 Name += ".text.eh.";
1051 Name += FunctionName;
1052 } else {
1053 Name += FunctionSectionName;
1055 if (!Name.endswith("."))
1056 Name += ".";
1057 Name += MBB.getSymbol()->getName();
1058 } else {
1059 UniqueID = NextUniqueID++;
1060 }
1061 }
1062 } else {
1063 // If the original function has a custom non-dot-text section, then emit
1064 // all basic block sections into that section too, each with a unique id.
1065 Name = FunctionSectionName;
1066 UniqueID = NextUniqueID++;
1067 }
1068
1069 unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_EXECINSTR;
1070 std::string GroupName;
1071 if (F.hasComdat()) {
1072 Flags |= ELF::SHF_GROUP;
1073 GroupName = F.getComdat()->getName().str();
1074 }
1076 0 /* Entry Size */, GroupName,
1077 F.hasComdat(), UniqueID, nullptr);
1078}
1079
1080static MCSectionELF *getStaticStructorSection(MCContext &Ctx, bool UseInitArray,
1081 bool IsCtor, unsigned Priority,
1082 const MCSymbol *KeySym) {
1083 std::string Name;
1084 unsigned Type;
1085 unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE;
1086 StringRef Comdat = KeySym ? KeySym->getName() : "";
1087
1088 if (KeySym)
1089 Flags |= ELF::SHF_GROUP;
1090
1091 if (UseInitArray) {
1092 if (IsCtor) {
1094 Name = ".init_array";
1095 } else {
1097 Name = ".fini_array";
1098 }
1099 if (Priority != 65535) {
1100 Name += '.';
1101 Name += utostr(Priority);
1102 }
1103 } else {
1104 // The default scheme is .ctor / .dtor, so we have to invert the priority
1105 // numbering.
1106 if (IsCtor)
1107 Name = ".ctors";
1108 else
1109 Name = ".dtors";
1110 if (Priority != 65535)
1111 raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
1113 }
1114
1115 return Ctx.getELFSection(Name, Type, Flags, 0, Comdat, /*IsComdat=*/true);
1116}
1117
1119 unsigned Priority, const MCSymbol *KeySym) const {
1120 return getStaticStructorSection(getContext(), UseInitArray, true, Priority,
1121 KeySym);
1122}
1123
1125 unsigned Priority, const MCSymbol *KeySym) const {
1126 return getStaticStructorSection(getContext(), UseInitArray, false, Priority,
1127 KeySym);
1128}
1129
1131 const GlobalValue *LHS, const GlobalValue *RHS,
1132 const TargetMachine &TM) const {
1133 // We may only use a PLT-relative relocation to refer to unnamed_addr
1134 // functions.
1135 if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
1136 return nullptr;
1137
1138 // Basic correctness checks.
1139 if (LHS->getType()->getPointerAddressSpace() != 0 ||
1140 RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
1141 RHS->isThreadLocal())
1142 return nullptr;
1143
1146 getContext()),
1148}
1149
1151 const DSOLocalEquivalent *Equiv, const TargetMachine &TM) const {
1153
1154 const auto *GV = Equiv->getGlobalValue();
1155
1156 // A PLT entry is not needed for dso_local globals.
1157 if (GV->isDSOLocal() || GV->isImplicitDSOLocal())
1159
1161 getContext());
1162}
1163
1165 // Use ".GCC.command.line" since this feature is to support clang's
1166 // -frecord-gcc-switches which in turn attempts to mimic GCC's switch of the
1167 // same name.
1168 return getContext().getELFSection(".GCC.command.line", ELF::SHT_PROGBITS,
1170}
1171
1172void
1174 UseInitArray = UseInitArray_;
1175 MCContext &Ctx = getContext();
1176 if (!UseInitArray) {
1179
1182 return;
1183 }
1184
1189}
1190
1191//===----------------------------------------------------------------------===//
1192// MachO
1193//===----------------------------------------------------------------------===//
1194
1197}
1198
1200 const TargetMachine &TM) {
1203 StaticCtorSection = Ctx.getMachOSection("__TEXT", "__constructor", 0,
1205 StaticDtorSection = Ctx.getMachOSection("__TEXT", "__destructor", 0,
1207 } else {
1208 StaticCtorSection = Ctx.getMachOSection("__DATA", "__mod_init_func",
1211 StaticDtorSection = Ctx.getMachOSection("__DATA", "__mod_term_func",
1214 }
1215
1221}
1222
1224 unsigned Priority, const MCSymbol *KeySym) const {
1225 return StaticDtorSection;
1226 // In userspace, we lower global destructors via atexit(), but kernel/kext
1227 // environments do not provide this function so we still need to support the
1228 // legacy way here.
1229 // See the -disable-atexit-based-global-dtor-lowering CodeGen flag for more
1230 // context.
1231}
1232
1234 Module &M) const {
1235 // Emit the linker options if present.
1236 if (auto *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
1237 for (const auto *Option : LinkerOptions->operands()) {
1238 SmallVector<std::string, 4> StrOptions;
1239 for (const auto &Piece : cast<MDNode>(Option)->operands())
1240 StrOptions.push_back(std::string(cast<MDString>(Piece)->getString()));
1241 Streamer.emitLinkerOptions(StrOptions);
1242 }
1243 }
1244
1245 unsigned VersionVal = 0;
1246 unsigned ImageInfoFlags = 0;
1247 StringRef SectionVal;
1248
1249 GetObjCImageInfo(M, VersionVal, ImageInfoFlags, SectionVal);
1250 emitCGProfileMetadata(Streamer, M);
1251
1252 // The section is mandatory. If we don't have it, then we don't have GC info.
1253 if (SectionVal.empty())
1254 return;
1255
1256 StringRef Segment, Section;
1257 unsigned TAA = 0, StubSize = 0;
1258 bool TAAParsed;
1260 SectionVal, Segment, Section, TAA, TAAParsed, StubSize)) {
1261 // If invalid, report the error with report_fatal_error.
1262 report_fatal_error("Invalid section specifier '" + Section +
1263 "': " + toString(std::move(E)) + ".");
1264 }
1265
1266 // Get the section.
1268 Segment, Section, TAA, StubSize, SectionKind::getData());
1269 Streamer.switchSection(S);
1270 Streamer.emitLabel(getContext().
1271 getOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
1272 Streamer.emitInt32(VersionVal);
1273 Streamer.emitInt32(ImageInfoFlags);
1274 Streamer.addBlankLine();
1275}
1276
1277static void checkMachOComdat(const GlobalValue *GV) {
1278 const Comdat *C = GV->getComdat();
1279 if (!C)
1280 return;
1281
1282 report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() +
1283 "' cannot be lowered.");
1284}
1285
1287 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1288
1290
1291 const GlobalVariable *GV = dyn_cast<GlobalVariable>(GO);
1292 if (GV && GV->hasImplicitSection()) {
1293 auto Attrs = GV->getAttributes();
1294 if (Attrs.hasAttribute("bss-section") && Kind.isBSS()) {
1295 SectionName = Attrs.getAttribute("bss-section").getValueAsString();
1296 } else if (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly()) {
1297 SectionName = Attrs.getAttribute("rodata-section").getValueAsString();
1298 } else if (Attrs.hasAttribute("relro-section") && Kind.isReadOnlyWithRel()) {
1299 SectionName = Attrs.getAttribute("relro-section").getValueAsString();
1300 } else if (Attrs.hasAttribute("data-section") && Kind.isData()) {
1301 SectionName = Attrs.getAttribute("data-section").getValueAsString();
1302 }
1303 }
1304
1305 const Function *F = dyn_cast<Function>(GO);
1306 if (F && F->hasFnAttribute("implicit-section-name")) {
1307 SectionName = F->getFnAttribute("implicit-section-name").getValueAsString();
1308 }
1309
1310 // Parse the section specifier and create it if valid.
1311 StringRef Segment, Section;
1312 unsigned TAA = 0, StubSize = 0;
1313 bool TAAParsed;
1314
1315 checkMachOComdat(GO);
1316
1318 SectionName, Segment, Section, TAA, TAAParsed, StubSize)) {
1319 // If invalid, report the error with report_fatal_error.
1320 report_fatal_error("Global variable '" + GO->getName() +
1321 "' has an invalid section specifier '" +
1322 GO->getSection() + "': " + toString(std::move(E)) + ".");
1323 }
1324
1325 // Get the section.
1326 MCSectionMachO *S =
1327 getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
1328
1329 // If TAA wasn't set by ParseSectionSpecifier() above,
1330 // use the value returned by getMachOSection() as a default.
1331 if (!TAAParsed)
1332 TAA = S->getTypeAndAttributes();
1333
1334 // Okay, now that we got the section, verify that the TAA & StubSize agree.
1335 // If the user declared multiple globals with different section flags, we need
1336 // to reject it here.
1337 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
1338 // If invalid, report the error with report_fatal_error.
1339 report_fatal_error("Global variable '" + GO->getName() +
1340 "' section type or attributes does not match previous"
1341 " section specifier");
1342 }
1343
1344 return S;
1345}
1346
1348 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1349 checkMachOComdat(GO);
1350
1351 // Handle thread local data.
1352 if (Kind.isThreadBSS()) return TLSBSSSection;
1353 if (Kind.isThreadData()) return TLSDataSection;
1354
1355 if (Kind.isText())
1357
1358 // If this is weak/linkonce, put this in a coalescable section, either in text
1359 // or data depending on if it is writable.
1360 if (GO->isWeakForLinker()) {
1361 if (Kind.isReadOnly())
1362 return ConstTextCoalSection;
1363 if (Kind.isReadOnlyWithRel())
1364 return ConstDataCoalSection;
1365 return DataCoalSection;
1366 }
1367
1368 // FIXME: Alignment check should be handled by section classifier.
1369 if (Kind.isMergeable1ByteCString() &&
1371 cast<GlobalVariable>(GO)) < Align(32))
1372 return CStringSection;
1373
1374 // Do not put 16-bit arrays in the UString section if they have an
1375 // externally visible label, this runs into issues with certain linker
1376 // versions.
1377 if (Kind.isMergeable2ByteCString() && !GO->hasExternalLinkage() &&
1379 cast<GlobalVariable>(GO)) < Align(32))
1380 return UStringSection;
1381
1382 // With MachO only variables whose corresponding symbol starts with 'l' or
1383 // 'L' can be merged, so we only try merging GVs with private linkage.
1384 if (GO->hasPrivateLinkage() && Kind.isMergeableConst()) {
1385 if (Kind.isMergeableConst4())
1387 if (Kind.isMergeableConst8())
1389 if (Kind.isMergeableConst16())
1391 }
1392
1393 // Otherwise, if it is readonly, but not something we can specially optimize,
1394 // just drop it in .const.
1395 if (Kind.isReadOnly())
1396 return ReadOnlySection;
1397
1398 // If this is marked const, put it into a const section. But if the dynamic
1399 // linker needs to write to it, put it in the data segment.
1400 if (Kind.isReadOnlyWithRel())
1401 return ConstDataSection;
1402
1403 // Put zero initialized globals with strong external linkage in the
1404 // DATA, __common section with the .zerofill directive.
1405 if (Kind.isBSSExtern())
1406 return DataCommonSection;
1407
1408 // Put zero initialized globals with local linkage in __DATA,__bss directive
1409 // with the .zerofill directive (aka .lcomm).
1410 if (Kind.isBSSLocal())
1411 return DataBSSSection;
1412
1413 // Otherwise, just drop the variable in the normal data section.
1414 return DataSection;
1415}
1416
1418 const DataLayout &DL, SectionKind Kind, const Constant *C,
1419 Align &Alignment) const {
1420 // If this constant requires a relocation, we have to put it in the data
1421 // segment, not in the text segment.
1422 if (Kind.isData() || Kind.isReadOnlyWithRel())
1423 return ConstDataSection;
1424
1425 if (Kind.isMergeableConst4())
1427 if (Kind.isMergeableConst8())
1429 if (Kind.isMergeableConst16())
1431 return ReadOnlySection; // .const
1432}
1433
1435 return getContext().getMachOSection("__TEXT", "__command_line", 0,
1437}
1438
1440 const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
1441 MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1442 // The mach-o version of this method defaults to returning a stub reference.
1443
1444 if (Encoding & DW_EH_PE_indirect) {
1445 MachineModuleInfoMachO &MachOMMI =
1447
1448 MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
1449
1450 // Add information about the stub reference to MachOMMI so that the stub
1451 // gets emitted by the asmprinter.
1452 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
1453 if (!StubSym.getPointer()) {
1454 MCSymbol *Sym = TM.getSymbol(GV);
1456 }
1457
1460 Encoding & ~DW_EH_PE_indirect, Streamer);
1461 }
1462
1464 MMI, Streamer);
1465}
1466
1468 const GlobalValue *GV, const TargetMachine &TM,
1469 MachineModuleInfo *MMI) const {
1470 // The mach-o version of this method defaults to returning a stub reference.
1471 MachineModuleInfoMachO &MachOMMI =
1473
1474 MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
1475
1476 // Add information about the stub reference to MachOMMI so that the stub
1477 // gets emitted by the asmprinter.
1478 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
1479 if (!StubSym.getPointer()) {
1480 MCSymbol *Sym = TM.getSymbol(GV);
1482 }
1483
1484 return SSym;
1485}
1486
1488 const GlobalValue *GV, const MCSymbol *Sym, const MCValue &MV,
1489 int64_t Offset, MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1490 // Although MachO 32-bit targets do not explicitly have a GOTPCREL relocation
1491 // as 64-bit do, we replace the GOT equivalent by accessing the final symbol
1492 // through a non_lazy_ptr stub instead. One advantage is that it allows the
1493 // computation of deltas to final external symbols. Example:
1494 //
1495 // _extgotequiv:
1496 // .long _extfoo
1497 //
1498 // _delta:
1499 // .long _extgotequiv-_delta
1500 //
1501 // is transformed to:
1502 //
1503 // _delta:
1504 // .long L_extfoo$non_lazy_ptr-(_delta+0)
1505 //
1506 // .section __IMPORT,__pointers,non_lazy_symbol_pointers
1507 // L_extfoo$non_lazy_ptr:
1508 // .indirect_symbol _extfoo
1509 // .long 0
1510 //
1511 // The indirect symbol table (and sections of non_lazy_symbol_pointers type)
1512 // may point to both local (same translation unit) and global (other
1513 // translation units) symbols. Example:
1514 //
1515 // .section __DATA,__pointers,non_lazy_symbol_pointers
1516 // L1:
1517 // .indirect_symbol _myGlobal
1518 // .long 0
1519 // L2:
1520 // .indirect_symbol _myLocal
1521 // .long _myLocal
1522 //
1523 // If the symbol is local, instead of the symbol's index, the assembler
1524 // places the constant INDIRECT_SYMBOL_LOCAL into the indirect symbol table.
1525 // Then the linker will notice the constant in the table and will look at the
1526 // content of the symbol.
1527 MachineModuleInfoMachO &MachOMMI =
1529 MCContext &Ctx = getContext();
1530
1531 // The offset must consider the original displacement from the base symbol
1532 // since 32-bit targets don't have a GOTPCREL to fold the PC displacement.
1533 Offset = -MV.getConstant();
1534 const MCSymbol *BaseSym = &MV.getSymB()->getSymbol();
1535
1536 // Access the final symbol via sym$non_lazy_ptr and generate the appropriated
1537 // non_lazy_ptr stubs.
1539 StringRef Suffix = "$non_lazy_ptr";
1541 Name += Sym->getName();
1542 Name += Suffix;
1543 MCSymbol *Stub = Ctx.getOrCreateSymbol(Name);
1544
1545 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Stub);
1546
1547 if (!StubSym.getPointer())
1548 StubSym = MachineModuleInfoImpl::StubValueTy(const_cast<MCSymbol *>(Sym),
1549 !GV->hasLocalLinkage());
1550
1551 const MCExpr *BSymExpr =
1553 const MCExpr *LHS =
1555
1556 if (!Offset)
1557 return MCBinaryExpr::createSub(LHS, BSymExpr, Ctx);
1558
1559 const MCExpr *RHS =
1561 return MCBinaryExpr::createSub(LHS, RHS, Ctx);
1562}
1563
1564static bool canUsePrivateLabel(const MCAsmInfo &AsmInfo,
1565 const MCSection &Section) {
1566 if (!AsmInfo.isSectionAtomizableBySymbols(Section))
1567 return true;
1568
1569 // FIXME: we should be able to use private labels for sections that can't be
1570 // dead-stripped (there's no issue with blocking atomization there), but `ld
1571 // -r` sometimes drops the no_dead_strip attribute from sections so for safety
1572 // we don't allow it.
1573 return false;
1574}
1575
1577 SmallVectorImpl<char> &OutName, const GlobalValue *GV,
1578 const TargetMachine &TM) const {
1579 bool CannotUsePrivateLabel = true;
1580 if (auto *GO = GV->getAliaseeObject()) {
1582 const MCSection *TheSection = SectionForGlobal(GO, GOKind, TM);
1583 CannotUsePrivateLabel =
1584 !canUsePrivateLabel(*TM.getMCAsmInfo(), *TheSection);
1585 }
1586 getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
1587}
1588
1589//===----------------------------------------------------------------------===//
1590// COFF
1591//===----------------------------------------------------------------------===//
1592
1593static unsigned
1595 unsigned Flags = 0;
1596 bool isThumb = TM.getTargetTriple().getArch() == Triple::thumb;
1597
1598 if (K.isMetadata())
1599 Flags |=
1601 else if (K.isExclude())
1602 Flags |=
1604 else if (K.isText())
1605 Flags |=
1610 else if (K.isBSS())
1611 Flags |=
1615 else if (K.isThreadLocal())
1616 Flags |=
1620 else if (K.isReadOnly() || K.isReadOnlyWithRel())
1621 Flags |=
1624 else if (K.isWriteable())
1625 Flags |=
1629
1630 return Flags;
1631}
1632
1634 const Comdat *C = GV->getComdat();
1635 assert(C && "expected GV to have a Comdat!");
1636
1637 StringRef ComdatGVName = C->getName();
1638 const GlobalValue *ComdatGV = GV->getParent()->getNamedValue(ComdatGVName);
1639 if (!ComdatGV)
1640 report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
1641 "' does not exist.");
1642
1643 if (ComdatGV->getComdat() != C)
1644 report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
1645 "' is not a key for its COMDAT.");
1646
1647 return ComdatGV;
1648}
1649
1650static int getSelectionForCOFF(const GlobalValue *GV) {
1651 if (const Comdat *C = GV->getComdat()) {
1652 const GlobalValue *ComdatKey = getComdatGVForCOFF(GV);
1653 if (const auto *GA = dyn_cast<GlobalAlias>(ComdatKey))
1654 ComdatKey = GA->getAliaseeObject();
1655 if (ComdatKey == GV) {
1656 switch (C->getSelectionKind()) {
1657 case Comdat::Any:
1659 case Comdat::ExactMatch:
1661 case Comdat::Largest:
1665 case Comdat::SameSize:
1667 }
1668 } else {
1670 }
1671 }
1672 return 0;
1673}
1674
1676 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1677 int Selection = 0;
1678 unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1679 StringRef Name = GO->getSection();
1680 StringRef COMDATSymName = "";
1681 if (GO->hasComdat()) {
1683 const GlobalValue *ComdatGV;
1685 ComdatGV = getComdatGVForCOFF(GO);
1686 else
1687 ComdatGV = GO;
1688
1689 if (!ComdatGV->hasPrivateLinkage()) {
1690 MCSymbol *Sym = TM.getSymbol(ComdatGV);
1691 COMDATSymName = Sym->getName();
1693 } else {
1694 Selection = 0;
1695 }
1696 }
1697
1698 return getContext().getCOFFSection(Name, Characteristics, Kind, COMDATSymName,
1699 Selection);
1700}
1701
1703 if (Kind.isText())
1704 return ".text";
1705 if (Kind.isBSS())
1706 return ".bss";
1707 if (Kind.isThreadLocal())
1708 return ".tls$";
1709 if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
1710 return ".rdata";
1711 return ".data";
1712}
1713
1715 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1716 // If we have -ffunction-sections then we should emit the global value to a
1717 // uniqued section specifically for it.
1718 bool EmitUniquedSection;
1719 if (Kind.isText())
1720 EmitUniquedSection = TM.getFunctionSections();
1721 else
1722 EmitUniquedSection = TM.getDataSections();
1723
1724 if ((EmitUniquedSection && !Kind.isCommon()) || GO->hasComdat()) {
1726
1727 unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1728
1731 if (!Selection)
1733 const GlobalValue *ComdatGV;
1734 if (GO->hasComdat())
1735 ComdatGV = getComdatGVForCOFF(GO);
1736 else
1737 ComdatGV = GO;
1738
1739 unsigned UniqueID = MCContext::GenericSectionID;
1740 if (EmitUniquedSection)
1741 UniqueID = NextUniqueID++;
1742
1743 if (!ComdatGV->hasPrivateLinkage()) {
1744 MCSymbol *Sym = TM.getSymbol(ComdatGV);
1745 StringRef COMDATSymName = Sym->getName();
1746
1747 if (const auto *F = dyn_cast<Function>(GO))
1748 if (std::optional<StringRef> Prefix = F->getSectionPrefix())
1749 raw_svector_ostream(Name) << '$' << *Prefix;
1750
1751 // Append "$symbol" to the section name *before* IR-level mangling is
1752 // applied when targetting mingw. This is what GCC does, and the ld.bfd
1753 // COFF linker will not properly handle comdats otherwise.
1754 if (getContext().getTargetTriple().isWindowsGNUEnvironment())
1755 raw_svector_ostream(Name) << '$' << ComdatGV->getName();
1756
1758 COMDATSymName, Selection, UniqueID);
1759 } else {
1760 SmallString<256> TmpData;
1761 getMangler().getNameWithPrefix(TmpData, GO, /*CannotUsePrivateLabel=*/true);
1762 return getContext().getCOFFSection(Name, Characteristics, Kind, TmpData,
1763 Selection, UniqueID);
1764 }
1765 }
1766
1767 if (Kind.isText())
1768 return TextSection;
1769
1770 if (Kind.isThreadLocal())
1771 return TLSDataSection;
1772
1773 if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
1774 return ReadOnlySection;
1775
1776 // Note: we claim that common symbols are put in BSSSection, but they are
1777 // really emitted with the magic .comm directive, which creates a symbol table
1778 // entry but not a section.
1779 if (Kind.isBSS() || Kind.isCommon())
1780 return BSSSection;
1781
1782 return DataSection;
1783}
1784
1786 SmallVectorImpl<char> &OutName, const GlobalValue *GV,
1787 const TargetMachine &TM) const {
1788 bool CannotUsePrivateLabel = false;
1789 if (GV->hasPrivateLinkage() &&
1790 ((isa<Function>(GV) && TM.getFunctionSections()) ||
1791 (isa<GlobalVariable>(GV) && TM.getDataSections())))
1792 CannotUsePrivateLabel = true;
1793
1794 getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
1795}
1796
1798 const Function &F, const TargetMachine &TM) const {
1799 // If the function can be removed, produce a unique section so that
1800 // the table doesn't prevent the removal.
1801 const Comdat *C = F.getComdat();
1802 bool EmitUniqueSection = TM.getFunctionSections() || C;
1803 if (!EmitUniqueSection)
1804 return ReadOnlySection;
1805
1806 // FIXME: we should produce a symbol for F instead.
1807 if (F.hasPrivateLinkage())
1808 return ReadOnlySection;
1809
1810 MCSymbol *Sym = TM.getSymbol(&F);
1811 StringRef COMDATSymName = Sym->getName();
1812
1815 unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1817 unsigned UniqueID = NextUniqueID++;
1818
1819 return getContext().getCOFFSection(
1820 SecName, Characteristics, Kind, COMDATSymName,
1822}
1823
1825 bool UsesLabelDifference, const Function &F) const {
1826 if (TM->getTargetTriple().getArch() == Triple::x86_64) {
1828 // We can always create relative relocations, so use another section
1829 // that can be marked non-executable.
1830 return false;
1831 }
1832 }
1834 UsesLabelDifference, F);
1835}
1836
1838 Module &M) const {
1839 emitLinkerDirectives(Streamer, M);
1840
1841 unsigned Version = 0;
1842 unsigned Flags = 0;
1843 StringRef Section;
1844
1845 GetObjCImageInfo(M, Version, Flags, Section);
1846 if (!Section.empty()) {
1847 auto &C = getContext();
1848 auto *S = C.getCOFFSection(Section,
1852 Streamer.switchSection(S);
1853 Streamer.emitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
1854 Streamer.emitInt32(Version);
1855 Streamer.emitInt32(Flags);
1856 Streamer.addBlankLine();
1857 }
1858
1859 emitCGProfileMetadata(Streamer, M);
1860}
1861
1862void TargetLoweringObjectFileCOFF::emitLinkerDirectives(
1863 MCStreamer &Streamer, Module &M) const {
1864 if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
1865 // Emit the linker options to the linker .drectve section. According to the
1866 // spec, this section is a space-separated string containing flags for
1867 // linker.
1869 Streamer.switchSection(Sec);
1870 for (const auto *Option : LinkerOptions->operands()) {
1871 for (const auto &Piece : cast<MDNode>(Option)->operands()) {
1872 // Lead with a space for consistency with our dllexport implementation.
1873 std::string Directive(" ");
1874 Directive.append(std::string(cast<MDString>(Piece)->getString()));
1875 Streamer.emitBytes(Directive);
1876 }
1877 }
1878 }
1879
1880 // Emit /EXPORT: flags for each exported global as necessary.
1881 std::string Flags;
1882 for (const GlobalValue &GV : M.global_values()) {
1883 raw_string_ostream OS(Flags);
1884 emitLinkerFlagsForGlobalCOFF(OS, &GV, getContext().getTargetTriple(),
1885 getMangler());
1886 OS.flush();
1887 if (!Flags.empty()) {
1888 Streamer.switchSection(getDrectveSection());
1889 Streamer.emitBytes(Flags);
1890 }
1891 Flags.clear();
1892 }
1893
1894 // Emit /INCLUDE: flags for each used global as necessary.
1895 if (const auto *LU = M.getNamedGlobal("llvm.used")) {
1896 assert(LU->hasInitializer() && "expected llvm.used to have an initializer");
1897 assert(isa<ArrayType>(LU->getValueType()) &&
1898 "expected llvm.used to be an array type");
1899 if (const auto *A = cast<ConstantArray>(LU->getInitializer())) {
1900 for (const Value *Op : A->operands()) {
1901 const auto *GV = cast<GlobalValue>(Op->stripPointerCasts());
1902 // Global symbols with internal or private linkage are not visible to
1903 // the linker, and thus would cause an error when the linker tried to
1904 // preserve the symbol due to the `/include:` directive.
1905 if (GV->hasLocalLinkage())
1906 continue;
1907
1908 raw_string_ostream OS(Flags);
1909 emitLinkerFlagsForUsedCOFF(OS, GV, getContext().getTargetTriple(),
1910 getMangler());
1911 OS.flush();
1912
1913 if (!Flags.empty()) {
1914 Streamer.switchSection(getDrectveSection());
1915 Streamer.emitBytes(Flags);
1916 }
1917 Flags.clear();
1918 }
1919 }
1920 }
1921}
1922
1924 const TargetMachine &TM) {
1926 this->TM = &TM;
1927 const Triple &T = TM.getTargetTriple();
1928 if (T.isWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) {
1937 } else {
1946 }
1947}
1948
1950 const Triple &T, bool IsCtor,
1951 unsigned Priority,
1952 const MCSymbol *KeySym,
1954 if (T.isWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) {
1955 // If the priority is the default, use .CRT$XCU, possibly associative.
1956 if (Priority == 65535)
1957 return Ctx.getAssociativeCOFFSection(Default, KeySym, 0);
1958
1959 // Otherwise, we need to compute a new section name. Low priorities should
1960 // run earlier. The linker will sort sections ASCII-betically, and we need a
1961 // string that sorts between .CRT$XCA and .CRT$XCU. In the general case, we
1962 // make a name like ".CRT$XCT12345", since that runs before .CRT$XCU. Really
1963 // low priorities need to sort before 'L', since the CRT uses that
1964 // internally, so we use ".CRT$XCA00001" for them. We have a contract with
1965 // the frontend that "init_seg(compiler)" corresponds to priority 200 and
1966 // "init_seg(lib)" corresponds to priority 400, and those respectively use
1967 // 'C' and 'L' without the priority suffix. Priorities between 200 and 400
1968 // use 'C' with the priority as a suffix.
1970 char LastLetter = 'T';
1971 bool AddPrioritySuffix = Priority != 200 && Priority != 400;
1972 if (Priority < 200)
1973 LastLetter = 'A';
1974 else if (Priority < 400)
1975 LastLetter = 'C';
1976 else if (Priority == 400)
1977 LastLetter = 'L';
1979 OS << ".CRT$X" << (IsCtor ? "C" : "T") << LastLetter;
1980 if (AddPrioritySuffix)
1981 OS << format("%05u", Priority);
1982 MCSectionCOFF *Sec = Ctx.getCOFFSection(
1985 return Ctx.getAssociativeCOFFSection(Sec, KeySym, 0);
1986 }
1987
1988 std::string Name = IsCtor ? ".ctors" : ".dtors";
1989 if (Priority != 65535)
1990 raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
1991
1992 return Ctx.getAssociativeCOFFSection(
1997 KeySym, 0);
1998}
1999
2001 unsigned Priority, const MCSymbol *KeySym) const {
2003 getContext(), getContext().getTargetTriple(), true, Priority, KeySym,
2004 cast<MCSectionCOFF>(StaticCtorSection));
2005}
2006
2008 unsigned Priority, const MCSymbol *KeySym) const {
2010 getContext(), getContext().getTargetTriple(), false, Priority, KeySym,
2011 cast<MCSectionCOFF>(StaticDtorSection));
2012}
2013
2015 const GlobalValue *LHS, const GlobalValue *RHS,
2016 const TargetMachine &TM) const {
2017 const Triple &T = TM.getTargetTriple();
2018 if (T.isOSCygMing())
2019 return nullptr;
2020
2021 // Our symbols should exist in address space zero, cowardly no-op if
2022 // otherwise.
2023 if (LHS->getType()->getPointerAddressSpace() != 0 ||
2025 return nullptr;
2026
2027 // Both ptrtoint instructions must wrap global objects:
2028 // - Only global variables are eligible for image relative relocations.
2029 // - The subtrahend refers to the special symbol __ImageBase, a GlobalVariable.
2030 // We expect __ImageBase to be a global variable without a section, externally
2031 // defined.
2032 //
2033 // It should look something like this: @__ImageBase = external constant i8
2034 if (!isa<GlobalObject>(LHS) || !isa<GlobalVariable>(RHS) ||
2035 LHS->isThreadLocal() || RHS->isThreadLocal() ||
2036 RHS->getName() != "__ImageBase" || !RHS->hasExternalLinkage() ||
2037 cast<GlobalVariable>(RHS)->hasInitializer() || RHS->hasSection())
2038 return nullptr;
2039
2040 return MCSymbolRefExpr::create(TM.getSymbol(LHS),
2042 getContext());
2043}
2044
2045static std::string APIntToHexString(const APInt &AI) {
2046 unsigned Width = (AI.getBitWidth() / 8) * 2;
2047 std::string HexString = toString(AI, 16, /*Signed=*/false);
2048 llvm::transform(HexString, HexString.begin(), tolower);
2049 unsigned Size = HexString.size();
2050 assert(Width >= Size && "hex string is too large!");
2051 HexString.insert(HexString.begin(), Width - Size, '0');
2052
2053 return HexString;
2054}
2055
2056static std::string scalarConstantToHexString(const Constant *C) {
2057 Type *Ty = C->getType();
2058 if (isa<UndefValue>(C)) {
2060 } else if (const auto *CFP = dyn_cast<ConstantFP>(C)) {
2061 return APIntToHexString(CFP->getValueAPF().bitcastToAPInt());
2062 } else if (const auto *CI = dyn_cast<ConstantInt>(C)) {
2063 return APIntToHexString(CI->getValue());
2064 } else {
2065 unsigned NumElements;
2066 if (auto *VTy = dyn_cast<VectorType>(Ty))
2067 NumElements = cast<FixedVectorType>(VTy)->getNumElements();
2068 else
2069 NumElements = Ty->getArrayNumElements();
2070 std::string HexString;
2071 for (int I = NumElements - 1, E = -1; I != E; --I)
2072 HexString += scalarConstantToHexString(C->getAggregateElement(I));
2073 return HexString;
2074 }
2075}
2076
2078 const DataLayout &DL, SectionKind Kind, const Constant *C,
2079 Align &Alignment) const {
2080 if (Kind.isMergeableConst() && C &&
2081 getContext().getAsmInfo()->hasCOFFComdatConstants()) {
2082 // This creates comdat sections with the given symbol name, but unless
2083 // AsmPrinter::GetCPISymbol actually makes the symbol global, the symbol
2084 // will be created with a null storage class, which makes GNU binutils
2085 // error out.
2089 std::string COMDATSymName;
2090 if (Kind.isMergeableConst4()) {
2091 if (Alignment <= 4) {
2092 COMDATSymName = "__real@" + scalarConstantToHexString(C);
2093 Alignment = Align(4);
2094 }
2095 } else if (Kind.isMergeableConst8()) {
2096 if (Alignment <= 8) {
2097 COMDATSymName = "__real@" + scalarConstantToHexString(C);
2098 Alignment = Align(8);
2099 }
2100 } else if (Kind.isMergeableConst16()) {
2101 // FIXME: These may not be appropriate for non-x86 architectures.
2102 if (Alignment <= 16) {
2103 COMDATSymName = "__xmm@" + scalarConstantToHexString(C);
2104 Alignment = Align(16);
2105 }
2106 } else if (Kind.isMergeableConst32()) {
2107 if (Alignment <= 32) {
2108 COMDATSymName = "__ymm@" + scalarConstantToHexString(C);
2109 Alignment = Align(32);
2110 }
2111 }
2112
2113 if (!COMDATSymName.empty())
2114 return getContext().getCOFFSection(".rdata", Characteristics, Kind,
2115 COMDATSymName,
2117 }
2118
2120 Alignment);
2121}
2122
2123//===----------------------------------------------------------------------===//
2124// Wasm
2125//===----------------------------------------------------------------------===//
2126
2127static const Comdat *getWasmComdat(const GlobalValue *GV) {
2128 const Comdat *C = GV->getComdat();
2129 if (!C)
2130 return nullptr;
2131
2132 if (C->getSelectionKind() != Comdat::Any)
2133 report_fatal_error("WebAssembly COMDATs only support "
2134 "SelectionKind::Any, '" + C->getName() + "' cannot be "
2135 "lowered.");
2136
2137 return C;
2138}
2139
2141 unsigned Flags = 0;
2142
2143 if (K.isThreadLocal())
2144 Flags |= wasm::WASM_SEG_FLAG_TLS;
2145
2146 if (K.isMergeableCString())
2148
2149 // TODO(sbc): Add suport for K.isMergeableConst()
2150
2151 return Flags;
2152}
2153
2155 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2156 // We don't support explict section names for functions in the wasm object
2157 // format. Each function has to be in its own unique section.
2158 if (isa<Function>(GO)) {
2159 return SelectSectionForGlobal(GO, Kind, TM);
2160 }
2161
2162 StringRef Name = GO->getSection();
2163
2164 // Certain data sections we treat as named custom sections rather than
2165 // segments within the data section.
2166 // This could be avoided if all data segements (the wasm sense) were
2167 // represented as their own sections (in the llvm sense).
2168 // TODO(sbc): https://github.com/WebAssembly/tool-conventions/issues/138
2169 if (Name == ".llvmcmd" || Name == ".llvmbc")
2170 Kind = SectionKind::getMetadata();
2171
2172 StringRef Group = "";
2173 if (const Comdat *C = getWasmComdat(GO)) {
2174 Group = C->getName();
2175 }
2176
2177 unsigned Flags = getWasmSectionFlags(Kind);
2179 Name, Kind, Flags, Group, MCContext::GenericSectionID);
2180
2181 return Section;
2182}
2183
2185 MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
2186 const TargetMachine &TM, bool EmitUniqueSection, unsigned *NextUniqueID) {
2187 StringRef Group = "";
2188 if (const Comdat *C = getWasmComdat(GO)) {
2189 Group = C->getName();
2190 }
2191
2192 bool UniqueSectionNames = TM.getUniqueSectionNames();
2193 SmallString<128> Name = getSectionPrefixForGlobal(Kind, /*IsLarge=*/false);
2194
2195 if (const auto *F = dyn_cast<Function>(GO)) {
2196 const auto &OptionalPrefix = F->getSectionPrefix();
2197 if (OptionalPrefix)
2198 raw_svector_ostream(Name) << '.' << *OptionalPrefix;
2199 }
2200
2201 if (EmitUniqueSection && UniqueSectionNames) {
2202 Name.push_back('.');
2203 TM.getNameWithPrefix(Name, GO, Mang, true);
2204 }
2205 unsigned UniqueID = MCContext::GenericSectionID;
2206 if (EmitUniqueSection && !UniqueSectionNames) {
2207 UniqueID = *NextUniqueID;
2208 (*NextUniqueID)++;
2209 }
2210
2211 unsigned Flags = getWasmSectionFlags(Kind);
2212 return Ctx.getWasmSection(Name, Kind, Flags, Group, UniqueID);
2213}
2214
2216 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2217
2218 if (Kind.isCommon())
2219 report_fatal_error("mergable sections not supported yet on wasm");
2220
2221 // If we have -ffunction-section or -fdata-section then we should emit the
2222 // global value to a uniqued section specifically for it.
2223 bool EmitUniqueSection = false;
2224 if (Kind.isText())
2225 EmitUniqueSection = TM.getFunctionSections();
2226 else
2227 EmitUniqueSection = TM.getDataSections();
2228 EmitUniqueSection |= GO->hasComdat();
2229
2230 return selectWasmSectionForGlobal(getContext(), GO, Kind, getMangler(), TM,
2231 EmitUniqueSection, &NextUniqueID);
2232}
2233
2235 bool UsesLabelDifference, const Function &F) const {
2236 // We can always create relative relocations, so use another section
2237 // that can be marked non-executable.
2238 return false;
2239}
2240
2242 const GlobalValue *LHS, const GlobalValue *RHS,
2243 const TargetMachine &TM) const {
2244 // We may only use a PLT-relative relocation to refer to unnamed_addr
2245 // functions.
2246 if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
2247 return nullptr;
2248
2249 // Basic correctness checks.
2250 if (LHS->getType()->getPointerAddressSpace() != 0 ||
2251 RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
2252 RHS->isThreadLocal())
2253 return nullptr;
2254
2257 getContext()),
2259}
2260
2264
2265 // We don't use PersonalityEncoding and LSDAEncoding because we don't emit
2266 // .cfi directives. We use TTypeEncoding to encode typeinfo global variables.
2268}
2269
2271 unsigned Priority, const MCSymbol *KeySym) const {
2272 return Priority == UINT16_MAX ?
2274 getContext().getWasmSection(".init_array." + utostr(Priority),
2276}
2277
2279 unsigned Priority, const MCSymbol *KeySym) const {
2280 report_fatal_error("@llvm.global_dtors should have been lowered already");
2281}
2282
2283//===----------------------------------------------------------------------===//
2284// XCOFF
2285//===----------------------------------------------------------------------===//
2287 const MachineFunction *MF) {
2288 if (!MF->getLandingPads().empty())
2289 return true;
2290
2291 const Function &F = MF->getFunction();
2292 if (!F.hasPersonalityFn() || !F.needsUnwindTableEntry())
2293 return false;
2294
2295 const GlobalValue *Per =
2296 dyn_cast<GlobalValue>(F.getPersonalityFn()->stripPointerCasts());
2297 assert(Per && "Personality routine is not a GlobalValue type.");
2299 return false;
2300
2301 return true;
2302}
2303
2305 const MachineFunction *MF) {
2306 const Function &F = MF->getFunction();
2307 if (!F.hasStackProtectorFnAttr())
2308 return false;
2309 // FIXME: check presence of canary word
2310 // There are cases that the stack protectors are not really inserted even if
2311 // the attributes are on.
2312 return true;
2313}
2314
2315MCSymbol *
2317 return MF->getMMI().getContext().getOrCreateSymbol(
2318 "__ehinfo." + Twine(MF->getFunctionNumber()));
2319}
2320
2321MCSymbol *
2323 const TargetMachine &TM) const {
2324 // We always use a qualname symbol for a GV that represents
2325 // a declaration, a function descriptor, or a common symbol.
2326 // If a GV represents a GlobalVariable and -fdata-sections is enabled, we
2327 // also return a qualname so that a label symbol could be avoided.
2328 // It is inherently ambiguous when the GO represents the address of a
2329 // function, as the GO could either represent a function descriptor or a
2330 // function entry point. We choose to always return a function descriptor
2331 // here.
2332 if (const GlobalObject *GO = dyn_cast<GlobalObject>(GV)) {
2333 if (GO->isDeclarationForLinker())
2334 return cast<MCSectionXCOFF>(getSectionForExternalReference(GO, TM))
2335 ->getQualNameSymbol();
2336
2337 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV))
2338 if (GVar->hasAttribute("toc-data"))
2339 return cast<MCSectionXCOFF>(
2341 ->getQualNameSymbol();
2342
2343 SectionKind GOKind = getKindForGlobal(GO, TM);
2344 if (GOKind.isText())
2345 return cast<MCSectionXCOFF>(
2346 getSectionForFunctionDescriptor(cast<Function>(GO), TM))
2347 ->getQualNameSymbol();
2348 if ((TM.getDataSections() && !GO->hasSection()) || GO->hasCommonLinkage() ||
2349 GOKind.isBSSLocal() || GOKind.isThreadBSSLocal())
2350 return cast<MCSectionXCOFF>(SectionForGlobal(GO, GOKind, TM))
2351 ->getQualNameSymbol();
2352 }
2353
2354 // For all other cases, fall back to getSymbol to return the unqualified name.
2355 return nullptr;
2356}
2357
2359 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2360 if (!GO->hasSection())
2361 report_fatal_error("#pragma clang section is not yet supported");
2362
2364
2365 // Handle the XCOFF::TD case first, then deal with the rest.
2366 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GO))
2367 if (GVar->hasAttribute("toc-data"))
2368 return getContext().getXCOFFSection(
2369 SectionName, Kind,
2371 /* MultiSymbolsAllowed*/ true);
2372
2373 XCOFF::StorageMappingClass MappingClass;
2374 if (Kind.isText())
2375 MappingClass = XCOFF::XMC_PR;
2376 else if (Kind.isData() || Kind.isBSS())
2377 MappingClass = XCOFF::XMC_RW;
2378 else if (Kind.isReadOnlyWithRel())
2379 MappingClass =
2381 else if (Kind.isReadOnly())
2382 MappingClass = XCOFF::XMC_RO;
2383 else
2384 report_fatal_error("XCOFF other section types not yet implemented.");
2385
2386 return getContext().getXCOFFSection(
2387 SectionName, Kind, XCOFF::CsectProperties(MappingClass, XCOFF::XTY_SD),
2388 /* MultiSymbolsAllowed*/ true);
2389}
2390
2392 const GlobalObject *GO, const TargetMachine &TM) const {
2394 "Tried to get ER section for a defined global.");
2395
2398
2400 isa<Function>(GO) ? XCOFF::XMC_DS : XCOFF::XMC_UA;
2401 if (GO->isThreadLocal())
2402 SMC = XCOFF::XMC_UL;
2403
2404 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GO))
2405 if (GVar->hasAttribute("toc-data"))
2406 SMC = XCOFF::XMC_TD;
2407
2408 // Externals go into a csect of type ER.
2409 return getContext().getXCOFFSection(
2412}
2413
2415 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2416 // Handle the XCOFF::TD case first, then deal with the rest.
2417 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GO))
2418 if (GVar->hasAttribute("toc-data")) {
2421 return getContext().getXCOFFSection(
2423 /* MultiSymbolsAllowed*/ true);
2424 }
2425
2426 // Common symbols go into a csect with matching name which will get mapped
2427 // into the .bss section.
2428 // Zero-initialized local TLS symbols go into a csect with matching name which
2429 // will get mapped into the .tbss section.
2430 if (Kind.isBSSLocal() || GO->hasCommonLinkage() || Kind.isThreadBSSLocal()) {
2433 XCOFF::StorageMappingClass SMC = Kind.isBSSLocal() ? XCOFF::XMC_BS
2434 : Kind.isCommon() ? XCOFF::XMC_RW
2435 : XCOFF::XMC_UL;
2436 return getContext().getXCOFFSection(
2438 }
2439
2440 if (Kind.isText()) {
2441 if (TM.getFunctionSections()) {
2442 return cast<MCSymbolXCOFF>(getFunctionEntryPointSymbol(GO, TM))
2443 ->getRepresentedCsect();
2444 }
2445 return TextSection;
2446 }
2447
2448 if (TM.Options.XCOFFReadOnlyPointers && Kind.isReadOnlyWithRel()) {
2449 if (!TM.getDataSections())
2451 "ReadOnlyPointers is supported only if data sections is turned on");
2452
2455 return getContext().getXCOFFSection(
2458 }
2459
2460 // For BSS kind, zero initialized data must be emitted to the .data section
2461 // because external linkage control sections that get mapped to the .bss
2462 // section will be linked as tentative defintions, which is only appropriate
2463 // for SectionKind::Common.
2464 if (Kind.isData() || Kind.isReadOnlyWithRel() || Kind.isBSS()) {
2465 if (TM.getDataSections()) {
2468 return getContext().getXCOFFSection(
2471 }
2472 return DataSection;
2473 }
2474
2475 if (Kind.isReadOnly()) {
2476 if (TM.getDataSections()) {
2479 return getContext().getXCOFFSection(
2482 }
2483 return ReadOnlySection;
2484 }
2485
2486 // External/weak TLS data and initialized local TLS data are not eligible
2487 // to be put into common csect. If data sections are enabled, thread
2488 // data are emitted into separate sections. Otherwise, thread data
2489 // are emitted into the .tdata section.
2490 if (Kind.isThreadLocal()) {
2491 if (TM.getDataSections()) {
2494 return getContext().getXCOFFSection(
2496 }
2497 return TLSDataSection;
2498 }
2499
2500 report_fatal_error("XCOFF other section types not yet implemented.");
2501}
2502
2504 const Function &F, const TargetMachine &TM) const {
2505 assert (!F.getComdat() && "Comdat not supported on XCOFF.");
2506
2507 if (!TM.getFunctionSections())
2508 return ReadOnlySection;
2509
2510 // If the function can be removed, produce a unique section so that
2511 // the table doesn't prevent the removal.
2512 SmallString<128> NameStr(".rodata.jmp..");
2513 getNameWithPrefix(NameStr, &F, TM);
2514 return getContext().getXCOFFSection(
2515 NameStr, SectionKind::getReadOnly(),
2517}
2518
2520 bool UsesLabelDifference, const Function &F) const {
2521 return false;
2522}
2523
2524/// Given a mergeable constant with the specified size and relocation
2525/// information, return a section that it should be placed in.
2527 const DataLayout &DL, SectionKind Kind, const Constant *C,
2528 Align &Alignment) const {
2529 // TODO: Enable emiting constant pool to unique sections when we support it.
2530 if (Alignment > Align(16))
2531 report_fatal_error("Alignments greater than 16 not yet supported.");
2532
2533 if (Alignment == Align(8)) {
2534 assert(ReadOnly8Section && "Section should always be initialized.");
2535 return ReadOnly8Section;
2536 }
2537
2538 if (Alignment == Align(16)) {
2539 assert(ReadOnly16Section && "Section should always be initialized.");
2540 return ReadOnly16Section;
2541 }
2542
2543 return ReadOnlySection;
2544}
2545
2547 const TargetMachine &TgtM) {
2554 LSDAEncoding = 0;
2556
2557 // AIX debug for thread local location is not ready. And for integrated as
2558 // mode, the relocatable address for the thread local variable will cause
2559 // linker error. So disable the location attribute generation for thread local
2560 // variables for now.
2561 // FIXME: when TLS debug on AIX is ready, remove this setting.
2563}
2564
2566 unsigned Priority, const MCSymbol *KeySym) const {
2567 report_fatal_error("no static constructor section on AIX");
2568}
2569
2571 unsigned Priority, const MCSymbol *KeySym) const {
2572 report_fatal_error("no static destructor section on AIX");
2573}
2574
2576 const GlobalValue *LHS, const GlobalValue *RHS,
2577 const TargetMachine &TM) const {
2578 /* Not implemented yet, but don't crash, return nullptr. */
2579 return nullptr;
2580}
2581
2584 assert(!isa<GlobalIFunc>(GV) && "GlobalIFunc is not supported on AIX.");
2585
2586 switch (GV->getLinkage()) {
2589 return XCOFF::C_HIDEXT;
2593 return XCOFF::C_EXT;
2599 return XCOFF::C_WEAKEXT;
2602 "There is no mapping that implements AppendingLinkage for XCOFF.");
2603 }
2604 llvm_unreachable("Unknown linkage type!");
2605}
2606
2608 const GlobalValue *Func, const TargetMachine &TM) const {
2609 assert((isa<Function>(Func) ||
2610 (isa<GlobalAlias>(Func) &&
2611 isa_and_nonnull<Function>(
2612 cast<GlobalAlias>(Func)->getAliaseeObject()))) &&
2613 "Func must be a function or an alias which has a function as base "
2614 "object.");
2615
2616 SmallString<128> NameStr;
2617 NameStr.push_back('.');
2618 getNameWithPrefix(NameStr, Func, TM);
2619
2620 // When -function-sections is enabled and explicit section is not specified,
2621 // it's not necessary to emit function entry point label any more. We will use
2622 // function entry point csect instead. And for function delcarations, the
2623 // undefined symbols gets treated as csect with XTY_ER property.
2624 if (((TM.getFunctionSections() && !Func->hasSection()) ||
2625 Func->isDeclarationForLinker()) &&
2626 isa<Function>(Func)) {
2627 return getContext()
2629 NameStr, SectionKind::getText(),
2630 XCOFF::CsectProperties(XCOFF::XMC_PR, Func->isDeclarationForLinker()
2632 : XCOFF::XTY_SD))
2634 }
2635
2636 return getContext().getOrCreateSymbol(NameStr);
2637}
2638
2640 const Function *F, const TargetMachine &TM) const {
2641 SmallString<128> NameStr;
2642 getNameWithPrefix(NameStr, F, TM);
2643 return getContext().getXCOFFSection(
2644 NameStr, SectionKind::getData(),
2646}
2647
2649 const MCSymbol *Sym, const TargetMachine &TM) const {
2650 // Use TE storage-mapping class when large code model is enabled so that
2651 // the chance of needing -bbigtoc is decreased.
2652 return getContext().getXCOFFSection(
2653 cast<MCSymbolXCOFF>(Sym)->getSymbolTableName(), SectionKind::getData(),
2656 XCOFF::XTY_SD));
2657}
2658
2660 const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const {
2661 auto *LSDA = cast<MCSectionXCOFF>(LSDASection);
2662 if (TM.getFunctionSections()) {
2663 // If option -ffunction-sections is on, append the function name to the
2664 // name of the LSDA csect so that each function has its own LSDA csect.
2665 // This helps the linker to garbage-collect EH info of unused functions.
2666 SmallString<128> NameStr = LSDA->getName();
2667 raw_svector_ostream(NameStr) << '.' << F.getName();
2668 LSDA = getContext().getXCOFFSection(NameStr, LSDA->getKind(),
2669 LSDA->getCsectProp());
2670 }
2671 return LSDA;
2672}
2673//===----------------------------------------------------------------------===//
2674// GOFF
2675//===----------------------------------------------------------------------===//
2677
2679 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2680 return SelectSectionForGlobal(GO, Kind, TM);
2681}
2682
2684 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
2685 auto *Symbol = TM.getSymbol(GO);
2686 if (Kind.isBSS())
2687 return getContext().getGOFFSection(Symbol->getName(), SectionKind::getBSS(),
2688 nullptr, nullptr);
2689
2691}
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:468
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 unsigned getWasmSectionFlags(SectionKind K)
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 MCSectionWasm * selectWasmSectionForGlobal(MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang, const TargetMachine &TM, bool EmitUniqueSection, unsigned *NextUniqueID)
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 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 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 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:920
GlobalValue * getGlobalValue() const
Definition: Constants.h:939
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:117
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
Definition: Metadata.cpp:1354
bool hasComdat() const
Definition: GlobalObject.h:127
bool hasSection() const
Check if this global has a custom object file section.
Definition: GlobalObject.h:109
bool hasExternalLinkage() const
Definition: GlobalValue.h:506
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
Definition: GlobalValue.h:259
LinkageTypes getLinkage() const
Definition: GlobalValue.h:541
bool hasLocalLinkage() const
Definition: GlobalValue.h:523
bool hasPrivateLinkage() const
Definition: GlobalValue.h:522
const Comdat * getComdat() const
Definition: Globals.cpp:183
bool isDeclarationForLinker() const
Definition: GlobalValue.h:614
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:652
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:367
bool hasCommonLinkage() const
Definition: GlobalValue.h:527
static bool isWeakForLinker(LinkageTypes Linkage)
Whether the definition of this global may be replaced at link time.
Definition: GlobalValue.h:453
@ PrivateLinkage
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:56
@ CommonLinkage
Tentative definitions.
Definition: GlobalValue.h:58
@ InternalLinkage
Rename collisions when linking (static functions).
Definition: GlobalValue.h:55
@ LinkOnceAnyLinkage
Keep one copy of function when linking (inline)
Definition: GlobalValue.h:50
@ WeakODRLinkage
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:53
@ ExternalLinkage
Externally visible function.
Definition: GlobalValue.h:48
@ WeakAnyLinkage
Keep one copy of named function when linking (weak)
Definition: GlobalValue.h:52
@ AppendingLinkage
Special purpose, only applies to global arrays.
Definition: GlobalValue.h:54
@ AvailableExternallyLinkage
Available for inspection, not emission.
Definition: GlobalValue.h:49
@ ExternalWeakLinkage
ExternalWeak linkage description.
Definition: GlobalValue.h:57
@ LinkOnceODRLinkage
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:51
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:842
virtual bool isSectionAtomizableBySymbols(const MCSection &Section) const
True if the section is atomized using the symbols in it.
Definition: MCAsmInfo.cpp:78
bool binutilsIsAtLeast(int Major, int Minor) const
Definition: MCAsmInfo.h:849
ExceptionHandling getExceptionHandlingType() const
Definition: MCAsmInfo.h:781
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:528
static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:613
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
@ GenericSectionID
Pass this value as the UniqueID during section creation to get the generic section with the given nam...
Definition: MCContext.h:548
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:438
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:517
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:565
bool isELFGenericMergeableSection(StringRef Name)
Definition: MCContext.cpp:636
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:774
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:642
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:662
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:201
bool isELFImplicitMergeableSectionNamePrefix(StringRef Name)
Definition: MCContext.cpp:631
MCSectionGOFF * getGOFFSection(StringRef Section, SectionKind Kind, MCSection *Parent, const MCExpr *SubsectionId)
Definition: MCContext.cpp:650
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:701
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:402
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:389
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:206
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:950
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1303
Metadata * get() const
Definition: Metadata.h:801
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:239
GlobalValue * getNamedValue(StringRef Name) const
Return the global value in the module with the specified name, of arbitrary type.
Definition: Module.cpp:110
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.h:254
A tuple of MDNodes.
Definition: Metadata.h:1604
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:577
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
bool startswith(StringRef Prefix) const
Definition: StringRef.h:261
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 * 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.
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:78
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:355
EnvironmentType getEnvironment() const
Get the parsed environment type of this triple.
Definition: Triple.h:372
bool isOSFreeBSD() const
Definition: Triple.h:544
bool isArch32Bit() const
Test whether the architecture is 32-bit.
Definition: Triple.cpp:1469
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:1069
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:642
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:672
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
@ SHT_LLVM_DEPENDENT_LIBRARIES
Definition: ELF.h:1028
@ SHT_PROGBITS
Definition: ELF.h:1000
@ SHT_LLVM_LINKER_OPTIONS
Definition: ELF.h:1025
@ SHT_NOBITS
Definition: ELF.h:1007
@ SHT_LLVM_OFFLOADING
Definition: ELF.h:1038
@ SHT_PREINIT_ARRAY
Definition: ELF.h:1013
@ SHT_INIT_ARRAY
Definition: ELF.h:1011
@ SHT_NOTE
Definition: ELF.h:1006
@ SHT_FINI_ARRAY
Definition: ELF.h:1012
@ SHF_MERGE
Definition: ELF.h:1095
@ SHF_STRINGS
Definition: ELF.h:1098
@ SHF_EXCLUDE
Definition: ELF.h:1123
@ SHF_ALLOC
Definition: ELF.h:1089
@ SHF_LINK_ORDER
Definition: ELF.h:1104
@ SHF_GROUP
Definition: ELF.h:1111
@ SHF_SUNW_NODISCARD
Definition: ELF.h:1130
@ SHF_X86_64_LARGE
Definition: ELF.h:1152
@ SHF_GNU_RETAIN
Definition: ELF.h:1120
@ SHF_WRITE
Definition: ELF.h:1086
@ SHF_TLS
Definition: ELF.h:1114
@ SHF_ARM_PURECODE
Definition: ELF.h:1184
@ SHF_EXECINSTR
Definition: ELF.h:1092
@ 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:169
@ C_WEAKEXT
Definition: XCOFF.h:198
@ C_HIDEXT
Definition: XCOFF.h:205
StorageMappingClass
Storage Mapping Class definitions.
Definition: XCOFF.h:102
@ XMC_TE
Symbol mapped at the end of TOC.
Definition: XCOFF.h:127
@ XMC_DS
Descriptor csect.
Definition: XCOFF.h:120
@ XMC_RW
Read Write Data.
Definition: XCOFF.h:116
@ XMC_TL
Initialized thread-local variable.
Definition: XCOFF.h:125
@ XMC_RO
Read Only Constant.
Definition: XCOFF.h:105
@ XMC_UA
Unclassified - Treated as Read Write.
Definition: XCOFF.h:121
@ XMC_TD
Scalar data item in the TOC.
Definition: XCOFF.h:119
@ XMC_UL
Uninitialized thread-local variable.
Definition: XCOFF.h:126
@ XMC_PR
Program Code.
Definition: XCOFF.h:104
@ XMC_BS
BSS class (uninitialized static internal)
Definition: XCOFF.h:122
@ XMC_TC
General TOC item.
Definition: XCOFF.h:118
@ XTY_CM
Common csect definition. For uninitialized storage.
Definition: XCOFF.h:244
@ XTY_SD
Csect definition for initialized storage.
Definition: XCOFF.h:241
@ XTY_ER
External reference.
Definition: XCOFF.h:240
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:445
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_TLS
Definition: Wasm.h:394
@ WASM_SEG_FLAG_STRINGS
Definition: Wasm.h:393
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:440
std::string getInstrProfSectionName(InstrProfSectKind IPSK, Triple::ObjectFormatType OF, bool AddSegmentInfo=true)
Return the name of the profile section corresponding to IPSK.
Definition: InstrProf.cpp:218
@ 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:1933
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:834
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