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