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