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