LLVM 19.0.0git
MCStreamer.h
Go to the documentation of this file.
1//===- MCStreamer.h - High-level Streaming Machine Code Output --*- C++ -*-===//
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 declares the MCStreamer class.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_MC_MCSTREAMER_H
14#define LLVM_MC_MCSTREAMER_H
15
16#include "llvm/ADT/ArrayRef.h"
17#include "llvm/ADT/DenseMap.h"
19#include "llvm/ADT/StringRef.h"
21#include "llvm/MC/MCDwarf.h"
24#include "llvm/MC/MCWinEH.h"
25#include "llvm/Support/Error.h"
26#include "llvm/Support/MD5.h"
27#include "llvm/Support/SMLoc.h"
30#include <cassert>
31#include <cstdint>
32#include <memory>
33#include <optional>
34#include <string>
35#include <utility>
36#include <vector>
37
38namespace llvm {
39
40class APInt;
41class AssemblerConstantPools;
42class MCAsmBackend;
43class MCAssembler;
44class MCContext;
45class MCExpr;
46class MCFragment;
47class MCInst;
48class MCInstPrinter;
49class MCRegister;
50class MCSection;
51class MCStreamer;
52class MCSubtargetInfo;
53class MCSymbol;
54class MCSymbolRefExpr;
55class Triple;
56class Twine;
57class raw_ostream;
58
59namespace codeview {
60struct DefRangeRegisterRelHeader;
61struct DefRangeSubfieldRegisterHeader;
62struct DefRangeRegisterHeader;
63struct DefRangeFramePointerRelHeader;
64}
65
66using MCSectionSubPair = std::pair<MCSection *, const MCExpr *>;
67
68/// Target specific streamer interface. This is used so that targets can
69/// implement support for target specific assembly directives.
70///
71/// If target foo wants to use this, it should implement 3 classes:
72/// * FooTargetStreamer : public MCTargetStreamer
73/// * FooTargetAsmStreamer : public FooTargetStreamer
74/// * FooTargetELFStreamer : public FooTargetStreamer
75///
76/// FooTargetStreamer should have a pure virtual method for each directive. For
77/// example, for a ".bar symbol_name" directive, it should have
78/// virtual emitBar(const MCSymbol &Symbol) = 0;
79///
80/// The FooTargetAsmStreamer and FooTargetELFStreamer classes implement the
81/// method. The assembly streamer just prints ".bar symbol_name". The object
82/// streamer does whatever is needed to implement .bar in the object file.
83///
84/// In the assembly printer and parser the target streamer can be used by
85/// calling getTargetStreamer and casting it to FooTargetStreamer:
86///
87/// MCTargetStreamer &TS = OutStreamer.getTargetStreamer();
88/// FooTargetStreamer &ATS = static_cast<FooTargetStreamer &>(TS);
89///
90/// The base classes FooTargetAsmStreamer and FooTargetELFStreamer should
91/// *never* be treated differently. Callers should always talk to a
92/// FooTargetStreamer.
94protected:
96
97public:
100
102
103 // Allow a target to add behavior to the EmitLabel of MCStreamer.
104 virtual void emitLabel(MCSymbol *Symbol);
105 // Allow a target to add behavior to the emitAssignment of MCStreamer.
106 virtual void emitAssignment(MCSymbol *Symbol, const MCExpr *Value);
107
108 virtual void prettyPrintAsm(MCInstPrinter &InstPrinter, uint64_t Address,
109 const MCInst &Inst, const MCSubtargetInfo &STI,
110 raw_ostream &OS);
111
113
114 /// Update streamer for a new active section.
115 ///
116 /// This is called by popSection and switchSection, if the current
117 /// section changes.
118 virtual void changeSection(const MCSection *CurSection, MCSection *Section,
119 const MCExpr *SubSection, raw_ostream &OS);
120
121 virtual void emitValue(const MCExpr *Value);
122
123 /// Emit the bytes in \p Data into the output.
124 ///
125 /// This is used to emit bytes in \p Data as sequence of .byte directives.
126 virtual void emitRawBytes(StringRef Data);
127
128 virtual void emitConstantPools();
129
130 virtual void finish();
131};
132
133// FIXME: declared here because it is used from
134// lib/CodeGen/AsmPrinter/ARMException.cpp.
136public:
139
140 virtual void emitFnStart();
141 virtual void emitFnEnd();
142 virtual void emitCantUnwind();
143 virtual void emitPersonality(const MCSymbol *Personality);
144 virtual void emitPersonalityIndex(unsigned Index);
145 virtual void emitHandlerData();
146 virtual void emitSetFP(unsigned FpReg, unsigned SpReg,
147 int64_t Offset = 0);
148 virtual void emitMovSP(unsigned Reg, int64_t Offset = 0);
149 virtual void emitPad(int64_t Offset);
150 virtual void emitRegSave(const SmallVectorImpl<unsigned> &RegList,
151 bool isVector);
152 virtual void emitUnwindRaw(int64_t StackOffset,
153 const SmallVectorImpl<uint8_t> &Opcodes);
154
155 virtual void switchVendor(StringRef Vendor);
156 virtual void emitAttribute(unsigned Attribute, unsigned Value);
157 virtual void emitTextAttribute(unsigned Attribute, StringRef String);
158 virtual void emitIntTextAttribute(unsigned Attribute, unsigned IntValue,
159 StringRef StringValue = "");
160 virtual void emitFPU(ARM::FPUKind FPU);
161 virtual void emitArch(ARM::ArchKind Arch);
162 virtual void emitArchExtension(uint64_t ArchExt);
163 virtual void emitObjectArch(ARM::ArchKind Arch);
164 void emitTargetAttributes(const MCSubtargetInfo &STI);
165 virtual void finishAttributeSection();
166 virtual void emitInst(uint32_t Inst, char Suffix = '\0');
167
168 virtual void annotateTLSDescriptorSequence(const MCSymbolRefExpr *SRE);
169
170 virtual void emitThumbSet(MCSymbol *Symbol, const MCExpr *Value);
171
172 void emitConstantPools() override;
173
174 virtual void emitARMWinCFIAllocStack(unsigned Size, bool Wide);
175 virtual void emitARMWinCFISaveRegMask(unsigned Mask, bool Wide);
176 virtual void emitARMWinCFISaveSP(unsigned Reg);
177 virtual void emitARMWinCFISaveFRegs(unsigned First, unsigned Last);
178 virtual void emitARMWinCFISaveLR(unsigned Offset);
179 virtual void emitARMWinCFIPrologEnd(bool Fragment);
180 virtual void emitARMWinCFINop(bool Wide);
181 virtual void emitARMWinCFIEpilogStart(unsigned Condition);
182 virtual void emitARMWinCFIEpilogEnd();
183 virtual void emitARMWinCFICustom(unsigned Opcode);
184
185 /// Reset any state between object emissions, i.e. the equivalent of
186 /// MCStreamer's reset method.
187 virtual void reset();
188
189 /// Callback used to implement the ldr= pseudo.
190 /// Add a new entry to the constant pool for the current section and return an
191 /// MCExpr that can be used to refer to the constant pool location.
192 const MCExpr *addConstantPoolEntry(const MCExpr *, SMLoc Loc);
193
194 /// Callback used to implement the .ltorg directive.
195 /// Emit contents of constant pool for the current section.
197
198private:
199 std::unique_ptr<AssemblerConstantPools> ConstantPools;
200};
201
202/// Streaming machine code generation interface.
203///
204/// This interface is intended to provide a programmatic interface that is very
205/// similar to the level that an assembler .s file provides. It has callbacks
206/// to emit bytes, handle directives, etc. The implementation of this interface
207/// retains state to know what the current section is etc.
208///
209/// There are multiple implementations of this interface: one for writing out
210/// a .s file, and implementations that write out .o files of various formats.
211///
213 MCContext &Context;
214 std::unique_ptr<MCTargetStreamer> TargetStreamer;
215
216 std::vector<MCDwarfFrameInfo> DwarfFrameInfos;
217 // This is a pair of index into DwarfFrameInfos and the MCSection associated
218 // with the frame. Note, we use an index instead of an iterator because they
219 // can be invalidated in std::vector.
221 MCDwarfFrameInfo *getCurrentDwarfFrameInfo();
222
223 /// Similar to DwarfFrameInfos, but for SEH unwind info. Chained frames may
224 /// refer to each other, so use std::unique_ptr to provide pointer stability.
225 std::vector<std::unique_ptr<WinEH::FrameInfo>> WinFrameInfos;
226
227 WinEH::FrameInfo *CurrentWinFrameInfo;
228 size_t CurrentProcWinFrameInfoStartIndex;
229
230 /// Tracks an index to represent the order a symbol was emitted in.
231 /// Zero means we did not emit that symbol.
233
234 /// This is stack of current and previous section values saved by
235 /// pushSection.
237
238 /// Pointer to the parser's SMLoc if available. This is used to provide
239 /// locations for diagnostics.
240 const SMLoc *StartTokLocPtr = nullptr;
241
242 /// The next unique ID to use when creating a WinCFI-related section (.pdata
243 /// or .xdata). This ID ensures that we have a one-to-one mapping from
244 /// code section to unwind info section, which MSVC's incremental linker
245 /// requires.
246 unsigned NextWinCFIID = 0;
247
248 bool UseAssemblerInfoForParsing;
249
250 /// Is the assembler allowed to insert padding automatically? For
251 /// correctness reasons, we sometimes need to ensure instructions aren't
252 /// separated in unexpected ways. At the moment, this feature is only
253 /// useable from an integrated assembler, but assembly syntax is under
254 /// discussion for future inclusion.
255 bool AllowAutoPadding = false;
256
257protected:
258 MCStreamer(MCContext &Ctx);
259
260 virtual void emitCFIStartProcImpl(MCDwarfFrameInfo &Frame);
261 virtual void emitCFIEndProcImpl(MCDwarfFrameInfo &CurFrame);
262
264 return CurrentWinFrameInfo;
265 }
266
267 virtual void emitWindowsUnwindTables(WinEH::FrameInfo *Frame);
268
269 virtual void emitWindowsUnwindTables();
270
271 virtual void emitRawTextImpl(StringRef String);
272
273 /// Returns true if the .cv_loc directive is in the right section.
274 bool checkCVLocSection(unsigned FuncId, unsigned FileNo, SMLoc Loc);
275
276public:
277 MCStreamer(const MCStreamer &) = delete;
278 MCStreamer &operator=(const MCStreamer &) = delete;
279 virtual ~MCStreamer();
280
281 void visitUsedExpr(const MCExpr &Expr);
282 virtual void visitUsedSymbol(const MCSymbol &Sym);
283
285 TargetStreamer.reset(TS);
286 }
287
288 void setStartTokLocPtr(const SMLoc *Loc) { StartTokLocPtr = Loc; }
290 return StartTokLocPtr ? *StartTokLocPtr : SMLoc();
291 }
292
293 /// State management
294 ///
295 virtual void reset();
296
297 MCContext &getContext() const { return Context; }
298
299 virtual MCAssembler *getAssemblerPtr() { return nullptr; }
300
301 void setUseAssemblerInfoForParsing(bool v) { UseAssemblerInfoForParsing = v; }
302 bool getUseAssemblerInfoForParsing() { return UseAssemblerInfoForParsing; }
303
305 return TargetStreamer.get();
306 }
307
308 void setAllowAutoPadding(bool v) { AllowAutoPadding = v; }
309 bool getAllowAutoPadding() const { return AllowAutoPadding; }
310
311 /// When emitting an object file, create and emit a real label. When emitting
312 /// textual assembly, this should do nothing to avoid polluting our output.
313 virtual MCSymbol *emitCFILabel();
314
315 /// Retrieve the current frame info if one is available and it is not yet
316 /// closed. Otherwise, issue an error and return null.
318
319 unsigned getNumFrameInfos();
321
323
324 unsigned getNumWinFrameInfos() { return WinFrameInfos.size(); }
326 return WinFrameInfos;
327 }
328
330
331 /// \name Assembly File Formatting.
332 /// @{
333
334 /// Return true if this streamer supports verbose assembly and if it is
335 /// enabled.
336 virtual bool isVerboseAsm() const { return false; }
337
338 /// Return true if this asm streamer supports emitting unformatted text
339 /// to the .s file with EmitRawText.
340 virtual bool hasRawTextSupport() const { return false; }
341
342 /// Is the integrated assembler required for this streamer to function
343 /// correctly?
344 virtual bool isIntegratedAssemblerRequired() const { return false; }
345
346 /// Add a textual comment.
347 ///
348 /// Typically for comments that can be emitted to the generated .s
349 /// file if applicable as a QoI issue to make the output of the compiler
350 /// more readable. This only affects the MCAsmStreamer, and only when
351 /// verbose assembly output is enabled.
352 ///
353 /// If the comment includes embedded \n's, they will each get the comment
354 /// prefix as appropriate. The added comment should not end with a \n.
355 /// By default, each comment is terminated with an end of line, i.e. the
356 /// EOL param is set to true by default. If one prefers not to end the
357 /// comment with a new line then the EOL param should be passed
358 /// with a false value.
359 virtual void AddComment(const Twine &T, bool EOL = true) {}
360
361 /// Return a raw_ostream that comments can be written to. Unlike
362 /// AddComment, you are required to terminate comments with \n if you use this
363 /// method.
364 virtual raw_ostream &getCommentOS();
365
366 /// Print T and prefix it with the comment string (normally #) and
367 /// optionally a tab. This prints the comment immediately, not at the end of
368 /// the current line. It is basically a safe version of EmitRawText: since it
369 /// only prints comments, the object streamer ignores it instead of asserting.
370 virtual void emitRawComment(const Twine &T, bool TabPrefix = true);
371
372 /// Add explicit comment T. T is required to be a valid
373 /// comment in the output and does not need to be escaped.
374 virtual void addExplicitComment(const Twine &T);
375
376 /// Emit added explicit comments.
377 virtual void emitExplicitComments();
378
379 /// Emit a blank line to a .s file to pretty it up.
380 virtual void addBlankLine() {}
381
382 /// @}
383
384 /// \name Symbol & Section Management
385 /// @{
386
387 /// Return the current section that the streamer is emitting code to.
389 if (!SectionStack.empty())
390 return SectionStack.back().first;
391 return MCSectionSubPair();
392 }
394
395 /// Return the previous section that the streamer is emitting code to.
397 if (!SectionStack.empty())
398 return SectionStack.back().second;
399 return MCSectionSubPair();
400 }
401
402 /// Returns an index to represent the order a symbol was emitted in.
403 /// (zero if we did not emit that symbol)
404 unsigned getSymbolOrder(const MCSymbol *Sym) const {
405 return SymbolOrdering.lookup(Sym);
406 }
407
408 /// Update streamer for a new active section.
409 ///
410 /// This is called by popSection and switchSection, if the current
411 /// section changes.
412 virtual void changeSection(MCSection *, const MCExpr *);
413
414 /// Save the current and previous section on the section stack.
415 void pushSection() {
416 SectionStack.push_back(
417 std::make_pair(getCurrentSection(), getPreviousSection()));
418 }
419
420 /// Restore the current and previous section from the section stack.
421 /// Calls changeSection as needed.
422 ///
423 /// Returns false if the stack was empty.
424 bool popSection() {
425 if (SectionStack.size() <= 1)
426 return false;
427 auto I = SectionStack.end();
428 --I;
429 MCSectionSubPair OldSection = I->first;
430 --I;
431 MCSectionSubPair NewSection = I->first;
432
433 if (NewSection.first && OldSection != NewSection)
434 changeSection(NewSection.first, NewSection.second);
435 SectionStack.pop_back();
436 return true;
437 }
438
439 bool subSection(const MCExpr *Subsection) {
440 if (SectionStack.empty())
441 return false;
442
443 switchSection(SectionStack.back().first.first, Subsection);
444 return true;
445 }
446
447 /// Set the current section where code is being emitted to \p Section. This
448 /// is required to update CurSection.
449 ///
450 /// This corresponds to assembler directives like .section, .text, etc.
451 virtual void switchSection(MCSection *Section,
452 const MCExpr *Subsection = nullptr);
453
454 /// Set the current section where code is being emitted to \p Section.
455 /// This is required to update CurSection. This version does not call
456 /// changeSection.
458 const MCExpr *Subsection = nullptr) {
459 assert(Section && "Cannot switch to a null section!");
460 MCSectionSubPair curSection = SectionStack.back().first;
461 SectionStack.back().second = curSection;
462 if (MCSectionSubPair(Section, Subsection) != curSection)
463 SectionStack.back().first = MCSectionSubPair(Section, Subsection);
464 }
465
466 /// Create the default sections and set the initial one.
467 virtual void initSections(bool NoExecStack, const MCSubtargetInfo &STI);
468
469 MCSymbol *endSection(MCSection *Section);
470
471 /// Sets the symbol's section.
472 ///
473 /// Each emitted symbol will be tracked in the ordering table,
474 /// so we can sort on them later.
475 void assignFragment(MCSymbol *Symbol, MCFragment *Fragment);
476
477 /// Returns the mnemonic for \p MI, if the streamer has access to a
478 /// instruction printer and returns an empty string otherwise.
479 virtual StringRef getMnemonic(MCInst &MI) { return ""; }
480
481 /// Emit a label for \p Symbol into the current section.
482 ///
483 /// This corresponds to an assembler statement such as:
484 /// foo:
485 ///
486 /// \param Symbol - The symbol to emit. A given symbol should only be
487 /// emitted as a label once, and symbols emitted as a label should never be
488 /// used in an assignment.
489 // FIXME: These emission are non-const because we mutate the symbol to
490 // add the section we're emitting it to later.
491 virtual void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc());
492
493 virtual void emitEHSymAttributes(const MCSymbol *Symbol, MCSymbol *EHSymbol);
494
495 /// Note in the output the specified \p Flag.
496 virtual void emitAssemblerFlag(MCAssemblerFlag Flag);
497
498 /// Emit the given list \p Options of strings as linker
499 /// options into the output.
501
502 /// Note in the output the specified region \p Kind.
503 virtual void emitDataRegion(MCDataRegionType Kind) {}
504
505 /// Specify the Mach-O minimum deployment target version.
506 virtual void emitVersionMin(MCVersionMinType Type, unsigned Major,
507 unsigned Minor, unsigned Update,
508 VersionTuple SDKVersion) {}
509
510 /// Emit/Specify Mach-O build version command.
511 /// \p Platform should be one of MachO::PlatformType.
512 virtual void emitBuildVersion(unsigned Platform, unsigned Major,
513 unsigned Minor, unsigned Update,
514 VersionTuple SDKVersion) {}
515
516 virtual void emitDarwinTargetVariantBuildVersion(unsigned Platform,
517 unsigned Major,
518 unsigned Minor,
519 unsigned Update,
520 VersionTuple SDKVersion) {}
521
523 const VersionTuple &SDKVersion,
524 const Triple *DarwinTargetVariantTriple,
525 const VersionTuple &DarwinTargetVariantSDKVersion);
526
527 /// Note in the output that the specified \p Func is a Thumb mode
528 /// function (ARM target only).
529 virtual void emitThumbFunc(MCSymbol *Func);
530
531 /// Emit an assignment of \p Value to \p Symbol.
532 ///
533 /// This corresponds to an assembler statement such as:
534 /// symbol = value
535 ///
536 /// The assignment generates no code, but has the side effect of binding the
537 /// value in the current context. For the assembly streamer, this prints the
538 /// binding into the .s file.
539 ///
540 /// \param Symbol - The symbol being assigned to.
541 /// \param Value - The value for the symbol.
542 virtual void emitAssignment(MCSymbol *Symbol, const MCExpr *Value);
543
544 /// Emit an assignment of \p Value to \p Symbol, but only if \p Value is also
545 /// emitted.
546 virtual void emitConditionalAssignment(MCSymbol *Symbol, const MCExpr *Value);
547
548 /// Emit an weak reference from \p Alias to \p Symbol.
549 ///
550 /// This corresponds to an assembler statement such as:
551 /// .weakref alias, symbol
552 ///
553 /// \param Alias - The alias that is being created.
554 /// \param Symbol - The symbol being aliased.
555 virtual void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol);
556
557 /// Add the given \p Attribute to \p Symbol.
558 virtual bool emitSymbolAttribute(MCSymbol *Symbol,
560
561 /// Set the \p DescValue for the \p Symbol.
562 ///
563 /// \param Symbol - The symbol to have its n_desc field set.
564 /// \param DescValue - The value to set into the n_desc field.
565 virtual void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue);
566
567 /// Start emitting COFF symbol definition
568 ///
569 /// \param Symbol - The symbol to have its External & Type fields set.
570 virtual void beginCOFFSymbolDef(const MCSymbol *Symbol);
571
572 /// Emit the storage class of the symbol.
573 ///
574 /// \param StorageClass - The storage class the symbol should have.
576
577 /// Emit the type of the symbol.
578 ///
579 /// \param Type - A COFF type identifier (see COFF::SymbolType in X86COFF.h)
580 virtual void emitCOFFSymbolType(int Type);
581
582 /// Marks the end of the symbol definition.
583 virtual void endCOFFSymbolDef();
584
585 virtual void emitCOFFSafeSEH(MCSymbol const *Symbol);
586
587 /// Emits the symbol table index of a Symbol into the current section.
588 virtual void emitCOFFSymbolIndex(MCSymbol const *Symbol);
589
590 /// Emits a COFF section index.
591 ///
592 /// \param Symbol - Symbol the section number relocation should point to.
593 virtual void emitCOFFSectionIndex(MCSymbol const *Symbol);
594
595 /// Emits a COFF section relative relocation.
596 ///
597 /// \param Symbol - Symbol the section relative relocation should point to.
598 virtual void emitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset);
599
600 /// Emits a COFF image relative relocation.
601 ///
602 /// \param Symbol - Symbol the image relative relocation should point to.
603 virtual void emitCOFFImgRel32(MCSymbol const *Symbol, int64_t Offset);
604
605 /// Emits an lcomm directive with XCOFF csect information.
606 ///
607 /// \param LabelSym - Label on the block of storage.
608 /// \param Size - The size of the block of storage.
609 /// \param CsectSym - Csect name for the block of storage.
610 /// \param Alignment - The alignment of the symbol in bytes.
611 virtual void emitXCOFFLocalCommonSymbol(MCSymbol *LabelSym, uint64_t Size,
612 MCSymbol *CsectSym, Align Alignment);
613
614 /// Emit a symbol's linkage and visibility with a linkage directive for XCOFF.
615 ///
616 /// \param Symbol - The symbol to emit.
617 /// \param Linkage - The linkage of the symbol to emit.
618 /// \param Visibility - The visibility of the symbol to emit or MCSA_Invalid
619 /// if the symbol does not have an explicit visibility.
621 MCSymbolAttr Linkage,
622 MCSymbolAttr Visibility);
623
624 /// Emit a XCOFF .rename directive which creates a synonym for an illegal or
625 /// undesirable name.
626 ///
627 /// \param Name - The name used internally in the assembly for references to
628 /// the symbol.
629 /// \param Rename - The value to which the Name parameter is
630 /// changed at the end of assembly.
631 virtual void emitXCOFFRenameDirective(const MCSymbol *Name, StringRef Rename);
632
633 /// Emit an XCOFF .except directive which adds information about
634 /// a trap instruction to the object file exception section
635 ///
636 /// \param Symbol - The function containing the trap.
637 /// \param Lang - The language code for the exception entry.
638 /// \param Reason - The reason code for the exception entry.
639 virtual void emitXCOFFExceptDirective(const MCSymbol *Symbol,
640 const MCSymbol *Trap,
641 unsigned Lang, unsigned Reason,
642 unsigned FunctionSize, bool hasDebug);
643
644 /// Emit a XCOFF .ref directive which creates R_REF type entry in the
645 /// relocation table for one or more symbols.
646 ///
647 /// \param Sym - The symbol on the .ref directive.
648 virtual void emitXCOFFRefDirective(const MCSymbol *Symbol);
649
650 /// Emit a C_INFO symbol with XCOFF embedded metadata to the .info section.
651 ///
652 /// \param Name - The embedded metadata name
653 /// \param Metadata - The embedded metadata
655
656 /// Emit an ELF .size directive.
657 ///
658 /// This corresponds to an assembler statement such as:
659 /// .size symbol, expression
660 virtual void emitELFSize(MCSymbol *Symbol, const MCExpr *Value);
661
662 /// Emit an ELF .symver directive.
663 ///
664 /// This corresponds to an assembler statement such as:
665 /// .symver _start, foo@@SOME_VERSION
666 virtual void emitELFSymverDirective(const MCSymbol *OriginalSym,
667 StringRef Name, bool KeepOriginalSym);
668
669 /// Emit a Linker Optimization Hint (LOH) directive.
670 /// \param Args - Arguments of the LOH.
671 virtual void emitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) {}
672
673 /// Emit a .gnu_attribute directive.
674 virtual void emitGNUAttribute(unsigned Tag, unsigned Value) {}
675
676 /// Emit a common symbol.
677 ///
678 /// \param Symbol - The common symbol to emit.
679 /// \param Size - The size of the common symbol.
680 /// \param ByteAlignment - The alignment of the symbol.
681 virtual void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
682 Align ByteAlignment) = 0;
683
684 /// Emit a local common (.lcomm) symbol.
685 ///
686 /// \param Symbol - The common symbol to emit.
687 /// \param Size - The size of the common symbol.
688 /// \param ByteAlignment - The alignment of the common symbol in bytes.
689 virtual void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
690 Align ByteAlignment);
691
692 /// Emit the zerofill section and an optional symbol.
693 ///
694 /// \param Section - The zerofill section to create and or to put the symbol
695 /// \param Symbol - The zerofill symbol to emit, if non-NULL.
696 /// \param Size - The size of the zerofill symbol.
697 /// \param ByteAlignment - The alignment of the zerofill symbol.
698 virtual void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
699 uint64_t Size = 0, Align ByteAlignment = Align(1),
700 SMLoc Loc = SMLoc()) = 0;
701
702 /// Emit a thread local bss (.tbss) symbol.
703 ///
704 /// \param Section - The thread local common section.
705 /// \param Symbol - The thread local common symbol to emit.
706 /// \param Size - The size of the symbol.
707 /// \param ByteAlignment - The alignment of the thread local common symbol.
708 virtual void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
709 uint64_t Size, Align ByteAlignment = Align(1));
710
711 /// @}
712 /// \name Generating Data
713 /// @{
714
715 /// Emit the bytes in \p Data into the output.
716 ///
717 /// This is used to implement assembler directives such as .byte, .ascii,
718 /// etc.
719 virtual void emitBytes(StringRef Data);
720
721 /// Functionally identical to EmitBytes. When emitting textual assembly, this
722 /// method uses .byte directives instead of .ascii or .asciz for readability.
723 virtual void emitBinaryData(StringRef Data);
724
725 /// Emit the expression \p Value into the output as a native
726 /// integer of the given \p Size bytes.
727 ///
728 /// This is used to implement assembler directives such as .word, .quad,
729 /// etc.
730 ///
731 /// \param Value - The value to emit.
732 /// \param Size - The size of the integer (in bytes) to emit. This must
733 /// match a native machine width.
734 /// \param Loc - The location of the expression for error reporting.
735 virtual void emitValueImpl(const MCExpr *Value, unsigned Size,
736 SMLoc Loc = SMLoc());
737
738 void emitValue(const MCExpr *Value, unsigned Size, SMLoc Loc = SMLoc());
739
740 /// Special case of EmitValue that avoids the client having
741 /// to pass in a MCExpr for constant integers.
742 virtual void emitIntValue(uint64_t Value, unsigned Size);
743 virtual void emitIntValue(APInt Value);
744
745 /// Special case of EmitValue that avoids the client having to pass
746 /// in a MCExpr for constant integers & prints in Hex format for certain
747 /// modes.
748 virtual void emitIntValueInHex(uint64_t Value, unsigned Size) {
750 }
751
756
757 /// Special case of EmitValue that avoids the client having to pass
758 /// in a MCExpr for constant integers & prints in Hex format for certain
759 /// modes, pads the field with leading zeros to Size width
762 }
763
764 virtual void emitULEB128Value(const MCExpr *Value);
765
766 virtual void emitSLEB128Value(const MCExpr *Value);
767
768 /// Special case of EmitULEB128Value that avoids the client having to
769 /// pass in a MCExpr for constant integers.
770 unsigned emitULEB128IntValue(uint64_t Value, unsigned PadTo = 0);
771
772 /// Special case of EmitSLEB128Value that avoids the client having to
773 /// pass in a MCExpr for constant integers.
774 unsigned emitSLEB128IntValue(int64_t Value);
775
776 /// Special case of EmitValue that avoids the client having to pass in
777 /// a MCExpr for MCSymbols.
778 void emitSymbolValue(const MCSymbol *Sym, unsigned Size,
779 bool IsSectionRelative = false);
780
781 /// Emit the expression \p Value into the output as a dtprel
782 /// (64-bit DTP relative) value.
783 ///
784 /// This is used to implement assembler directives such as .dtpreldword on
785 /// targets that support them.
786 virtual void emitDTPRel64Value(const MCExpr *Value);
787
788 /// Emit the expression \p Value into the output as a dtprel
789 /// (32-bit DTP relative) value.
790 ///
791 /// This is used to implement assembler directives such as .dtprelword on
792 /// targets that support them.
793 virtual void emitDTPRel32Value(const MCExpr *Value);
794
795 /// Emit the expression \p Value into the output as a tprel
796 /// (64-bit TP relative) value.
797 ///
798 /// This is used to implement assembler directives such as .tpreldword on
799 /// targets that support them.
800 virtual void emitTPRel64Value(const MCExpr *Value);
801
802 /// Emit the expression \p Value into the output as a tprel
803 /// (32-bit TP relative) value.
804 ///
805 /// This is used to implement assembler directives such as .tprelword on
806 /// targets that support them.
807 virtual void emitTPRel32Value(const MCExpr *Value);
808
809 /// Emit the expression \p Value into the output as a gprel64 (64-bit
810 /// GP relative) value.
811 ///
812 /// This is used to implement assembler directives such as .gpdword on
813 /// targets that support them.
814 virtual void emitGPRel64Value(const MCExpr *Value);
815
816 /// Emit the expression \p Value into the output as a gprel32 (32-bit
817 /// GP relative) value.
818 ///
819 /// This is used to implement assembler directives such as .gprel32 on
820 /// targets that support them.
821 virtual void emitGPRel32Value(const MCExpr *Value);
822
823 /// Emit NumBytes bytes worth of the value specified by FillValue.
824 /// This implements directives such as '.space'.
825 void emitFill(uint64_t NumBytes, uint8_t FillValue);
826
827 /// Emit \p Size bytes worth of the value specified by \p FillValue.
828 ///
829 /// This is used to implement assembler directives such as .space or .skip.
830 ///
831 /// \param NumBytes - The number of bytes to emit.
832 /// \param FillValue - The value to use when filling bytes.
833 /// \param Loc - The location of the expression for error reporting.
834 virtual void emitFill(const MCExpr &NumBytes, uint64_t FillValue,
835 SMLoc Loc = SMLoc());
836
837 /// Emit \p NumValues copies of \p Size bytes. Each \p Size bytes is
838 /// taken from the lowest order 4 bytes of \p Expr expression.
839 ///
840 /// This is used to implement assembler directives such as .fill.
841 ///
842 /// \param NumValues - The number of copies of \p Size bytes to emit.
843 /// \param Size - The size (in bytes) of each repeated value.
844 /// \param Expr - The expression from which \p Size bytes are used.
845 virtual void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
846 SMLoc Loc = SMLoc());
847
848 virtual void emitNops(int64_t NumBytes, int64_t ControlledNopLength,
849 SMLoc Loc, const MCSubtargetInfo& STI);
850
851 /// Emit NumBytes worth of zeros.
852 /// This function properly handles data in virtual sections.
853 void emitZeros(uint64_t NumBytes);
854
855 /// Emit some number of copies of \p Value until the byte alignment \p
856 /// ByteAlignment is reached.
857 ///
858 /// If the number of bytes need to emit for the alignment is not a multiple
859 /// of \p ValueSize, then the contents of the emitted fill bytes is
860 /// undefined.
861 ///
862 /// This used to implement the .align assembler directive.
863 ///
864 /// \param Alignment - The alignment to reach.
865 /// \param Value - The value to use when filling bytes.
866 /// \param ValueSize - The size of the integer (in bytes) to emit for
867 /// \p Value. This must match a native machine width.
868 /// \param MaxBytesToEmit - The maximum numbers of bytes to emit, or 0. If
869 /// the alignment cannot be reached in this many bytes, no bytes are
870 /// emitted.
871 virtual void emitValueToAlignment(Align Alignment, int64_t Value = 0,
872 unsigned ValueSize = 1,
873 unsigned MaxBytesToEmit = 0);
874
875 /// Emit nops until the byte alignment \p ByteAlignment is reached.
876 ///
877 /// This used to align code where the alignment bytes may be executed. This
878 /// can emit different bytes for different sizes to optimize execution.
879 ///
880 /// \param Alignment - The alignment to reach.
881 /// \param STI - The MCSubtargetInfo in operation when padding is emitted.
882 /// \param MaxBytesToEmit - The maximum numbers of bytes to emit, or 0. If
883 /// the alignment cannot be reached in this many bytes, no bytes are
884 /// emitted.
885 virtual void emitCodeAlignment(Align Alignment, const MCSubtargetInfo *STI,
886 unsigned MaxBytesToEmit = 0);
887
888 /// Emit some number of copies of \p Value until the byte offset \p
889 /// Offset is reached.
890 ///
891 /// This is used to implement assembler directives such as .org.
892 ///
893 /// \param Offset - The offset to reach. This may be an expression, but the
894 /// expression must be associated with the current section.
895 /// \param Value - The value to use when filling bytes.
896 virtual void emitValueToOffset(const MCExpr *Offset, unsigned char Value,
897 SMLoc Loc);
898
899 /// @}
900
901 /// Switch to a new logical file. This is used to implement the '.file
902 /// "foo.c"' assembler directive.
903 virtual void emitFileDirective(StringRef Filename);
904
905 /// Emit ".file assembler diretive with additioal info.
906 virtual void emitFileDirective(StringRef Filename, StringRef CompilerVersion,
907 StringRef TimeStamp, StringRef Description);
908
909 /// Emit the "identifiers" directive. This implements the
910 /// '.ident "version foo"' assembler directive.
911 virtual void emitIdent(StringRef IdentString) {}
912
913 /// Associate a filename with a specified logical file number. This
914 /// implements the DWARF2 '.file 4 "foo.c"' assembler directive.
916 unsigned FileNo, StringRef Directory, StringRef Filename,
917 std::optional<MD5::MD5Result> Checksum = std::nullopt,
918 std::optional<StringRef> Source = std::nullopt, unsigned CUID = 0) {
919 return cantFail(
920 tryEmitDwarfFileDirective(FileNo, Directory, Filename, Checksum,
921 Source, CUID));
922 }
923
924 /// Associate a filename with a specified logical file number.
925 /// Also associate a directory, optional checksum, and optional source
926 /// text with the logical file. This implements the DWARF2
927 /// '.file 4 "dir/foo.c"' assembler directive, and the DWARF5
928 /// '.file 4 "dir/foo.c" md5 "..." source "..."' assembler directive.
930 unsigned FileNo, StringRef Directory, StringRef Filename,
931 std::optional<MD5::MD5Result> Checksum = std::nullopt,
932 std::optional<StringRef> Source = std::nullopt, unsigned CUID = 0);
933
934 /// Specify the "root" file of the compilation, using the ".file 0" extension.
935 virtual void emitDwarfFile0Directive(StringRef Directory, StringRef Filename,
936 std::optional<MD5::MD5Result> Checksum,
937 std::optional<StringRef> Source,
938 unsigned CUID = 0);
939
940 virtual void emitCFIBKeyFrame();
941 virtual void emitCFIMTETaggedFrame();
942
943 /// This implements the DWARF2 '.loc fileno lineno ...' assembler
944 /// directive.
945 virtual void emitDwarfLocDirective(unsigned FileNo, unsigned Line,
946 unsigned Column, unsigned Flags,
947 unsigned Isa, unsigned Discriminator,
948 StringRef FileName);
949
950 /// Associate a filename with a specified logical file number, and also
951 /// specify that file's checksum information. This implements the '.cv_file 4
952 /// "foo.c"' assembler directive. Returns true on success.
953 virtual bool emitCVFileDirective(unsigned FileNo, StringRef Filename,
954 ArrayRef<uint8_t> Checksum,
955 unsigned ChecksumKind);
956
957 /// Introduces a function id for use with .cv_loc.
958 virtual bool emitCVFuncIdDirective(unsigned FunctionId);
959
960 /// Introduces an inline call site id for use with .cv_loc. Includes
961 /// extra information for inline line table generation.
962 virtual bool emitCVInlineSiteIdDirective(unsigned FunctionId, unsigned IAFunc,
963 unsigned IAFile, unsigned IALine,
964 unsigned IACol, SMLoc Loc);
965
966 /// This implements the CodeView '.cv_loc' assembler directive.
967 virtual void emitCVLocDirective(unsigned FunctionId, unsigned FileNo,
968 unsigned Line, unsigned Column,
969 bool PrologueEnd, bool IsStmt,
970 StringRef FileName, SMLoc Loc);
971
972 /// This implements the CodeView '.cv_linetable' assembler directive.
973 virtual void emitCVLinetableDirective(unsigned FunctionId,
974 const MCSymbol *FnStart,
975 const MCSymbol *FnEnd);
976
977 /// This implements the CodeView '.cv_inline_linetable' assembler
978 /// directive.
979 virtual void emitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
980 unsigned SourceFileId,
981 unsigned SourceLineNum,
982 const MCSymbol *FnStartSym,
983 const MCSymbol *FnEndSym);
984
985 /// This implements the CodeView '.cv_def_range' assembler
986 /// directive.
987 virtual void emitCVDefRangeDirective(
988 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
989 StringRef FixedSizePortion);
990
991 virtual void emitCVDefRangeDirective(
992 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
994
995 virtual void emitCVDefRangeDirective(
996 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
998
999 virtual void emitCVDefRangeDirective(
1000 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
1002
1003 virtual void emitCVDefRangeDirective(
1004 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
1006
1007 /// This implements the CodeView '.cv_stringtable' assembler directive.
1009
1010 /// This implements the CodeView '.cv_filechecksums' assembler directive.
1012
1013 /// This implements the CodeView '.cv_filechecksumoffset' assembler
1014 /// directive.
1015 virtual void emitCVFileChecksumOffsetDirective(unsigned FileNo) {}
1016
1017 /// This implements the CodeView '.cv_fpo_data' assembler directive.
1018 virtual void emitCVFPOData(const MCSymbol *ProcSym, SMLoc Loc = {}) {}
1019
1020 /// Emit the absolute difference between two symbols.
1021 ///
1022 /// \pre Offset of \c Hi is greater than the offset \c Lo.
1023 virtual void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
1024 unsigned Size);
1025
1026 /// Emit the absolute difference between two symbols encoded with ULEB128.
1027 virtual void emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi,
1028 const MCSymbol *Lo);
1029
1030 virtual MCSymbol *getDwarfLineTableSymbol(unsigned CUID);
1031 virtual void emitCFISections(bool EH, bool Debug);
1032 void emitCFIStartProc(bool IsSimple, SMLoc Loc = SMLoc());
1033 void emitCFIEndProc();
1034 virtual void emitCFIDefCfa(int64_t Register, int64_t Offset, SMLoc Loc = {});
1035 virtual void emitCFIDefCfaOffset(int64_t Offset, SMLoc Loc = {});
1036 virtual void emitCFIDefCfaRegister(int64_t Register, SMLoc Loc = {});
1037 virtual void emitCFILLVMDefAspaceCfa(int64_t Register, int64_t Offset,
1038 int64_t AddressSpace, SMLoc Loc = {});
1039 virtual void emitCFIOffset(int64_t Register, int64_t Offset, SMLoc Loc = {});
1040 virtual void emitCFIPersonality(const MCSymbol *Sym, unsigned Encoding);
1041 virtual void emitCFILsda(const MCSymbol *Sym, unsigned Encoding);
1042 virtual void emitCFIRememberState(SMLoc Loc);
1043 virtual void emitCFIRestoreState(SMLoc Loc);
1044 virtual void emitCFISameValue(int64_t Register, SMLoc Loc = {});
1045 virtual void emitCFIRestore(int64_t Register, SMLoc Loc = {});
1046 virtual void emitCFIRelOffset(int64_t Register, int64_t Offset, SMLoc Loc);
1047 virtual void emitCFIAdjustCfaOffset(int64_t Adjustment, SMLoc Loc = {});
1048 virtual void emitCFIEscape(StringRef Values, SMLoc Loc = {});
1049 virtual void emitCFIReturnColumn(int64_t Register);
1050 virtual void emitCFIGnuArgsSize(int64_t Size, SMLoc Loc = {});
1051 virtual void emitCFISignalFrame();
1052 virtual void emitCFIUndefined(int64_t Register, SMLoc Loc = {});
1053 virtual void emitCFIRegister(int64_t Register1, int64_t Register2,
1054 SMLoc Loc = {});
1055 virtual void emitCFIWindowSave(SMLoc Loc = {});
1056 virtual void emitCFINegateRAState(SMLoc Loc = {});
1057
1058 virtual void emitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc = SMLoc());
1059 virtual void emitWinCFIEndProc(SMLoc Loc = SMLoc());
1060 /// This is used on platforms, such as Windows on ARM64, that require function
1061 /// or funclet sizes to be emitted in .xdata before the End marker is emitted
1062 /// for the frame. We cannot use the End marker, as it is not set at the
1063 /// point of emitting .xdata, in order to indicate that the frame is active.
1064 virtual void emitWinCFIFuncletOrFuncEnd(SMLoc Loc = SMLoc());
1065 virtual void emitWinCFIStartChained(SMLoc Loc = SMLoc());
1066 virtual void emitWinCFIEndChained(SMLoc Loc = SMLoc());
1067 virtual void emitWinCFIPushReg(MCRegister Register, SMLoc Loc = SMLoc());
1068 virtual void emitWinCFISetFrame(MCRegister Register, unsigned Offset,
1069 SMLoc Loc = SMLoc());
1070 virtual void emitWinCFIAllocStack(unsigned Size, SMLoc Loc = SMLoc());
1071 virtual void emitWinCFISaveReg(MCRegister Register, unsigned Offset,
1072 SMLoc Loc = SMLoc());
1073 virtual void emitWinCFISaveXMM(MCRegister Register, unsigned Offset,
1074 SMLoc Loc = SMLoc());
1075 virtual void emitWinCFIPushFrame(bool Code, SMLoc Loc = SMLoc());
1076 virtual void emitWinCFIEndProlog(SMLoc Loc = SMLoc());
1077 virtual void emitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except,
1078 SMLoc Loc = SMLoc());
1079 virtual void emitWinEHHandlerData(SMLoc Loc = SMLoc());
1080
1081 virtual void emitCGProfileEntry(const MCSymbolRefExpr *From,
1082 const MCSymbolRefExpr *To, uint64_t Count);
1083
1084 /// Get the .pdata section used for the given section. Typically the given
1085 /// section is either the main .text section or some other COMDAT .text
1086 /// section, but it may be any section containing code.
1087 MCSection *getAssociatedPDataSection(const MCSection *TextSec);
1088
1089 /// Get the .xdata section used for the given section.
1090 MCSection *getAssociatedXDataSection(const MCSection *TextSec);
1091
1092 virtual void emitSyntaxDirective();
1093
1094 /// Record a relocation described by the .reloc directive. Return std::nullopt
1095 /// if succeeded. Otherwise, return a pair (Name is invalid, error message).
1096 virtual std::optional<std::pair<bool, std::string>>
1098 SMLoc Loc, const MCSubtargetInfo &STI) {
1099 return std::nullopt;
1100 }
1101
1102 virtual void emitAddrsig() {}
1103 virtual void emitAddrsigSym(const MCSymbol *Sym) {}
1104
1105 /// Emit the given \p Instruction into the current section.
1106 virtual void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI);
1107
1108 /// Emit the a pseudo probe into the current section.
1109 virtual void emitPseudoProbe(uint64_t Guid, uint64_t Index, uint64_t Type,
1110 uint64_t Attr, uint64_t Discriminator,
1111 const MCPseudoProbeInlineStack &InlineStack,
1112 MCSymbol *FnSym);
1113
1114 /// Set the bundle alignment mode from now on in the section.
1115 /// The value 1 means turn the bundle alignment off.
1116 virtual void emitBundleAlignMode(Align Alignment);
1117
1118 /// The following instructions are a bundle-locked group.
1119 ///
1120 /// \param AlignToEnd - If true, the bundle-locked group will be aligned to
1121 /// the end of a bundle.
1122 virtual void emitBundleLock(bool AlignToEnd);
1123
1124 /// Ends a bundle-locked group.
1125 virtual void emitBundleUnlock();
1126
1127 /// If this file is backed by a assembly streamer, this dumps the
1128 /// specified string in the output .s file. This capability is indicated by
1129 /// the hasRawTextSupport() predicate. By default this aborts.
1130 void emitRawText(const Twine &String);
1131
1132 /// Streamer specific finalization.
1133 virtual void finishImpl();
1134 /// Finish emission of machine code.
1135 void finish(SMLoc EndLoc = SMLoc());
1136
1137 virtual bool mayHaveInstructions(MCSection &Sec) const { return true; }
1138
1139 /// Emit a special value of 0xffffffff if producing 64-bit debugging info.
1140 void maybeEmitDwarf64Mark();
1141
1142 /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen
1143 /// according to the settings.
1144 virtual void emitDwarfUnitLength(uint64_t Length, const Twine &Comment);
1145
1146 /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen
1147 /// according to the settings.
1148 /// Return the end symbol generated inside, the caller needs to emit it.
1149 virtual MCSymbol *emitDwarfUnitLength(const Twine &Prefix,
1150 const Twine &Comment);
1151
1152 /// Emit the debug line start label.
1153 virtual void emitDwarfLineStartLabel(MCSymbol *StartSym);
1154
1155 /// Emit the debug line end entry.
1156 virtual void emitDwarfLineEndEntry(MCSection *Section, MCSymbol *LastLabel) {}
1157
1158 /// If targets does not support representing debug line section by .loc/.file
1159 /// directives in assembly output, we need to populate debug line section with
1160 /// raw debug line contents.
1161 virtual void emitDwarfAdvanceLineAddr(int64_t LineDelta,
1162 const MCSymbol *LastLabel,
1163 const MCSymbol *Label,
1164 unsigned PointerSize) {}
1165
1166 /// Do finalization for the streamer at the end of a section.
1167 virtual void doFinalizationAtSectionEnd(MCSection *Section) {}
1168};
1169
1170/// Create a dummy machine code streamer, which does nothing. This is useful for
1171/// timing the assembler front end.
1172MCStreamer *createNullStreamer(MCContext &Ctx);
1173
1174} // end namespace llvm
1175
1176#endif // LLVM_MC_MCSTREAMER_H
BlockVerifier::State From
This file defines the DenseMap class.
std::string Name
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
IRTranslator LLVM IR MI
#define I(x, y, z)
Definition: MD5.cpp:58
unsigned Reg
LLVMContext & Context
bool Debug
Profile::FuncID FuncId
Definition: Profile.cpp:321
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
This file defines the SmallVector class.
Defines the llvm::VersionTuple class, which represents a version in the form major[....
Class for arbitrary precision integers.
Definition: APInt.h:76
virtual void emitUnwindRaw(int64_t StackOffset, const SmallVectorImpl< uint8_t > &Opcodes)
~ARMTargetStreamer() override
void emitTargetAttributes(const MCSubtargetInfo &STI)
Emit the build attributes that only depend on the hardware that we expect.
virtual void reset()
Reset any state between object emissions, i.e.
virtual void annotateTLSDescriptorSequence(const MCSymbolRefExpr *SRE)
virtual void finishAttributeSection()
virtual void emitARMWinCFISaveSP(unsigned Reg)
virtual void emitPersonalityIndex(unsigned Index)
virtual void emitInst(uint32_t Inst, char Suffix='\0')
virtual void emitARMWinCFISaveLR(unsigned Offset)
virtual void emitArchExtension(uint64_t ArchExt)
virtual void emitRegSave(const SmallVectorImpl< unsigned > &RegList, bool isVector)
virtual void emitTextAttribute(unsigned Attribute, StringRef String)
virtual void emitARMWinCFIAllocStack(unsigned Size, bool Wide)
virtual void emitMovSP(unsigned Reg, int64_t Offset=0)
virtual void emitARMWinCFICustom(unsigned Opcode)
virtual void emitARMWinCFISaveRegMask(unsigned Mask, bool Wide)
virtual void emitARMWinCFIEpilogEnd()
virtual void emitARMWinCFIPrologEnd(bool Fragment)
virtual void switchVendor(StringRef Vendor)
virtual void emitPersonality(const MCSymbol *Personality)
virtual void emitObjectArch(ARM::ArchKind Arch)
const MCExpr * addConstantPoolEntry(const MCExpr *, SMLoc Loc)
Callback used to implement the ldr= pseudo.
virtual void emitIntTextAttribute(unsigned Attribute, unsigned IntValue, StringRef StringValue="")
virtual void emitThumbSet(MCSymbol *Symbol, const MCExpr *Value)
virtual void emitFPU(ARM::FPUKind FPU)
virtual void emitARMWinCFISaveFRegs(unsigned First, unsigned Last)
virtual void emitARMWinCFIEpilogStart(unsigned Condition)
virtual void emitPad(int64_t Offset)
void emitCurrentConstantPool()
Callback used to implement the .ltorg directive.
virtual void emitAttribute(unsigned Attribute, unsigned Value)
virtual void emitARMWinCFINop(bool Wide)
virtual void emitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset=0)
void emitConstantPools() override
virtual void emitArch(ARM::ArchKind Arch)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:202
Tagged union holding either a T or a Error.
Definition: Error.h:474
Generic interface to target specific assembler backends.
Definition: MCAsmBackend.h:43
Context object for machine code objects.
Definition: MCContext.h:76
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
Definition: MCInstPrinter.h:45
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
Streaming machine code generation interface.
Definition: MCStreamer.h:212
virtual void emitCFIGnuArgsSize(int64_t Size, SMLoc Loc={})
Definition: MCStreamer.cpp:638
virtual void emitNops(int64_t NumBytes, int64_t ControlledNopLength, SMLoc Loc, const MCSubtargetInfo &STI)
Definition: MCStreamer.cpp:226
virtual void emitAddrsig()
Definition: MCStreamer.h:1102
virtual void emitAssignment(MCSymbol *Symbol, const MCExpr *Value)
Emit an assignment of Value to Symbol.
virtual void emitCFIDefCfa(int64_t Register, int64_t Offset, SMLoc Loc={})
Definition: MCStreamer.cpp:496
virtual void addBlankLine()
Emit a blank line to a .s file to pretty it up.
Definition: MCStreamer.h:380
virtual void emitDwarfLineEndEntry(MCSection *Section, MCSymbol *LastLabel)
Emit the debug line end entry.
Definition: MCStreamer.h:1156
virtual void visitUsedSymbol(const MCSymbol &Sym)
void emitCFIStartProc(bool IsSimple, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:448
virtual bool emitCVFuncIdDirective(unsigned FunctionId)
Introduces a function id for use with .cv_loc.
Definition: MCStreamer.cpp:302
virtual void finishImpl()
Streamer specific finalization.
void assignFragment(MCSymbol *Symbol, MCFragment *Fragment)
Sets the symbol's section.
Definition: MCStreamer.cpp:415
virtual void emitDTPRel64Value(const MCExpr *Value)
Emit the expression Value into the output as a dtprel (64-bit DTP relative) value.
Definition: MCStreamer.cpp:195
virtual void emitCFIBKeyFrame()
Definition: MCStreamer.cpp:249
void generateCompactUnwindEncodings(MCAsmBackend *MAB)
Definition: MCStreamer.cpp:126
MCSectionSubPair getPreviousSection() const
Return the previous section that the streamer is emitting code to.
Definition: MCStreamer.h:396
virtual void beginCOFFSymbolDef(const MCSymbol *Symbol)
Start emitting COFF symbol definition.
virtual void emitSyntaxDirective()
Definition: MCStreamer.cpp:866
virtual void emitWinCFIPushReg(MCRegister Register, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:872
virtual void emitBinaryData(StringRef Data)
Functionally identical to EmitBytes.
virtual StringRef getMnemonic(MCInst &MI)
Returns the mnemonic for MI, if the streamer has access to a instruction printer and returns an empty...
Definition: MCStreamer.h:479
virtual void initSections(bool NoExecStack, const MCSubtargetInfo &STI)
Create the default sections and set the initial one.
Definition: MCStreamer.cpp:411
virtual MCSymbol * emitCFILabel()
When emitting an object file, create and emit a real label.
Definition: MCStreamer.cpp:490
virtual void emitWindowsUnwindTables()
MCStreamer(const MCStreamer &)=delete
virtual void emitGNUAttribute(unsigned Tag, unsigned Value)
Emit a .gnu_attribute directive.
Definition: MCStreamer.h:674
virtual raw_ostream & getCommentOS()
Return a raw_ostream that comments can be written to.
Definition: MCStreamer.cpp:111
virtual void emitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:791
virtual void emitBundleLock(bool AlignToEnd)
The following instructions are a bundle-locked group.
MCSection * getAssociatedPDataSection(const MCSection *TextSec)
Get the .pdata section used for the given section.
Definition: MCStreamer.cpp:854
unsigned getNumWinFrameInfos()
Definition: MCStreamer.h:324
bool hasUnfinishedDwarfFrameInfo()
Definition: MCStreamer.cpp:281
virtual ~MCStreamer()
void setStartTokLocPtr(const SMLoc *Loc)
Definition: MCStreamer.h:288
virtual void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI)
Emit the given Instruction into the current section.
virtual void emitGPRel64Value(const MCExpr *Value)
Emit the expression Value into the output as a gprel64 (64-bit GP relative) value.
Definition: MCStreamer.cpp:211
virtual void emitCFISameValue(int64_t Register, SMLoc Loc={})
Definition: MCStreamer.cpp:608
virtual bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute)=0
Add the given Attribute to Symbol.
virtual bool emitCVFileDirective(unsigned FileNo, StringRef Filename, ArrayRef< uint8_t > Checksum, unsigned ChecksumKind)
Associate a filename with a specified logical file number, and also specify that file's checksum info...
Definition: MCStreamer.cpp:295
virtual void emitCFIReturnColumn(int64_t Register)
Definition: MCStreamer.cpp:695
virtual void emitCOFFSymbolType(int Type)
Emit the type of the symbol.
virtual void emitCFIPersonality(const MCSymbol *Sym, unsigned Encoding)
Definition: MCStreamer.cpp:570
virtual void emitDwarfUnitLength(uint64_t Length, const Twine &Comment)
Emit a unit length field.
virtual void emitCFIWindowSave(SMLoc Loc={})
Definition: MCStreamer.cpp:676
virtual void emitCOFFSymbolIndex(MCSymbol const *Symbol)
Emits the symbol table index of a Symbol into the current section.
Definition: MCStreamer.cpp:981
virtual void emitCVStringTableDirective()
This implements the CodeView '.cv_stringtable' assembler directive.
Definition: MCStreamer.h:1008
virtual bool hasRawTextSupport() const
Return true if this asm streamer supports emitting unformatted text to the .s file with EmitRawText.
Definition: MCStreamer.h:340
unsigned getSymbolOrder(const MCSymbol *Sym) const
Returns an index to represent the order a symbol was emitted in.
Definition: MCStreamer.h:404
virtual void emitIntValueInHex(uint64_t Value, unsigned Size)
Special case of EmitValue that avoids the client having to pass in a MCExpr for constant integers & p...
Definition: MCStreamer.h:748
virtual void emitDwarfLocDirective(unsigned FileNo, unsigned Line, unsigned Column, unsigned Flags, unsigned Isa, unsigned Discriminator, StringRef FileName)
This implements the DWARF2 '.loc fileno lineno ...' assembler directive.
Definition: MCStreamer.cpp:263
virtual bool isVerboseAsm() const
Return true if this streamer supports verbose assembly and if it is enabled.
Definition: MCStreamer.h:336
virtual void emitCOFFImgRel32(MCSymbol const *Symbol, int64_t Offset)
Emits a COFF image relative relocation.
Definition: MCStreamer.cpp:987
virtual void endCOFFSymbolDef()
Marks the end of the symbol definition.
unsigned emitDwarfFileDirective(unsigned FileNo, StringRef Directory, StringRef Filename, std::optional< MD5::MD5Result > Checksum=std::nullopt, std::optional< StringRef > Source=std::nullopt, unsigned CUID=0)
Associate a filename with a specified logical file number.
Definition: MCStreamer.h:915
virtual void emitWinCFIPushFrame(bool Code, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:955
virtual void emitWinEHHandlerData(SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:808
virtual void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size, Align ByteAlignment)=0
Emit a common symbol.
virtual MCAssembler * getAssemblerPtr()
Definition: MCStreamer.h:299
virtual void emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo)
Emit the absolute difference between two symbols encoded with ULEB128.
virtual void emitXCOFFSymbolLinkageWithVisibility(MCSymbol *Symbol, MCSymbolAttr Linkage, MCSymbolAttr Visibility)
Emit a symbol's linkage and visibility with a linkage directive for XCOFF.
virtual void emitCFIUndefined(int64_t Register, SMLoc Loc={})
Definition: MCStreamer.cpp:655
void setTargetStreamer(MCTargetStreamer *TS)
Definition: MCStreamer.h:284
virtual bool isIntegratedAssemblerRequired() const
Is the integrated assembler required for this streamer to function correctly?
Definition: MCStreamer.h:344
virtual void emitWinCFISaveXMM(MCRegister Register, unsigned Offset, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:940
virtual void emitCFIStartProcImpl(MCDwarfFrameInfo &Frame)
Definition: MCStreamer.cpp:473
virtual void emitCVFileChecksumOffsetDirective(unsigned FileNo)
This implements the CodeView '.cv_filechecksumoffset' assembler directive.
Definition: MCStreamer.h:1015
bool getUseAssemblerInfoForParsing()
Definition: MCStreamer.h:302
virtual void emitCFINegateRAState(SMLoc Loc={})
Definition: MCStreamer.cpp:685
virtual void emitGPRel32Value(const MCExpr *Value)
Emit the expression Value into the output as a gprel32 (32-bit GP relative) value.
Definition: MCStreamer.cpp:215
virtual void emitCFILsda(const MCSymbol *Sym, unsigned Encoding)
Definition: MCStreamer.cpp:579
MCContext & getContext() const
Definition: MCStreamer.h:297
SMLoc getStartTokLoc() const
Definition: MCStreamer.h:289
virtual void emitBundleUnlock()
Ends a bundle-locked group.
virtual Expected< unsigned > tryEmitDwarfFileDirective(unsigned FileNo, StringRef Directory, StringRef Filename, std::optional< MD5::MD5Result > Checksum=std::nullopt, std::optional< StringRef > Source=std::nullopt, unsigned CUID=0)
Associate a filename with a specified logical file number.
Definition: MCStreamer.cpp:232
virtual void addExplicitComment(const Twine &T)
Add explicit comment T.
Definition: MCStreamer.cpp:123
virtual void AddComment(const Twine &T, bool EOL=true)
Add a textual comment.
Definition: MCStreamer.h:359
virtual void emitCVFPOData(const MCSymbol *ProcSym, SMLoc Loc={})
This implements the CodeView '.cv_fpo_data' assembler directive.
Definition: MCStreamer.h:1018
virtual void emitELFSize(MCSymbol *Symbol, const MCExpr *Value)
Emit an ELF .size directive.
virtual void emitXCOFFLocalCommonSymbol(MCSymbol *LabelSym, uint64_t Size, MCSymbol *CsectSym, Align Alignment)
Emits an lcomm directive with XCOFF csect information.
virtual void emitCFIMTETaggedFrame()
Definition: MCStreamer.cpp:256
virtual void emitTPRel32Value(const MCExpr *Value)
Emit the expression Value into the output as a tprel (32-bit TP relative) value.
Definition: MCStreamer.cpp:207
virtual void emitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset)
Emits a COFF section relative relocation.
Definition: MCStreamer.cpp:985
MCSection * getAssociatedXDataSection(const MCSection *TextSec)
Get the .xdata section used for the given section.
Definition: MCStreamer.cpp:860
virtual void doFinalizationAtSectionEnd(MCSection *Section)
Do finalization for the streamer at the end of a section.
Definition: MCStreamer.h:1167
virtual void emitRawComment(const Twine &T, bool TabPrefix=true)
Print T and prefix it with the comment string (normally #) and optionally a tab.
Definition: MCStreamer.cpp:121
virtual std::optional< std::pair< bool, std::string > > emitRelocDirective(const MCExpr &Offset, StringRef Name, const MCExpr *Expr, SMLoc Loc, const MCSubtargetInfo &STI)
Record a relocation described by the .reloc directive.
Definition: MCStreamer.h:1097
virtual void emitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:717
void emitValue(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:180
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
bool checkCVLocSection(unsigned FuncId, unsigned FileNo, SMLoc Loc)
Returns true if the .cv_loc directive is in the right section.
Definition: MCStreamer.cpp:325
virtual void emitIdent(StringRef IdentString)
Emit the "identifiers" directive.
Definition: MCStreamer.h:911
virtual void emitCVFileChecksumsDirective()
This implements the CodeView '.cv_filechecksums' assembler directive.
Definition: MCStreamer.h:1011
virtual void emitDwarfLineStartLabel(MCSymbol *StartSym)
Emit the debug line start label.
virtual void emitCFIEscape(StringRef Values, SMLoc Loc={})
Definition: MCStreamer.cpp:628
virtual void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Size)
Emit the absolute difference between two symbols.
virtual void emitXCOFFExceptDirective(const MCSymbol *Symbol, const MCSymbol *Trap, unsigned Lang, unsigned Reason, unsigned FunctionSize, bool hasDebug)
Emit an XCOFF .except directive which adds information about a trap instruction to the object file ex...
virtual void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc())
Emit a label for Symbol into the current section.
Definition: MCStreamer.cpp:424
virtual void emitCOFFSectionIndex(MCSymbol const *Symbol)
Emits a COFF section index.
Definition: MCStreamer.cpp:983
void switchSectionNoChange(MCSection *Section, const MCExpr *Subsection=nullptr)
Set the current section where code is being emitted to Section.
Definition: MCStreamer.h:457
void setAllowAutoPadding(bool v)
Definition: MCStreamer.h:308
virtual void emitCFIRememberState(SMLoc Loc)
Definition: MCStreamer.cpp:587
virtual void reset()
State management.
Definition: MCStreamer.cpp:102
virtual void emitCVLinetableDirective(unsigned FunctionId, const MCSymbol *FnStart, const MCSymbol *FnEnd)
This implements the CodeView '.cv_linetable' assembler directive.
Definition: MCStreamer.cpp:347
bool popSection()
Restore the current and previous section from the section stack.
Definition: MCStreamer.h:424
virtual void emitTPRel64Value(const MCExpr *Value)
Emit the expression Value into the output as a tprel (64-bit TP relative) value.
Definition: MCStreamer.cpp:203
virtual void emitCFISections(bool EH, bool Debug)
Definition: MCStreamer.cpp:446
MCTargetStreamer * getTargetStreamer()
Definition: MCStreamer.h:304
virtual void emitIntValueInHexWithPadding(uint64_t Value, unsigned Size)
Special case of EmitValue that avoids the client having to pass in a MCExpr for constant integers & p...
Definition: MCStreamer.h:760
virtual void emitAssemblerFlag(MCAssemblerFlag Flag)
Note in the output the specified Flag.
virtual void emitDarwinTargetVariantBuildVersion(unsigned Platform, unsigned Major, unsigned Minor, unsigned Update, VersionTuple SDKVersion)
Definition: MCStreamer.h:516
virtual bool mayHaveInstructions(MCSection &Sec) const
Definition: MCStreamer.h:1137
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.
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:134
unsigned getNumFrameInfos()
Definition: MCStreamer.cpp:116
virtual void emitWinCFISaveReg(MCRegister Register, unsigned Offset, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:923
virtual void emitWinCFIEndChained(SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:777
virtual void emitWinCFIEndProlog(SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:969
virtual void emitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel, const MCSymbol *Label, unsigned PointerSize)
If targets does not support representing debug line section by .loc/.file directives in assembly outp...
Definition: MCStreamer.h:1161
virtual void emitWinCFIEndProc(SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:735
void emitInt16(uint64_t Value)
Definition: MCStreamer.h:753
void emitVersionForTarget(const Triple &Target, const VersionTuple &SDKVersion, const Triple *DarwinTargetVariantTriple, const VersionTuple &DarwinTargetVariantSDKVersion)
virtual void emitCodeAlignment(Align Alignment, const MCSubtargetInfo *STI, unsigned MaxBytesToEmit=0)
Emit nops until the byte alignment ByteAlignment is reached.
virtual void emitCFIEndProcImpl(MCDwarfFrameInfo &CurFrame)
Definition: MCStreamer.cpp:484
virtual void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue)
Set the DescValue for the Symbol.
virtual void emitCFIDefCfaRegister(int64_t Register, SMLoc Loc={})
Definition: MCStreamer.cpp:527
virtual void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, Align ByteAlignment)
Emit a local common (.lcomm) symbol.
virtual MCSymbol * getDwarfLineTableSymbol(unsigned CUID)
Definition: MCStreamer.cpp:271
virtual void emitCFIRegister(int64_t Register1, int64_t Register2, SMLoc Loc={})
Definition: MCStreamer.cpp:665
virtual void emitCOFFSafeSEH(MCSymbol const *Symbol)
Definition: MCStreamer.cpp:979
virtual void emitWinCFIFuncletOrFuncEnd(SMLoc Loc=SMLoc())
This is used on platforms, such as Windows on ARM64, that require function or funclet sizes to be emi...
Definition: MCStreamer.cpp:753
virtual void changeSection(MCSection *, const MCExpr *)
Update streamer for a new active section.
virtual void emitXCOFFRenameDirective(const MCSymbol *Name, StringRef Rename)
Emit a XCOFF .rename directive which creates a synonym for an illegal or undesirable name.
void pushSection()
Save the current and previous section on the section stack.
Definition: MCStreamer.h:415
virtual void emitPseudoProbe(uint64_t Guid, uint64_t Index, uint64_t Type, uint64_t Attr, uint64_t Discriminator, const MCPseudoProbeInlineStack &InlineStack, MCSymbol *FnSym)
Emit the a pseudo probe into the current section.
void setUseAssemblerInfoForParsing(bool v)
Definition: MCStreamer.h:301
virtual void emitCGProfileEntry(const MCSymbolRefExpr *From, const MCSymbolRefExpr *To, uint64_t Count)
Definition: MCStreamer.cpp:816
virtual void emitDataRegion(MCDataRegionType Kind)
Note in the output the specified region Kind.
Definition: MCStreamer.h:503
virtual void emitCFIAdjustCfaOffset(int64_t Adjustment, SMLoc Loc={})
Definition: MCStreamer.cpp:517
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 emitULEB128Value(const MCExpr *Value)
ArrayRef< MCDwarfFrameInfo > getDwarfFrameInfos() const
Definition: MCStreamer.cpp:117
bool getAllowAutoPadding() const
Definition: MCStreamer.h:309
virtual void emitCFIRelOffset(int64_t Register, int64_t Offset, SMLoc Loc)
Definition: MCStreamer.cpp:560
virtual void emitLinkerOptions(ArrayRef< std::string > Kind)
Emit the given list Options of strings as linker options into the output.
Definition: MCStreamer.h:500
virtual void emitValueToOffset(const MCExpr *Offset, unsigned char Value, SMLoc Loc)
Emit some number of copies of Value until the byte offset Offset is reached.
void emitInt64(uint64_t Value)
Definition: MCStreamer.h:755
MCSymbol * endSection(MCSection *Section)
virtual void switchSection(MCSection *Section, const MCExpr *Subsection=nullptr)
Set the current section where code is being emitted to Section.
virtual void emitExplicitComments()
Emit added explicit comments.
Definition: MCStreamer.cpp:124
WinEH::FrameInfo * EnsureValidWinFrameInfo(SMLoc Loc)
Retrieve the current frame info if one is available and it is not yet closed.
Definition: MCStreamer.cpp:702
virtual void emitThumbFunc(MCSymbol *Func)
Note in the output that the specified Func is a Thumb mode function (ARM target only).
virtual void emitCFIRestoreState(SMLoc Loc)
Definition: MCStreamer.cpp:597
virtual void emitXCOFFRefDirective(const MCSymbol *Symbol)
Emit a XCOFF .ref directive which creates R_REF type entry in the relocation table for one or more sy...
virtual void emitEHSymAttributes(const MCSymbol *Symbol, MCSymbol *EHSymbol)
Definition: MCStreamer.cpp:407
virtual void emitCVDefRangeDirective(ArrayRef< std::pair< const MCSymbol *, const MCSymbol * > > Ranges, StringRef FixedSizePortion)
This implements the CodeView '.cv_def_range' assembler directive.
Definition: MCStreamer.cpp:369
void emitInt32(uint64_t Value)
Definition: MCStreamer.h:754
virtual void emitCFIOffset(int64_t Register, int64_t Offset, SMLoc Loc={})
Definition: MCStreamer.cpp:550
virtual void emitWinCFISetFrame(MCRegister Register, unsigned Offset, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:884
ArrayRef< std::unique_ptr< WinEH::FrameInfo > > getWinFrameInfos() const
Definition: MCStreamer.h:325
void maybeEmitDwarf64Mark()
Emit a special value of 0xffffffff if producing 64-bit debugging info.
virtual void emitDTPRel32Value(const MCExpr *Value)
Emit the expression Value into the output as a dtprel (32-bit DTP relative) value.
Definition: MCStreamer.cpp:199
virtual void emitCFIDefCfaOffset(int64_t Offset, SMLoc Loc={})
Definition: MCStreamer.cpp:507
virtual void emitZerofill(MCSection *Section, MCSymbol *Symbol=nullptr, uint64_t Size=0, Align ByteAlignment=Align(1), SMLoc Loc=SMLoc())=0
Emit the zerofill section and an optional symbol.
virtual void emitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line, unsigned Column, bool PrologueEnd, bool IsStmt, StringRef FileName, SMLoc Loc)
This implements the CodeView '.cv_loc' assembler directive.
Definition: MCStreamer.cpp:320
MCSectionSubPair getCurrentSection() const
Return the current section that the streamer is emitting code to.
Definition: MCStreamer.h:388
virtual void emitWinCFIAllocStack(unsigned Size, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:906
virtual void emitFileDirective(StringRef Filename)
Switch to a new logical file.
virtual void emitSLEB128Value(const MCExpr *Value)
virtual void emitELFSymverDirective(const MCSymbol *OriginalSym, StringRef Name, bool KeepOriginalSym)
Emit an ELF .symver directive.
virtual void emitXCOFFCInfoSym(StringRef Name, StringRef Metadata)
Emit a C_INFO symbol with XCOFF embedded metadata to the .info section.
MCSection * getCurrentSectionOnly() const
Definition: MCStreamer.h:393
virtual void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc())
Emit the expression Value into the output as a native integer of the given Size bytes.
void emitRawText(const Twine &String)
If this file is backed by a assembly streamer, this dumps the specified string in the output ....
bool subSection(const MCExpr *Subsection)
Definition: MCStreamer.h:439
MCStreamer & operator=(const MCStreamer &)=delete
void emitZeros(uint64_t NumBytes)
Emit NumBytes worth of zeros.
Definition: MCStreamer.cpp:230
virtual void emitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args)
Emit a Linker Optimization Hint (LOH) directive.
Definition: MCStreamer.h:671
unsigned emitSLEB128IntValue(int64_t Value)
Special case of EmitSLEB128Value that avoids the client having to pass in a MCExpr for constant integ...
Definition: MCStreamer.cpp:172
virtual bool emitCVInlineSiteIdDirective(unsigned FunctionId, unsigned IAFunc, unsigned IAFile, unsigned IALine, unsigned IACol, SMLoc Loc)
Introduces an inline call site id for use with .cv_loc.
Definition: MCStreamer.cpp:306
virtual void emitCFISignalFrame()
Definition: MCStreamer.cpp:648
virtual void emitVersionMin(MCVersionMinType Type, unsigned Major, unsigned Minor, unsigned Update, VersionTuple SDKVersion)
Specify the Mach-O minimum deployment target version.
Definition: MCStreamer.h:506
virtual void emitCOFFSymbolStorageClass(int StorageClass)
Emit the storage class of the symbol.
WinEH::FrameInfo * getCurrentWinFrameInfo()
Definition: MCStreamer.h:263
virtual void emitConditionalAssignment(MCSymbol *Symbol, const MCExpr *Value)
Emit an assignment of Value to Symbol, but only if Value is also emitted.
Definition: MCStreamer.cpp:443
void emitInt8(uint64_t Value)
Definition: MCStreamer.h:752
virtual void emitWinCFIStartChained(SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:764
virtual void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size, Align ByteAlignment=Align(1))
Emit a thread local bss (.tbss) symbol.
virtual void emitCFIRestore(int64_t Register, SMLoc Loc={})
Definition: MCStreamer.cpp:618
virtual void emitCVInlineLinetableDirective(unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum, const MCSymbol *FnStartSym, const MCSymbol *FnEndSym)
This implements the CodeView '.cv_inline_linetable' assembler directive.
Definition: MCStreamer.cpp:351
void emitFill(uint64_t NumBytes, uint8_t FillValue)
Emit NumBytes bytes worth of the value specified by FillValue.
Definition: MCStreamer.cpp:221
virtual void emitBundleAlignMode(Align Alignment)
Set the bundle alignment mode from now on in the section.
virtual void emitRawTextImpl(StringRef String)
EmitRawText - If this file is backed by an assembly streamer, this dumps the specified string in the ...
Definition: MCStreamer.cpp:992
virtual void emitBytes(StringRef Data)
Emit the bytes in Data into the output.
virtual void emitAddrsigSym(const MCSymbol *Sym)
Definition: MCStreamer.h:1103
void finish(SMLoc EndLoc=SMLoc())
Finish emission of machine code.
virtual void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol)
Emit an weak reference from Alias to Symbol.
void visitUsedExpr(const MCExpr &Expr)
virtual void emitDwarfFile0Directive(StringRef Directory, StringRef Filename, std::optional< MD5::MD5Result > Checksum, std::optional< StringRef > Source, unsigned CUID=0)
Specify the "root" file of the compilation, using the ".file 0" extension.
Definition: MCStreamer.cpp:240
virtual void emitBuildVersion(unsigned Platform, unsigned Major, unsigned Minor, unsigned Update, VersionTuple SDKVersion)
Emit/Specify Mach-O build version command.
Definition: MCStreamer.h:512
virtual void emitCFILLVMDefAspaceCfa(int64_t Register, int64_t Offset, int64_t AddressSpace, SMLoc Loc={})
Definition: MCStreamer.cpp:538
Generic base class for all target subtargets.
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:192
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
Target specific streamer interface.
Definition: MCStreamer.h:93
virtual void emitDwarfFileDirective(StringRef Directive)
Definition: MCStreamer.cpp:68
virtual void emitValue(const MCExpr *Value)
Definition: MCStreamer.cpp:72
virtual void prettyPrintAsm(MCInstPrinter &InstPrinter, uint64_t Address, const MCInst &Inst, const MCSubtargetInfo &STI, raw_ostream &OS)
virtual void finish()
Definition: MCStreamer.cpp:55
virtual void emitAssignment(MCSymbol *Symbol, const MCExpr *Value)
Definition: MCStreamer.cpp:92
MCStreamer & getStreamer()
Definition: MCStreamer.h:101
virtual void emitRawBytes(StringRef Data)
Emit the bytes in Data into the output.
Definition: MCStreamer.cpp:80
MCStreamer & Streamer
Definition: MCStreamer.h:95
virtual void emitLabel(MCSymbol *Symbol)
Definition: MCStreamer.cpp:53
virtual void changeSection(const MCSection *CurSection, MCSection *Section, const MCExpr *SubSection, raw_ostream &OS)
Update streamer for a new active section.
Definition: MCStreamer.cpp:59
virtual void emitConstantPools()
Definition: MCStreamer.cpp:57
Root of the metadata hierarchy.
Definition: Metadata.h:62
Represents a location in source code.
Definition: SMLoc.h:23
bool empty() const
Definition: SmallVector.h:94
size_t size() const
Definition: SmallVector.h:91
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StackOffset holds a fixed and a scalable offset in bytes.
Definition: TypeSize.h:33
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Target - Wrapper for Target specific information.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
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
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:29
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
This class represents a function that is read from a sample profile.
Definition: FunctionId.h:36
StorageClass
Definition: XCOFF.h:170
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
@ Length
Definition: DWP.cpp:456
AddressSpace
Definition: NVPTXBaseInfo.h:21
MCStreamer * createNullStreamer(MCContext &Ctx)
Create a dummy machine code streamer, which does nothing.
MCDataRegionType
Definition: MCDirectives.h:61
MCVersionMinType
Definition: MCDirectives.h:69
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
MCAssemblerFlag
Definition: MCDirectives.h:53
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Definition: Error.h:749
MCLOHType
Linker Optimization Hint Type.
std::pair< MCSection *, const MCExpr * > MCSectionSubPair
Definition: MCStreamer.h:66
MCSymbolAttr
Definition: MCDirectives.h:18
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39