LLVM 19.0.0git
MCELFStreamer.cpp
Go to the documentation of this file.
1//===- lib/MC/MCELFStreamer.cpp - ELF Object Output -----------------------===//
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 assembles .s files and emits ELF .o object files.
10//
11//===----------------------------------------------------------------------===//
12
18#include "llvm/MC/MCAsmInfo.h"
19#include "llvm/MC/MCAssembler.h"
21#include "llvm/MC/MCContext.h"
22#include "llvm/MC/MCExpr.h"
23#include "llvm/MC/MCFixup.h"
24#include "llvm/MC/MCFragment.h"
27#include "llvm/MC/MCSection.h"
29#include "llvm/MC/MCStreamer.h"
30#include "llvm/MC/MCSymbol.h"
31#include "llvm/MC/MCSymbolELF.h"
35#include "llvm/Support/LEB128.h"
37#include <cassert>
38#include <cstdint>
39
40using namespace llvm;
41
43 std::unique_ptr<MCAsmBackend> TAB,
44 std::unique_ptr<MCObjectWriter> OW,
45 std::unique_ptr<MCCodeEmitter> Emitter)
46 : MCObjectStreamer(Context, std::move(TAB), std::move(OW),
47 std::move(Emitter)) {}
48
49bool MCELFStreamer::isBundleLocked() const {
51}
52
53void MCELFStreamer::initSections(bool NoExecStack, const MCSubtargetInfo &STI) {
54 MCContext &Ctx = getContext();
57 &STI);
58
59 if (NoExecStack)
61}
62
64 auto *Symbol = cast<MCSymbolELF>(S);
65 MCObjectStreamer::emitLabel(Symbol, Loc);
66
67 const MCSectionELF &Section =
68 static_cast<const MCSectionELF &>(*getCurrentSectionOnly());
69 if (Section.getFlags() & ELF::SHF_TLS)
70 Symbol->setType(ELF::STT_TLS);
71}
72
75 auto *Symbol = cast<MCSymbolELF>(S);
77
78 const MCSectionELF &Section =
79 static_cast<const MCSectionELF &>(*getCurrentSectionOnly());
80 if (Section.getFlags() & ELF::SHF_TLS)
81 Symbol->setType(ELF::STT_TLS);
82}
83
85 // Let the target do whatever target specific stuff it needs to do.
87 // Do any generic stuff we need to do.
88 switch (Flag) {
89 case MCAF_SyntaxUnified: return; // no-op here.
90 case MCAF_Code16: return; // Change parsing mode; no-op here.
91 case MCAF_Code32: return; // Change parsing mode; no-op here.
92 case MCAF_Code64: return; // Change parsing mode; no-op here.
95 return;
96 }
97
98 llvm_unreachable("invalid assembler flag!");
99}
100
101// If bundle alignment is used and there are any instructions in the section, it
102// needs to be aligned to at least the bundle size.
103static void setSectionAlignmentForBundling(const MCAssembler &Assembler,
104 MCSection *Section) {
105 if (Assembler.isBundlingEnabled() && Section->hasInstructions())
106 Section->ensureMinAlignment(Align(Assembler.getBundleAlignSize()));
107}
108
110 MCAssembler &Asm = getAssembler();
111 if (auto *F = getCurrentFragment()) {
112 if (isBundleLocked())
113 report_fatal_error("Unterminated .bundle_lock when changing a section");
114
115 // Ensure the previous section gets aligned if necessary.
116 setSectionAlignmentForBundling(Asm, F->getParent());
117 }
118 auto *SectionELF = static_cast<const MCSectionELF *>(Section);
119 const MCSymbol *Grp = SectionELF->getGroup();
120 if (Grp)
121 Asm.registerSymbol(*Grp);
122 if (SectionELF->getFlags() & ELF::SHF_GNU_RETAIN)
123 Asm.getWriter().markGnuAbi();
124
125 changeSectionImpl(Section, Subsection);
126 Asm.registerSymbol(*Section->getBeginSymbol());
127}
128
130 getAssembler().registerSymbol(*Symbol);
133 Alias->setVariableValue(Value);
134}
135
136// When GNU as encounters more than one .type declaration for an object it seems
137// to use a mechanism similar to the one below to decide which type is actually
138// used in the object file. The greater of T1 and T2 is selected based on the
139// following ordering:
140// STT_NOTYPE < STT_OBJECT < STT_FUNC < STT_GNU_IFUNC < STT_TLS < anything else
141// If neither T1 < T2 nor T2 < T1 according to this ordering, use T2 (the user
142// provided type).
143static unsigned CombineSymbolTypes(unsigned T1, unsigned T2) {
146 if (T1 == Type)
147 return T2;
148 if (T2 == Type)
149 return T1;
150 }
151
152 return T2;
153}
154
156 auto *Symbol = cast<MCSymbolELF>(S);
157
158 // Adding a symbol attribute always introduces the symbol, note that an
159 // important side effect of calling registerSymbol here is to register
160 // the symbol with the assembler.
161 getAssembler().registerSymbol(*Symbol);
162
163 // The implementation of symbol attributes is designed to match 'as', but it
164 // leaves much to desired. It doesn't really make sense to arbitrarily add and
165 // remove flags, but 'as' allows this (in particular, see .desc).
166 //
167 // In the future it might be worth trying to make these operations more well
168 // defined.
169 switch (Attribute) {
170 case MCSA_Cold:
171 case MCSA_Extern:
173 case MCSA_Reference:
178 case MCSA_Invalid:
180 case MCSA_Exported:
181 case MCSA_WeakAntiDep:
182 return false;
183
184 case MCSA_NoDeadStrip:
185 // Ignore for now.
186 break;
187
189 Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));
190 Symbol->setBinding(ELF::STB_GNU_UNIQUE);
192 break;
193
194 case MCSA_Global:
195 // For `.weak x; .global x`, GNU as sets the binding to STB_WEAK while we
196 // traditionally set the binding to STB_GLOBAL. This is error-prone, so we
197 // error on such cases. Note, we also disallow changed binding from .local.
198 if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_GLOBAL)
200 Symbol->getName() +
201 " changed binding to STB_GLOBAL");
202 Symbol->setBinding(ELF::STB_GLOBAL);
203 break;
204
206 case MCSA_Weak:
207 // For `.global x; .weak x`, both MC and GNU as set the binding to STB_WEAK.
208 // We emit a warning for now but may switch to an error in the future.
209 if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_WEAK)
211 getStartTokLoc(), Symbol->getName() + " changed binding to STB_WEAK");
212 Symbol->setBinding(ELF::STB_WEAK);
213 break;
214
215 case MCSA_Local:
216 if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_LOCAL)
218 Symbol->getName() +
219 " changed binding to STB_LOCAL");
220 Symbol->setBinding(ELF::STB_LOCAL);
221 break;
222
224 Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_FUNC));
225 break;
226
228 Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_GNU_IFUNC));
230 break;
231
233 Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));
234 break;
235
236 case MCSA_ELF_TypeTLS:
237 Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_TLS));
238 break;
239
241 // TODO: Emit these as a common symbol.
242 Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));
243 break;
244
246 Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_NOTYPE));
247 break;
248
249 case MCSA_Protected:
250 Symbol->setVisibility(ELF::STV_PROTECTED);
251 break;
252
253 case MCSA_Memtag:
254 Symbol->setMemtag(true);
255 break;
256
257 case MCSA_Hidden:
258 Symbol->setVisibility(ELF::STV_HIDDEN);
259 break;
260
261 case MCSA_Internal:
262 Symbol->setVisibility(ELF::STV_INTERNAL);
263 break;
264
265 case MCSA_AltEntry:
266 llvm_unreachable("ELF doesn't support the .alt_entry attribute");
267
268 case MCSA_LGlobal:
269 llvm_unreachable("ELF doesn't support the .lglobl attribute");
270 }
271
272 return true;
273}
274
276 Align ByteAlignment) {
277 auto *Symbol = cast<MCSymbolELF>(S);
278 getAssembler().registerSymbol(*Symbol);
279
280 if (!Symbol->isBindingSet())
281 Symbol->setBinding(ELF::STB_GLOBAL);
282
283 Symbol->setType(ELF::STT_OBJECT);
284
285 if (Symbol->getBinding() == ELF::STB_LOCAL) {
289 switchSection(&Section);
290
291 emitValueToAlignment(ByteAlignment, 0, 1, 0);
292 emitLabel(Symbol);
294
295 switchSection(P.first, P.second);
296 } else {
297 if (Symbol->declareCommon(Size, ByteAlignment))
298 report_fatal_error(Twine("Symbol: ") + Symbol->getName() +
299 " redeclared as different type");
300 }
301
302 cast<MCSymbolELF>(Symbol)
304}
305
307 cast<MCSymbolELF>(Symbol)->setSize(Value);
308}
309
312 bool KeepOriginalSym) {
314 getStartTokLoc(), OriginalSym, Name, KeepOriginalSym});
315}
316
318 Align ByteAlignment) {
319 auto *Symbol = cast<MCSymbolELF>(S);
320 // FIXME: Should this be caught and done earlier?
321 getAssembler().registerSymbol(*Symbol);
322 Symbol->setBinding(ELF::STB_LOCAL);
323 emitCommonSymbol(Symbol, Size, ByteAlignment);
324}
325
327 SMLoc Loc) {
328 if (isBundleLocked())
329 report_fatal_error("Emitting values inside a locked bundle is forbidden");
330 fixSymbolsInTLSFixups(Value);
332}
333
335 unsigned ValueSize,
336 unsigned MaxBytesToEmit) {
337 if (isBundleLocked())
338 report_fatal_error("Emitting values inside a locked bundle is forbidden");
339 MCObjectStreamer::emitValueToAlignment(Alignment, Value, ValueSize,
340 MaxBytesToEmit);
341}
342
344 const MCSymbolRefExpr *To,
345 uint64_t Count) {
346 getAssembler().CGProfile.push_back({From, To, Count});
347}
348
352 pushSection();
353 switchSection(Comment);
354 if (!SeenIdent) {
355 emitInt8(0);
356 SeenIdent = true;
357 }
358 emitBytes(IdentString);
359 emitInt8(0);
360 popSection();
361}
362
363void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
364 switch (expr->getKind()) {
365 case MCExpr::Target:
366 cast<MCTargetExpr>(expr)->fixELFSymbolsInTLSFixups(getAssembler());
367 break;
368 case MCExpr::Constant:
369 break;
370
371 case MCExpr::Binary: {
372 const MCBinaryExpr *be = cast<MCBinaryExpr>(expr);
373 fixSymbolsInTLSFixups(be->getLHS());
374 fixSymbolsInTLSFixups(be->getRHS());
375 break;
376 }
377
378 case MCExpr::SymbolRef: {
379 const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr);
380 switch (symRef.getKind()) {
381 default:
382 return;
437 break;
438 }
440 cast<MCSymbolELF>(symRef.getSymbol()).setType(ELF::STT_TLS);
441 break;
442 }
443
444 case MCExpr::Unary:
445 fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr());
446 break;
447 }
448}
449
450void MCELFStreamer::finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE,
452 const MCSymbol *S = &SRE->getSymbol();
453 if (S->isTemporary()) {
454 if (!S->isInSection()) {
456 SRE->getLoc(), Twine("Reference to undefined temporary symbol ") +
457 "`" + S->getName() + "`");
458 return;
459 }
460 S = S->getSection().getBeginSymbol();
461 S->setUsedInReloc();
463 SRE->getLoc());
464 }
466 if (std::optional<std::pair<bool, std::string>> Err =
468 *MCOffset, "BFD_RELOC_NONE", SRE, SRE->getLoc(),
469 *getContext().getSubtargetInfo()))
470 report_fatal_error("Relocation for CG Profile could not be created: " +
471 Twine(Err->second));
472}
473
474void MCELFStreamer::finalizeCGProfile() {
476 if (Asm.CGProfile.empty())
477 return;
479 ".llvm.call-graph-profile", ELF::SHT_LLVM_CALL_GRAPH_PROFILE,
480 ELF::SHF_EXCLUDE, /*sizeof(Elf_CGProfile_Impl<>)=*/8);
481 pushSection();
482 switchSection(CGProfile);
483 uint64_t Offset = 0;
484 for (MCAssembler::CGProfileEntry &E : Asm.CGProfile) {
485 finalizeCGProfileEntry(E.From, Offset);
486 finalizeCGProfileEntry(E.To, Offset);
487 emitIntValue(E.Count, sizeof(uint64_t));
488 Offset += sizeof(uint64_t);
489 }
490 popSection();
491}
492
493void MCELFStreamer::emitInstToFragment(const MCInst &Inst,
494 const MCSubtargetInfo &STI) {
496 MCRelaxableFragment &F = *cast<MCRelaxableFragment>(getCurrentFragment());
497
498 for (auto &Fixup : F.getFixups())
499 fixSymbolsInTLSFixups(Fixup.getValue());
500}
501
502// A fragment can only have one Subtarget, and when bundling is enabled we
503// sometimes need to use the same fragment. We give an error if there
504// are conflicting Subtargets.
505static void CheckBundleSubtargets(const MCSubtargetInfo *OldSTI,
506 const MCSubtargetInfo *NewSTI) {
507 if (OldSTI && NewSTI && OldSTI != NewSTI)
508 report_fatal_error("A Bundle can only have one Subtarget.");
509}
510
511void MCELFStreamer::emitInstToData(const MCInst &Inst,
512 const MCSubtargetInfo &STI) {
513 MCAssembler &Assembler = getAssembler();
514
515 // There are several possibilities here:
516 //
517 // If bundling is disabled, append the encoded instruction to the current data
518 // fragment (or create a new such fragment if the current fragment is not a
519 // data fragment, or the Subtarget has changed).
520 //
521 // If bundling is enabled:
522 // - If we're not in a bundle-locked group, emit the instruction into a
523 // fragment of its own.
524 // - If we're in a bundle-locked group, append the instruction to the current
525 // data fragment because we want all the instructions in a group to get into
526 // the same fragment. Be careful not to do that for the first instruction in
527 // the group, though.
529
530 if (Assembler.isBundlingEnabled()) {
532 if (isBundleLocked() && !Sec.isBundleGroupBeforeFirstInst()) {
533 // If we are bundle-locked, we re-use the current fragment.
534 // The bundle-locking directive ensures this is a new data fragment.
535 DF = cast<MCDataFragment>(getCurrentFragment());
536 CheckBundleSubtargets(DF->getSubtargetInfo(), &STI);
537 } else {
539 insert(DF);
540 }
542 // If this fragment is for a group marked "align_to_end", set a flag
543 // in the fragment. This can happen after the fragment has already been
544 // created if there are nested bundle_align groups and an inner one
545 // is the one marked align_to_end.
546 DF->setAlignToBundleEnd(true);
547 }
548
549 // We're now emitting an instruction in a bundle group, so this flag has
550 // to be turned off.
552 } else {
554 }
555
556 // Emit instruction directly into data fragment.
557 size_t FixupStartIndex = DF->getFixups().size();
558 size_t CodeOffset = DF->getContents().size();
559 Assembler.getEmitter().encodeInstruction(Inst, DF->getContents(),
560 DF->getFixups(), STI);
561
562 auto Fixups = MutableArrayRef(DF->getFixups()).slice(FixupStartIndex);
563 for (auto &Fixup : Fixups) {
564 Fixup.setOffset(Fixup.getOffset() + CodeOffset);
565 fixSymbolsInTLSFixups(Fixup.getValue());
566 }
567
568 DF->setHasInstructions(STI);
569 if (!Fixups.empty() && Fixups.back().getTargetKind() ==
570 getAssembler().getBackend().RelaxFixupKind)
571 DF->setLinkerRelaxable();
572}
573
575 assert(Log2(Alignment) <= 30 && "Invalid bundle alignment");
576 MCAssembler &Assembler = getAssembler();
577 if (Alignment > 1 && (Assembler.getBundleAlignSize() == 0 ||
578 Assembler.getBundleAlignSize() == Alignment.value()))
579 Assembler.setBundleAlignSize(Alignment.value());
580 else
581 report_fatal_error(".bundle_align_mode cannot be changed once set");
582}
583
584void MCELFStreamer::emitBundleLock(bool AlignToEnd) {
586
587 if (!getAssembler().isBundlingEnabled())
588 report_fatal_error(".bundle_lock forbidden when bundling is disabled");
589
590 if (!isBundleLocked())
592
595}
596
599
600 if (!getAssembler().isBundlingEnabled())
601 report_fatal_error(".bundle_unlock forbidden when bundling is disabled");
602 else if (!isBundleLocked())
603 report_fatal_error(".bundle_unlock without matching lock");
604 else if (Sec.isBundleGroupBeforeFirstInst())
605 report_fatal_error("Empty bundle-locked group is forbidden");
606
608}
609
611 // Emit the .gnu attributes section if any attributes have been added.
612 if (!GNUAttributes.empty()) {
613 MCSection *DummyAttributeSection = nullptr;
614 createAttributesSection("gnu", ".gnu.attributes", ELF::SHT_GNU_ATTRIBUTES,
615 DummyAttributeSection, GNUAttributes);
616 }
617
618 // Ensure the last section gets aligned if necessary.
621
622 finalizeCGProfile();
623 emitFrames(nullptr);
624
626}
627
629 llvm_unreachable("Generic ELF doesn't support this directive");
630}
631
632void MCELFStreamer::emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
633 llvm_unreachable("ELF doesn't support this directive");
634}
635
637 uint64_t Size, Align ByteAlignment,
638 SMLoc Loc) {
639 llvm_unreachable("ELF doesn't support this directive");
640}
641
643 uint64_t Size, Align ByteAlignment) {
644 llvm_unreachable("ELF doesn't support this directive");
645}
646
648 bool OverwriteExisting) {
649 // Look for existing attribute item
650 if (AttributeItem *Item = getAttributeItem(Attribute)) {
651 if (!OverwriteExisting)
652 return;
654 Item->IntValue = Value;
655 return;
656 }
657
658 // Create new attribute item
660 std::string(StringRef(""))};
661 Contents.push_back(Item);
662}
663
665 bool OverwriteExisting) {
666 // Look for existing attribute item
667 if (AttributeItem *Item = getAttributeItem(Attribute)) {
668 if (!OverwriteExisting)
669 return;
670 Item->Type = AttributeItem::TextAttribute;
671 Item->StringValue = std::string(Value);
672 return;
673 }
674
675 // Create new attribute item
677 std::string(Value)};
678 Contents.push_back(Item);
679}
680
681void MCELFStreamer::setAttributeItems(unsigned Attribute, unsigned IntValue,
682 StringRef StringValue,
683 bool OverwriteExisting) {
684 // Look for existing attribute item
685 if (AttributeItem *Item = getAttributeItem(Attribute)) {
686 if (!OverwriteExisting)
687 return;
689 Item->IntValue = IntValue;
690 Item->StringValue = std::string(StringValue);
691 return;
692 }
693
694 // Create new attribute item
696 IntValue, std::string(StringValue)};
697 Contents.push_back(Item);
698}
699
701MCELFStreamer::getAttributeItem(unsigned Attribute) {
702 for (AttributeItem &Item : Contents)
703 if (Item.Tag == Attribute)
704 return &Item;
705 return nullptr;
706}
707
708size_t
709MCELFStreamer::calculateContentSize(SmallVector<AttributeItem, 64> &AttrsVec) {
710 size_t Result = 0;
711 for (const AttributeItem &Item : AttrsVec) {
712 switch (Item.Type) {
714 break;
716 Result += getULEB128Size(Item.Tag);
717 Result += getULEB128Size(Item.IntValue);
718 break;
720 Result += getULEB128Size(Item.Tag);
721 Result += Item.StringValue.size() + 1; // string + '\0'
722 break;
724 Result += getULEB128Size(Item.Tag);
725 Result += getULEB128Size(Item.IntValue);
726 Result += Item.StringValue.size() + 1; // string + '\0';
727 break;
728 }
729 }
730 return Result;
731}
732
733void MCELFStreamer::createAttributesSection(
734 StringRef Vendor, const Twine &Section, unsigned Type,
735 MCSection *&AttributeSection, SmallVector<AttributeItem, 64> &AttrsVec) {
736 // <format-version>
737 // [ <section-length> "vendor-name"
738 // [ <file-tag> <size> <attribute>*
739 // | <section-tag> <size> <section-number>* 0 <attribute>*
740 // | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
741 // ]+
742 // ]*
743
744 // Switch section to AttributeSection or get/create the section.
745 if (AttributeSection) {
746 switchSection(AttributeSection);
747 } else {
748 AttributeSection = getContext().getELFSection(Section, Type, 0);
749 switchSection(AttributeSection);
750
751 // Format version
752 emitInt8(0x41);
753 }
754
755 // Vendor size + Vendor name + '\0'
756 const size_t VendorHeaderSize = 4 + Vendor.size() + 1;
757
758 // Tag + Tag Size
759 const size_t TagHeaderSize = 1 + 4;
760
761 const size_t ContentsSize = calculateContentSize(AttrsVec);
762
763 emitInt32(VendorHeaderSize + TagHeaderSize + ContentsSize);
764 emitBytes(Vendor);
765 emitInt8(0); // '\0'
766
768 emitInt32(TagHeaderSize + ContentsSize);
769
770 // Size should have been accounted for already, now
771 // emit each field as its type (ULEB or String)
772 for (const AttributeItem &Item : AttrsVec) {
773 emitULEB128IntValue(Item.Tag);
774 switch (Item.Type) {
775 default:
776 llvm_unreachable("Invalid attribute type");
778 emitULEB128IntValue(Item.IntValue);
779 break;
781 emitBytes(Item.StringValue);
782 emitInt8(0); // '\0'
783 break;
785 emitULEB128IntValue(Item.IntValue);
786 emitBytes(Item.StringValue);
787 emitInt8(0); // '\0'
788 break;
789 }
790 }
791
792 AttrsVec.clear();
793}
794
796 std::unique_ptr<MCAsmBackend> &&MAB,
797 std::unique_ptr<MCObjectWriter> &&OW,
798 std::unique_ptr<MCCodeEmitter> &&CE) {
799 MCELFStreamer *S =
800 new MCELFStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
801 return S;
802}
BlockVerifier::State From
dxil DXContainer Global Emitter
static RegisterPass< DebugifyFunctionPass > DF("debugify-function", "Attach debug info to a function")
std::string Name
uint64_t Size
static unsigned CombineSymbolTypes(unsigned T1, unsigned T2)
static void CheckBundleSubtargets(const MCSubtargetInfo *OldSTI, const MCSubtargetInfo *NewSTI)
static void setSectionAlignmentForBundling(const MCAssembler &Assembler, MCSection *Section)
#define F(x, y, z)
Definition: MD5.cpp:55
#define T1
#define P(N)
PowerPC TLS Dynamic Call Fixup
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallString class.
This file defines the SmallVector class.
virtual void handleAssemblerFlag(MCAssemblerFlag Flag)
Handle any target-specific assembler flags. By default, do nothing.
Definition: MCAsmBackend.h:224
virtual MCSection * getNonexecutableStackSection(MCContext &Ctx) const
Targets can implement this method to specify a section to switch to if the translation unit doesn't h...
Definition: MCAsmInfo.h:579
MCContext & getContext() const
Definition: MCAssembler.h:277
unsigned getBundleAlignSize() const
Definition: MCAssembler.h:319
bool isBundlingEnabled() const
Definition: MCAssembler.h:317
void setBundleAlignSize(unsigned Size)
Definition: MCAssembler.h:321
void setSubsectionsViaSymbols(bool Value)
Definition: MCAssembler.h:304
MCObjectWriter & getWriter() const
Definition: MCAssembler.h:289
MCCodeEmitter & getEmitter() const
Definition: MCAssembler.h:287
MCAsmBackend & getBackend() const
Definition: MCAssembler.h:285
std::vector< Symver > Symvers
Definition: MCAssembler.h:184
std::vector< CGProfileEntry > CGProfile
Definition: MCAssembler.h:357
bool registerSymbol(const MCSymbol &Symbol)
Binary assembler expressions.
Definition: MCExpr.h:488
const MCExpr * getLHS() const
Get the left-hand side expression of the binary operator.
Definition: MCExpr.h:635
const MCExpr * getRHS() const
Get the right-hand side expression of the binary operator.
Definition: MCExpr.h:638
virtual void encodeInstruction(const MCInst &Inst, SmallVectorImpl< char > &CB, SmallVectorImpl< MCFixup > &Fixups, const MCSubtargetInfo &STI) const =0
Encode the given Inst to bytes and append to CB.
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition: MCExpr.cpp:193
Context object for machine code objects.
Definition: MCContext.h:83
const MCObjectFileInfo * getObjectFileInfo() const
Definition: MCContext.h:416
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:547
void reportWarning(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:1076
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:412
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:1069
F * allocFragment(Args &&...args)
Definition: MCContext.h:440
Fragment for data and encoded instructions.
Definition: MCFragment.h:231
void emitBundleLock(bool AlignToEnd) override
The following instructions are a bundle-locked group.
SmallVector< AttributeItem, 64 > Contents
void emitValueToAlignment(Align, int64_t, unsigned, unsigned) override
Emit some number of copies of Value until the byte alignment ByteAlignment is reached.
void changeSection(MCSection *Section, uint32_t Subsection=0) override
This is called by popSection and switchSection, if the current section changes.
void emitIdent(StringRef IdentString) override
Emit the "identifiers" directive.
void setAttributeItems(unsigned Attribute, unsigned IntValue, StringRef StringValue, bool OverwriteExisting)
void emitBundleUnlock() override
Ends a bundle-locked group.
void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size, Align ByteAlignment) override
Emit a common symbol.
void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc()) override
Emit the expression Value into the output as a native integer of the given Size bytes.
void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, Align ByteAlignment) override
Emit a local common (.lcomm) symbol.
void emitAssemblerFlag(MCAssemblerFlag Flag) override
Note in the output the specified Flag.
void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override
Set the DescValue for the Symbol.
void emitELFSize(MCSymbol *Symbol, const MCExpr *Value) override
Emit an ELF .size directive.
void emitThumbFunc(MCSymbol *Func) override
Note in the output that the specified Func is a Thumb mode function (ARM target only).
void emitELFSymverDirective(const MCSymbol *OriginalSym, StringRef Name, bool KeepOriginalSym) override
Emit an ELF .symver directive.
void emitCGProfileEntry(const MCSymbolRefExpr *From, const MCSymbolRefExpr *To, uint64_t Count) override
void emitZerofill(MCSection *Section, MCSymbol *Symbol=nullptr, uint64_t Size=0, Align ByteAlignment=Align(1), SMLoc L=SMLoc()) override
Emit the zerofill section and an optional symbol.
void setAttributeItem(unsigned Attribute, unsigned Value, bool OverwriteExisting)
void finishImpl() final
Streamer specific finalization.
void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override
Emit an weak reference from Alias to Symbol.
void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
void emitBundleAlignMode(Align Alignment) override
Set the bundle alignment mode from now on in the section.
bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override
Add the given Attribute to Symbol.
void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size, Align ByteAlignment=Align(1)) override
Emit a thread local bss (.tbss) symbol.
void initSections(bool NoExecStack, const MCSubtargetInfo &STI) override
Create the default sections and set the initial one.
void emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCDataFragment &F, uint64_t Offset) override
MCELFStreamer(MCContext &Context, std::unique_ptr< MCAsmBackend > TAB, std::unique_ptr< MCObjectWriter > OW, std::unique_ptr< MCCodeEmitter > Emitter)
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:34
@ Unary
Unary expressions.
Definition: MCExpr.h:40
@ Constant
Constant expressions.
Definition: MCExpr.h:38
@ SymbolRef
References to labels and assigned expressions.
Definition: MCExpr.h:39
@ Target
Target specific expression.
Definition: MCExpr.h:41
@ Binary
Binary expressions.
Definition: MCExpr.h:37
ExprKind getKind() const
Definition: MCExpr.h:78
SMLoc getLoc() const
Definition: MCExpr.h:79
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
virtual unsigned getTextSectionAlignment() const
MCSection * getTextSection() const
Streaming object file generation interface.
void emitValueToAlignment(Align Alignment, int64_t Value=0, unsigned ValueSize=1, unsigned MaxBytesToEmit=0) override
Emit some number of copies of Value until the byte alignment ByteAlignment is reached.
MCDataFragment * getOrCreateDataFragment(const MCSubtargetInfo *STI=nullptr)
Get a data fragment to write into, creating a new one if the current fragment is not a data fragment.
MCAssembler & getAssembler()
void emitBytes(StringRef Data) override
Emit the bytes in Data into the output.
bool changeSectionImpl(MCSection *Section, uint32_t Subsection)
std::optional< std::pair< bool, std::string > > emitRelocDirective(const MCExpr &Offset, StringRef Name, const MCExpr *Expr, SMLoc Loc, const MCSubtargetInfo &STI) override
Record a relocation described by the .reloc directive.
void insert(MCFragment *F)
virtual void emitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &)
Emit an instruction to a special fragment, because this instruction can change its size during relaxa...
void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc()) override
Emit the expression Value into the output as a native integer of the given Size bytes.
void finishImpl() override
Streamer specific finalization.
void emitCodeAlignment(Align ByteAlignment, const MCSubtargetInfo *STI, unsigned MaxBytesToEmit=0) override
Emit nops until the byte alignment ByteAlignment is reached.
void emitFrames(MCAsmBackend *MAB)
virtual void emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCDataFragment &F, uint64_t Offset)
virtual void markGnuAbi()
ELF only. Mark that we have seen GNU ABI usage (e.g. SHF_GNU_RETAIN).
A relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler lay...
Definition: MCFragment.h:261
This represents a section on linux, lots of unix variants and some bare metal systems.
Definition: MCSectionELF.h:27
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:36
void setBundleLockState(BundleLockStateType NewState)
Definition: MCSection.cpp:50
bool isBundleGroupBeforeFirstInst() const
Definition: MCSection.h:162
bool isBundleLocked() const
Definition: MCSection.h:160
@ BundleLockedAlignToEnd
Definition: MCSection.h:57
MCSymbol * getBeginSymbol()
Definition: MCSection.h:135
BundleLockStateType getBundleLockState() const
Definition: MCSection.h:158
void setBundleGroupBeforeFirstInst(bool IsFirst)
Definition: MCSection.h:165
Streaming machine code generation interface.
Definition: MCStreamer.h:213
bool popSection()
Restore the current and previous section from the section stack.
MCFragment * getCurrentFragment() const
Definition: MCStreamer.h:409
MCContext & getContext() const
Definition: MCStreamer.h:300
SMLoc getStartTokLoc() const
Definition: MCStreamer.h:292
virtual void emitIntValue(uint64_t Value, unsigned Size)
Special case of EmitValue that avoids the client having to pass in a MCExpr for constant integers.
Definition: MCStreamer.cpp:133
void pushSection()
Save the current and previous section on the section stack.
Definition: MCStreamer.h:416
unsigned emitULEB128IntValue(uint64_t Value, unsigned PadTo=0)
Special case of EmitULEB128Value that avoids the client having to pass in a MCExpr for constant integ...
Definition: MCStreamer.cpp:161
virtual void switchSection(MCSection *Section, uint32_t Subsec=0)
Set the current section where code is being emitted to Section.
void emitInt32(uint64_t Value)
Definition: MCStreamer.h:719
MCSectionSubPair getCurrentSection() const
Return the current section that the streamer is emitting code to.
Definition: MCStreamer.h:393
MCSection * getCurrentSectionOnly() const
Definition: MCStreamer.h:398
void emitZeros(uint64_t NumBytes)
Emit NumBytes worth of zeros.
Definition: MCStreamer.cpp:229
void emitInt8(uint64_t Value)
Definition: MCStreamer.h:717
Generic base class for all target subtargets.
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:188
const MCSymbol & getSymbol() const
Definition: MCExpr.h:406
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:393
VariantKind getKind() const
Definition: MCExpr.h:408
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
bool isInSection() const
isInSection - Check if this symbol is defined in some section (i.e., it is defined but not absolute).
Definition: MCSymbol.h:254
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:205
void setVariableValue(const MCExpr *Value)
Definition: MCSymbol.cpp:47
void setUsedInReloc() const
Definition: MCSymbol.h:215
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
Definition: MCSymbol.h:269
bool isTemporary() const
isTemporary - Check if this is an assembler temporary symbol.
Definition: MCSymbol.h:222
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:307
MutableArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array.
Definition: ArrayRef.h:376
Represents a location in source code.
Definition: SMLoc.h:23
bool empty() const
Definition: SmallVector.h:94
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ STT_FUNC
Definition: ELF.h:1332
@ STT_NOTYPE
Definition: ELF.h:1330
@ STT_GNU_IFUNC
Definition: ELF.h:1337
@ STT_OBJECT
Definition: ELF.h:1331
@ STT_TLS
Definition: ELF.h:1336
@ STV_INTERNAL
Definition: ELF.h:1349
@ STV_HIDDEN
Definition: ELF.h:1350
@ STV_PROTECTED
Definition: ELF.h:1351
@ SHT_PROGBITS
Definition: ELF.h:1068
@ SHT_LLVM_CALL_GRAPH_PROFILE
Definition: ELF.h:1107
@ SHT_NOBITS
Definition: ELF.h:1075
@ SHT_GNU_ATTRIBUTES
Definition: ELF.h:1114
@ STB_GLOBAL
Definition: ELF.h:1319
@ STB_LOCAL
Definition: ELF.h:1318
@ STB_GNU_UNIQUE
Definition: ELF.h:1321
@ STB_WEAK
Definition: ELF.h:1320
@ SHF_MERGE
Definition: ELF.h:1171
@ SHF_STRINGS
Definition: ELF.h:1174
@ SHF_EXCLUDE
Definition: ELF.h:1199
@ SHF_ALLOC
Definition: ELF.h:1165
@ SHF_GNU_RETAIN
Definition: ELF.h:1196
@ SHF_WRITE
Definition: ELF.h:1162
@ SHF_TLS
Definition: ELF.h:1190
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:480
MCStreamer * createELFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE)
std::pair< MCSection *, uint32_t > MCSectionSubPair
Definition: MCStreamer.h:67
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:167
unsigned getULEB128Size(uint64_t Value)
Utility function to get the size of the ULEB128-encoded value.
Definition: LEB128.cpp:19
MCAssemblerFlag
Definition: MCDirectives.h:53
@ MCAF_SyntaxUnified
.syntax (ARM/ELF)
Definition: MCDirectives.h:54
@ MCAF_Code64
.code64 (X86)
Definition: MCDirectives.h:58
@ MCAF_Code16
.code16 (X86) / .code 16 (ARM)
Definition: MCDirectives.h:56
@ MCAF_Code32
.code32 (X86) / .code 32 (ARM)
Definition: MCDirectives.h:57
@ MCAF_SubsectionsViaSymbols
.subsections_via_symbols (MachO)
Definition: MCDirectives.h:55
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1849
unsigned Log2(Align A)
Returns the log2 of the alignment.
Definition: Alignment.h:208
MCSymbolAttr
Definition: MCDirectives.h:18
@ MCSA_Local
.local (ELF)
Definition: MCDirectives.h:38
@ MCSA_WeakDefAutoPrivate
.weak_def_can_be_hidden (MachO)
Definition: MCDirectives.h:48
@ MCSA_Memtag
.memtag (ELF)
Definition: MCDirectives.h:50
@ MCSA_Protected
.protected (ELF)
Definition: MCDirectives.h:43
@ MCSA_Exported
.globl _foo, exported (XCOFF)
Definition: MCDirectives.h:34
@ MCSA_PrivateExtern
.private_extern (MachO)
Definition: MCDirectives.h:42
@ MCSA_Internal
.internal (ELF)
Definition: MCDirectives.h:36
@ MCSA_WeakReference
.weak_reference (MachO)
Definition: MCDirectives.h:47
@ MCSA_AltEntry
.alt_entry (MachO)
Definition: MCDirectives.h:41
@ MCSA_ELF_TypeIndFunction
.type _foo, STT_GNU_IFUNC
Definition: MCDirectives.h:24
@ MCSA_LazyReference
.lazy_reference (MachO)
Definition: MCDirectives.h:37
@ MCSA_ELF_TypeNoType
.type _foo, STT_NOTYPE # aka @notype
Definition: MCDirectives.h:28
@ MCSA_Reference
.reference (MachO)
Definition: MCDirectives.h:44
@ MCSA_SymbolResolver
.symbol_resolver (MachO)
Definition: MCDirectives.h:40
@ MCSA_Weak
.weak
Definition: MCDirectives.h:45
@ MCSA_ELF_TypeTLS
.type _foo, STT_TLS # aka @tls_object
Definition: MCDirectives.h:26
@ MCSA_IndirectSymbol
.indirect_symbol (MachO)
Definition: MCDirectives.h:35
@ MCSA_WeakDefinition
.weak_definition (MachO)
Definition: MCDirectives.h:46
@ MCSA_ELF_TypeCommon
.type _foo, STT_COMMON # aka @common
Definition: MCDirectives.h:27
@ MCSA_Global
.type _foo, @gnu_unique_object
Definition: MCDirectives.h:30
@ MCSA_WeakAntiDep
.weak_anti_dep (COFF)
Definition: MCDirectives.h:49
@ MCSA_Extern
.extern (XCOFF)
Definition: MCDirectives.h:32
@ MCSA_Cold
.cold (MachO)
Definition: MCDirectives.h:22
@ MCSA_ELF_TypeObject
.type _foo, STT_OBJECT # aka @object
Definition: MCDirectives.h:25
@ MCSA_ELF_TypeGnuUniqueObject
Definition: MCDirectives.h:29
@ MCSA_ELF_TypeFunction
.type _foo, STT_FUNC # aka @function
Definition: MCDirectives.h:23
@ MCSA_Hidden
.hidden (ELF)
Definition: MCDirectives.h:33
@ MCSA_LGlobal
.lglobl (XCOFF)
Definition: MCDirectives.h:31
@ MCSA_Invalid
Not a valid directive.
Definition: MCDirectives.h:19
@ MCSA_NoDeadStrip
.no_dead_strip (MachO)
Definition: MCDirectives.h:39
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
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
const MCSymbolRefExpr * From
Definition: MCAssembler.h:353
const MCSymbolRefExpr * To
Definition: MCAssembler.h:354
ELF object attributes section emission support.
Definition: MCELFStreamer.h:92