LLVM 19.0.0git
AsmPrinter.h
Go to the documentation of this file.
1//===- llvm/CodeGen/AsmPrinter.h - AsmPrinter Framework ---------*- 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 contains a class to be used as the base class for target specific
10// asm writers. This class primarily handles common functionality used by
11// all asm writers.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CODEGEN_ASMPRINTER_H
16#define LLVM_CODEGEN_ASMPRINTER_H
17
18#include "llvm/ADT/DenseMap.h"
19#include "llvm/ADT/MapVector.h"
26#include "llvm/IR/InlineAsm.h"
28#include <cstdint>
29#include <memory>
30#include <utility>
31#include <vector>
32
33namespace llvm {
34
35class AddrLabelMap;
36class AsmPrinterHandler;
37class BasicBlock;
38class BlockAddress;
39class Constant;
40class ConstantArray;
41class ConstantPtrAuth;
42class DataLayout;
43class DebugHandlerBase;
44class DIE;
45class DIEAbbrev;
46class DwarfDebug;
47class GCMetadataPrinter;
48class GCStrategy;
49class GlobalAlias;
50class GlobalObject;
51class GlobalValue;
52class GlobalVariable;
53class MachineBasicBlock;
54class MachineConstantPoolValue;
55class MachineDominatorTree;
56class MachineFunction;
57class MachineInstr;
58class MachineJumpTableInfo;
59class MachineLoopInfo;
60class MachineModuleInfo;
61class MachineOptimizationRemarkEmitter;
62class MCAsmInfo;
63class MCCFIInstruction;
64class MCContext;
65class MCExpr;
66class MCInst;
67class MCSection;
68class MCStreamer;
69class MCSubtargetInfo;
70class MCSymbol;
71class MCTargetOptions;
72class MDNode;
73class Module;
74class PseudoProbeHandler;
75class raw_ostream;
76class StringRef;
77class TargetLoweringObjectFile;
78class TargetMachine;
79class Twine;
80
81namespace remarks {
82class RemarkStreamer;
83}
84
85/// This class is intended to be used as a driving class for all asm writers.
87public:
88 /// Target machine description.
90
91 /// Target Asm Printer information.
92 const MCAsmInfo *MAI = nullptr;
93
94 /// This is the context for the output file that we are streaming. This owns
95 /// all of the global MC-related objects for the generated translation unit.
97
98 /// This is the MCStreamer object for the file we are generating. This
99 /// contains the transient state for the current translation unit that we are
100 /// generating (such as the current section etc).
101 std::unique_ptr<MCStreamer> OutStreamer;
102
103 /// The current machine function.
104 MachineFunction *MF = nullptr;
105
106 /// This is a pointer to the current MachineModuleInfo.
108
109 /// This is a pointer to the current MachineDominatorTree.
111
112 /// This is a pointer to the current MachineLoopInfo.
114
115 /// Optimization remark emitter.
117
118 /// The symbol for the entry in __patchable_function_entires.
120
121 /// The symbol for the current function. This is recalculated at the beginning
122 /// of each call to runOnMachineFunction().
124
125 /// The symbol for the current function descriptor on AIX. This is created
126 /// at the beginning of each call to SetupMachineFunction().
128
129 /// The symbol used to represent the start of the current function for the
130 /// purpose of calculating its size (e.g. using the .size directive). By
131 /// default, this is equal to CurrentFnSym.
133
134 /// Map a basic block section ID to the begin and end symbols of that section
135 /// which determine the section's range.
138 };
139
141
142 /// Map global GOT equivalent MCSymbols to GlobalVariables and keep track of
143 /// its number of uses by other globals.
144 using GOTEquivUsePair = std::pair<const GlobalVariable *, unsigned>;
146
147 // Flags representing which CFI section is required for a function/module.
148 enum class CFISection : unsigned {
149 None = 0, ///< Do not emit either .eh_frame or .debug_frame
150 EH = 1, ///< Emit .eh_frame
151 Debug = 2 ///< Emit .debug_frame
152 };
153
154private:
155 MCSymbol *CurrentFnEnd = nullptr;
156
157 /// Map a basic block section ID to the exception symbol associated with that
158 /// section. Map entries are assigned and looked up via
159 /// AsmPrinter::getMBBExceptionSym.
160 DenseMap<MBBSectionID, MCSymbol *> MBBSectionExceptionSyms;
161
162 // The symbol used to represent the start of the current BB section of the
163 // function. This is used to calculate the size of the BB section.
164 MCSymbol *CurrentSectionBeginSym = nullptr;
165
166 /// This map keeps track of which symbol is being used for the specified basic
167 /// block's address of label.
168 std::unique_ptr<AddrLabelMap> AddrLabelSymbols;
169
170 /// The garbage collection metadata printer table.
172
173 /// Emit comments in assembly output if this is true.
174 bool VerboseAsm;
175
176 /// Output stream for the stack usage file (i.e., .su file).
177 std::unique_ptr<raw_fd_ostream> StackUsageStream;
178
179 /// List of symbols to be inserted into PC sections.
181
182 static char ID;
183
184protected:
186
187 /// For dso_local functions, the current $local alias for the function.
189
190 /// A vector of all debug/EH info emitters we should use. This vector
191 /// maintains ownership of the emitters.
193 size_t NumUserHandlers = 0;
194
195 /// Debuginfo handler. Protected so that targets can add their own.
198
200
201private:
202 /// If generated on the fly this own the instance.
203 std::unique_ptr<MachineDominatorTree> OwnedMDT;
204
205 /// If generated on the fly this own the instance.
206 std::unique_ptr<MachineLoopInfo> OwnedMLI;
207
208 /// If the target supports dwarf debug info, this pointer is non-null.
209 DwarfDebug *DD = nullptr;
210
211 /// A handler that supports pseudo probe emission with embedded inline
212 /// context.
213 std::unique_ptr<PseudoProbeHandler> PP;
214
215 /// CFISection type the module needs i.e. either .eh_frame or .debug_frame.
216 CFISection ModuleCFISection = CFISection::None;
217
218 /// True if the module contains split-stack functions. This is used to
219 /// emit .note.GNU-split-stack section as required by the linker for
220 /// special handling split-stack function calling no-split-stack function.
221 bool HasSplitStack = false;
222
223 /// True if the module contains no-split-stack functions. This is used to emit
224 /// .note.GNU-no-split-stack section when it also contains functions without a
225 /// split stack prologue.
226 bool HasNoSplitStack = false;
227
228protected:
229 explicit AsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer);
230
231public:
232 ~AsmPrinter() override;
233
234 DwarfDebug *getDwarfDebug() { return DD; }
235 DwarfDebug *getDwarfDebug() const { return DD; }
236
239
240 bool isDwarf64() const;
241
242 /// Returns 4 for DWARF32 and 8 for DWARF64.
243 unsigned int getDwarfOffsetByteSize() const;
244
245 /// Returns 4 for DWARF32 and 12 for DWARF64.
246 unsigned int getUnitLengthFieldByteSize() const;
247
248 /// Returns information about the byte size of DW_FORM values.
250
251 bool isPositionIndependent() const;
252
253 /// Return true if assembly output should contain comments.
254 bool isVerbose() const { return VerboseAsm; }
255
256 /// Return a unique ID for the current function.
257 unsigned getFunctionNumber() const;
258
259 /// Return symbol for the function pseudo stack if the stack frame is not a
260 /// register based.
261 virtual const MCSymbol *getFunctionFrameSymbol() const { return nullptr; }
262
264 MCSymbol *getFunctionEnd() const { return CurrentFnEnd; }
265
266 // Return the exception symbol associated with the MBB section containing a
267 // given basic block.
269
270 /// Return the symbol to be used for the specified basic block when its
271 /// address is taken. This cannot be its normal LBB label because the block
272 /// may be accessed outside its containing function.
274 return getAddrLabelSymbolToEmit(BB).front();
275 }
276
277 /// Return the symbol to be used for the specified basic block when its
278 /// address is taken. If other blocks were RAUW'd to this one, we may have
279 /// to emit them as well, return the whole set.
281
282 /// If the specified function has had any references to address-taken blocks
283 /// generated, but the block got deleted, return the symbol now so we can
284 /// emit it. This prevents emitting a reference to a symbol that has no
285 /// definition.
287 std::vector<MCSymbol *> &Result);
288
289 /// Return information about object file lowering.
291
292 /// Return information about data layout.
293 const DataLayout &getDataLayout() const;
294
295 /// Return the pointer size from the TargetMachine
296 unsigned getPointerSize() const;
297
298 /// Return information about subtarget.
299 const MCSubtargetInfo &getSubtargetInfo() const;
300
301 void EmitToStreamer(MCStreamer &S, const MCInst &Inst);
302
303 /// Emits inital debug location directive.
305
306 /// Return the current section we are emitting to.
307 const MCSection *getCurrentSection() const;
308
310 const GlobalValue *GV) const;
311
312 MCSymbol *getSymbol(const GlobalValue *GV) const;
313
314 /// Similar to getSymbol() but preferred for references. On ELF, this uses a
315 /// local symbol if a reference to GV is guaranteed to be resolved to the
316 /// definition in the same module.
317 MCSymbol *getSymbolPreferLocal(const GlobalValue &GV) const;
318
320 return DwarfUsesRelocationsAcrossSections;
321 }
322
324 DwarfUsesRelocationsAcrossSections = Enable;
325 }
326
327 //===------------------------------------------------------------------===//
328 // XRay instrumentation implementation.
329 //===------------------------------------------------------------------===//
330public:
331 // This describes the kind of sled we're storing in the XRay table.
332 enum class SledKind : uint8_t {
333 FUNCTION_ENTER = 0,
334 FUNCTION_EXIT = 1,
335 TAIL_CALL = 2,
336 LOG_ARGS_ENTER = 3,
337 CUSTOM_EVENT = 4,
338 TYPED_EVENT = 5,
339 };
340
341 // The table will contain these structs that point to the sled, the function
342 // containing the sled, and what kind of sled (and whether they should always
343 // be instrumented). We also use a version identifier that the runtime can use
344 // to decide what to do with the sled, depending on the version of the sled.
350 const class Function *Fn;
351 uint8_t Version;
352
353 void emit(int, MCStreamer *) const;
354 };
355
356 // All the sleds to be emitted.
358
359 // Helper function to record a given XRay sled.
360 void recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind,
361 uint8_t Version = 0);
362
363 /// Emit a table with all XRay instrumentation points.
364 void emitXRayTable();
365
367
368 //===------------------------------------------------------------------===//
369 // MachineFunctionPass Implementation.
370 //===------------------------------------------------------------------===//
371
372 /// Record analysis usage.
373 void getAnalysisUsage(AnalysisUsage &AU) const override;
374
375 /// Set up the AsmPrinter when we are working on a new module. If your pass
376 /// overrides this, it must make sure to explicitly call this implementation.
377 bool doInitialization(Module &M) override;
378
379 /// Shut down the asmprinter. If you override this in your pass, you must make
380 /// sure to call it explicitly.
381 bool doFinalization(Module &M) override;
382
383 /// Emit the specified function out to the OutStreamer.
387 return false;
388 }
389
390 //===------------------------------------------------------------------===//
391 // Coarse grained IR lowering routines.
392 //===------------------------------------------------------------------===//
393
394 /// This should be called when a new MachineFunction is being processed from
395 /// runOnMachineFunction.
397
398 /// This method emits the body and trailer for a function.
399 void emitFunctionBody();
400
402
403 void emitFrameAlloc(const MachineInstr &MI);
404
406
407 void emitStackUsage(const MachineFunction &MF);
408
410
411 void emitKCFITrapEntry(const MachineFunction &MF, const MCSymbol *Symbol);
412 virtual void emitKCFITypeId(const MachineFunction &MF);
413
414 void emitPseudoProbe(const MachineInstr &MI);
415
417
418 /// Emits a label as reference for PC sections.
419 void emitPCSectionsLabel(const MachineFunction &MF, const MDNode &MD);
420
421 /// Emits the PC sections collected from instructions.
422 void emitPCSections(const MachineFunction &MF);
423
424 /// Get the CFISection type for a function.
426
427 /// Get the CFISection type for a function.
429
430 /// Get the CFISection type for the module.
431 CFISection getModuleCFISectionType() const { return ModuleCFISection; }
432
433 bool needsSEHMoves();
434
435 /// Since emitting CFI unwind information is entangled with supporting the
436 /// exceptions, this returns true for platforms which use CFI unwind
437 /// information for other purposes (debugging, sanitizers, ...) when
438 /// `MCAsmInfo::ExceptionsType == ExceptionHandling::None`.
439 bool usesCFIWithoutEH() const;
440
441 /// Print to the current output stream assembly representations of the
442 /// constants in the constant pool MCP. This is used to print out constants
443 /// which have been "spilled to memory" by the code generator.
444 virtual void emitConstantPool();
445
446 /// Print assembly representations of the jump tables used by the current
447 /// function to the current output stream.
448 virtual void emitJumpTableInfo();
449
450 /// Emit the specified global variable to the .s file.
451 virtual void emitGlobalVariable(const GlobalVariable *GV);
452
453 /// Check to see if the specified global is a special global used by LLVM. If
454 /// so, emit it and return true, otherwise do nothing and return false.
456
457 /// `llvm.global_ctors` and `llvm.global_dtors` are arrays of Structor
458 /// structs.
459 ///
460 /// Priority - init priority
461 /// Func - global initialization or global clean-up function
462 /// ComdatKey - associated data
463 struct Structor {
464 int Priority = 0;
465 Constant *Func = nullptr;
467
468 Structor() = default;
469 };
470
471 /// This method gathers an array of Structors and then sorts them out by
472 /// Priority.
473 /// @param List The initializer of `llvm.global_ctors` or `llvm.global_dtors`
474 /// array.
475 /// @param[out] Structors Sorted Structor structs by Priority.
477 SmallVector<Structor, 8> &Structors);
478
479 /// This method emits `llvm.global_ctors` or `llvm.global_dtors` list.
480 virtual void emitXXStructorList(const DataLayout &DL, const Constant *List,
481 bool IsCtor);
482
483 /// Emit an alignment directive to the specified power of two boundary. If a
484 /// global value is specified, and if that global has an explicit alignment
485 /// requested, it will override the alignment request if required for
486 /// correctness.
487 void emitAlignment(Align Alignment, const GlobalObject *GV = nullptr,
488 unsigned MaxBytesToEmit = 0) const;
489
490 /// Lower the specified LLVM Constant to an MCExpr.
491 virtual const MCExpr *lowerConstant(const Constant *CV);
492
493 /// Print a general LLVM constant to the .s file.
494 /// On AIX, when an alias refers to a sub-element of a global variable, the
495 /// label of that alias needs to be emitted before the corresponding element.
497 void emitGlobalConstant(const DataLayout &DL, const Constant *CV,
498 AliasMapTy *AliasList = nullptr);
499
500 /// Unnamed constant global variables solely contaning a pointer to
501 /// another globals variable act like a global variable "proxy", or GOT
502 /// equivalents, i.e., it's only used to hold the address of the latter. One
503 /// optimization is to replace accesses to these proxies by using the GOT
504 /// entry for the final global instead. Hence, we select GOT equivalent
505 /// candidates among all the module global variables, avoid emitting them
506 /// unnecessarily and finally replace references to them by pc relative
507 /// accesses to GOT entries.
509
510 /// Constant expressions using GOT equivalent globals may not be
511 /// eligible for PC relative GOT entry conversion, in such cases we need to
512 /// emit the proxies we previously omitted in EmitGlobalVariable.
513 void emitGlobalGOTEquivs();
514
515 /// Emit the stack maps.
516 void emitStackMaps();
517
518 //===------------------------------------------------------------------===//
519 // Overridable Hooks
520 //===------------------------------------------------------------------===//
521
522 void addAsmPrinterHandler(std::unique_ptr<AsmPrinterHandler> Handler);
523
524 void addDebugHandler(std::unique_ptr<DebugHandlerBase> Handler);
525
526 // Targets can, or in the case of EmitInstruction, must implement these to
527 // customize output.
528
529 /// This virtual method can be overridden by targets that want to emit
530 /// something at the start of their file.
531 virtual void emitStartOfAsmFile(Module &) {}
532
533 /// This virtual method can be overridden by targets that want to emit
534 /// something at the end of their file.
535 virtual void emitEndOfAsmFile(Module &) {}
536
537 /// Targets can override this to emit stuff before the first basic block in
538 /// the function.
539 virtual void emitFunctionBodyStart() {}
540
541 /// Targets can override this to emit stuff after the last basic block in the
542 /// function.
543 virtual void emitFunctionBodyEnd() {}
544
545 /// Targets can override this to emit stuff at the start of a basic block.
546 /// By default, this method prints the label for the specified
547 /// MachineBasicBlock, an alignment (if present) and a comment describing it
548 /// if appropriate.
549 virtual void emitBasicBlockStart(const MachineBasicBlock &MBB);
550
551 /// Targets can override this to emit stuff at the end of a basic block.
552 virtual void emitBasicBlockEnd(const MachineBasicBlock &MBB);
553
554 /// Targets should implement this to emit instructions.
555 virtual void emitInstruction(const MachineInstr *) {
556 llvm_unreachable("EmitInstruction not implemented");
557 }
558
559 /// Return the symbol for the specified constant pool entry.
560 virtual MCSymbol *GetCPISymbol(unsigned CPID) const;
561
562 virtual void emitFunctionEntryLabel();
563
564 virtual void emitFunctionDescriptor() {
565 llvm_unreachable("Function descriptor is target-specific.");
566 }
567
569
570 /// Targets can override this to change how global constants that are part of
571 /// a C++ static/global constructor list are emitted.
572 virtual void emitXXStructor(const DataLayout &DL, const Constant *CV) {
574 }
575
576 virtual const MCExpr *lowerConstantPtrAuth(const ConstantPtrAuth &CPA) {
577 report_fatal_error("ptrauth constant lowering not implemented");
578 }
579
580 /// Return true if the basic block has exactly one predecessor and the control
581 /// transfer mechanism between the predecessor and this block is a
582 /// fall-through.
583 virtual bool
585
586 /// Targets can override this to customize the output of IMPLICIT_DEF
587 /// instructions in verbose mode.
588 virtual void emitImplicitDef(const MachineInstr *MI) const;
589
590 /// getSubtargetInfo() cannot be used where this is needed because we don't
591 /// have a MachineFunction when we're lowering a GlobalIFunc, and
592 /// getSubtargetInfo requires one. Override the implementation in targets
593 /// that support the Mach-O IFunc lowering.
595 return nullptr;
596 }
597
598 virtual void emitMachOIFuncStubBody(Module &M, const GlobalIFunc &GI,
599 MCSymbol *LazyPointer) {
601 "Mach-O IFunc lowering is not yet supported on this target");
602 }
603
605 MCSymbol *LazyPointer) {
607 "Mach-O IFunc lowering is not yet supported on this target");
608 }
609
610 /// Emit N NOP instructions.
611 void emitNops(unsigned N);
612
613 //===------------------------------------------------------------------===//
614 // Symbol Lowering Routines.
615 //===------------------------------------------------------------------===//
616
617 MCSymbol *createTempSymbol(const Twine &Name) const;
618
619 /// Return the MCSymbol for a private symbol with global value name as its
620 /// base, with the specified suffix.
622 StringRef Suffix) const;
623
624 /// Return the MCSymbol for the specified ExternalSymbol.
626
627 /// Return the symbol for the specified jump table entry.
628 MCSymbol *GetJTISymbol(unsigned JTID, bool isLinkerPrivate = false) const;
629
630 /// Return the symbol for the specified jump table .set
631 /// FIXME: privatize to AsmPrinter.
632 MCSymbol *GetJTSetSymbol(unsigned UID, unsigned MBBID) const;
633
634 /// Return the MCSymbol used to satisfy BlockAddress uses of the specified
635 /// basic block.
637 MCSymbol *GetBlockAddressSymbol(const BasicBlock *BB) const;
638
639 //===------------------------------------------------------------------===//
640 // Emission Helper Routines.
641 //===------------------------------------------------------------------===//
642
643 /// This is just convenient handler for printing offsets.
644 void printOffset(int64_t Offset, raw_ostream &OS) const;
645
646 /// Emit a byte directive and value.
647 void emitInt8(int Value) const;
648
649 /// Emit a short directive and value.
650 void emitInt16(int Value) const;
651
652 /// Emit a long directive and value.
653 void emitInt32(int Value) const;
654
655 /// Emit a long long directive and value.
656 void emitInt64(uint64_t Value) const;
657
658 /// Emit the specified signed leb128 value.
659 void emitSLEB128(int64_t Value, const char *Desc = nullptr) const;
660
661 /// Emit the specified unsigned leb128 value.
662 void emitULEB128(uint64_t Value, const char *Desc = nullptr,
663 unsigned PadTo = 0) const;
664
665 /// Emit something like ".long Hi-Lo" where the size in bytes of the directive
666 /// is specified by Size and Hi/Lo specify the labels. This implicitly uses
667 /// .set if it is available.
668 void emitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo,
669 unsigned Size) const;
670
671 /// Emit something like ".uleb128 Hi-Lo".
673 const MCSymbol *Lo) const;
674
675 /// Emit something like ".long Label+Offset" where the size in bytes of the
676 /// directive is specified by Size and Label specifies the label. This
677 /// implicitly uses .set if it is available.
678 void emitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset,
679 unsigned Size, bool IsSectionRelative = false) const;
680
681 /// Emit something like ".long Label" where the size in bytes of the directive
682 /// is specified by Size and Label specifies the label.
683 void emitLabelReference(const MCSymbol *Label, unsigned Size,
684 bool IsSectionRelative = false) const {
685 emitLabelPlusOffset(Label, 0, Size, IsSectionRelative);
686 }
687
688 //===------------------------------------------------------------------===//
689 // Dwarf Emission Helper Routines
690 //===------------------------------------------------------------------===//
691
692 /// Emit a .byte 42 directive that corresponds to an encoding. If verbose
693 /// assembly output is enabled, we output comments describing the encoding.
694 /// Desc is a string saying what the encoding is specifying (e.g. "LSDA").
695 void emitEncodingByte(unsigned Val, const char *Desc = nullptr) const;
696
697 /// Return the size of the encoding in bytes.
698 unsigned GetSizeOfEncodedValue(unsigned Encoding) const;
699
700 /// Emit reference to a ttype global with a specified encoding.
701 virtual void emitTTypeReference(const GlobalValue *GV, unsigned Encoding);
702
703 /// Emit a reference to a symbol for use in dwarf. Different object formats
704 /// represent this in different ways. Some use a relocation others encode
705 /// the label offset in its section.
706 void emitDwarfSymbolReference(const MCSymbol *Label,
707 bool ForceOffset = false) const;
708
709 /// Emit the 4- or 8-byte offset of a string from the start of its section.
710 ///
711 /// When possible, emit a DwarfStringPool section offset without any
712 /// relocations, and without using the symbol. Otherwise, defers to \a
713 /// emitDwarfSymbolReference().
714 ///
715 /// The length of the emitted value depends on the DWARF format.
717
718 /// Emit the 4-or 8-byte offset of a string from the start of its section.
721 }
722
723 /// Emit something like ".long Label + Offset" or ".quad Label + Offset"
724 /// depending on the DWARF format.
725 void emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const;
726
727 /// Emit 32- or 64-bit value depending on the DWARF format.
729
730 /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen
731 /// according to the settings.
732 void emitDwarfUnitLength(uint64_t Length, const Twine &Comment) const;
733
734 /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen
735 /// according to the settings.
736 /// Return the end symbol generated inside, the caller needs to emit it.
737 MCSymbol *emitDwarfUnitLength(const Twine &Prefix,
738 const Twine &Comment) const;
739
740 /// Emit reference to a call site with a specified encoding
741 void emitCallSiteOffset(const MCSymbol *Hi, const MCSymbol *Lo,
742 unsigned Encoding) const;
743 /// Emit an integer value corresponding to the call site encoding
744 void emitCallSiteValue(uint64_t Value, unsigned Encoding) const;
745
746 /// Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
747 virtual unsigned getISAEncoding() { return 0; }
748
749 /// Emit the directive and value for debug thread local expression
750 ///
751 /// \p Value - The value to emit.
752 /// \p Size - The size of the integer (in bytes) to emit.
753 virtual void emitDebugValue(const MCExpr *Value, unsigned Size) const;
754
755 //===------------------------------------------------------------------===//
756 // Dwarf Lowering Routines
757 //===------------------------------------------------------------------===//
758
759 /// Emit frame instruction to describe the layout of the frame.
760 void emitCFIInstruction(const MCCFIInstruction &Inst) const;
761
762 /// Emit Dwarf abbreviation table.
763 template <typename T> void emitDwarfAbbrevs(const T &Abbrevs) const {
764 // For each abbreviation.
765 for (const auto &Abbrev : Abbrevs)
766 emitDwarfAbbrev(*Abbrev);
767
768 // Mark end of abbreviations.
769 emitULEB128(0, "EOM(3)");
770 }
771
772 void emitDwarfAbbrev(const DIEAbbrev &Abbrev) const;
773
774 /// Recursively emit Dwarf DIE tree.
775 void emitDwarfDIE(const DIE &Die) const;
776
777 //===------------------------------------------------------------------===//
778 // CodeView Helper Routines
779 //===------------------------------------------------------------------===//
780
781 /// Gets information required to create a CodeView debug symbol for a jump
782 /// table.
783 /// Return value is <Base Address, Base Offset, Branch Address, Entry Size>
784 virtual std::tuple<const MCSymbol *, uint64_t, const MCSymbol *,
786 getCodeViewJumpTableInfo(int JTI, const MachineInstr *BranchInstr,
787 const MCSymbol *BranchLabel) const;
788
789 //===------------------------------------------------------------------===//
790 // Inline Asm Support
791 //===------------------------------------------------------------------===//
792
793 // These are hooks that targets can override to implement inline asm
794 // support. These should probably be moved out of AsmPrinter someday.
795
796 /// Print information related to the specified machine instr that is
797 /// independent of the operand, and may be independent of the instr itself.
798 /// This can be useful for portably encoding the comment character or other
799 /// bits of target-specific knowledge into the asmstrings. The syntax used is
800 /// ${:comment}. Targets can override this to add support for their own
801 /// strange codes.
802 virtual void PrintSpecial(const MachineInstr *MI, raw_ostream &OS,
803 StringRef Code) const;
804
805 /// Print the MachineOperand as a symbol. Targets with complex handling of
806 /// symbol references should override the base implementation.
807 virtual void PrintSymbolOperand(const MachineOperand &MO, raw_ostream &OS);
808
809 /// Print the specified operand of MI, an INLINEASM instruction, using the
810 /// specified assembler variant. Targets should override this to format as
811 /// appropriate. This method can return true if the operand is erroneous.
812 virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
813 const char *ExtraCode, raw_ostream &OS);
814
815 /// Print the specified operand of MI, an INLINEASM instruction, using the
816 /// specified assembler variant as an address. Targets should override this to
817 /// format as appropriate. This method can return true if the operand is
818 /// erroneous.
819 virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
820 const char *ExtraCode, raw_ostream &OS);
821
822 /// Let the target do anything it needs to do before emitting inlineasm.
823 /// \p StartInfo - the subtarget info before parsing inline asm
824 virtual void emitInlineAsmStart() const;
825
826 /// Let the target do anything it needs to do after emitting inlineasm.
827 /// This callback can be used restore the original mode in case the
828 /// inlineasm contains directives to switch modes.
829 /// \p StartInfo - the original subtarget info before inline asm
830 /// \p EndInfo - the final subtarget info after parsing the inline asm,
831 /// or NULL if the value is unknown.
832 virtual void emitInlineAsmEnd(const MCSubtargetInfo &StartInfo,
833 const MCSubtargetInfo *EndInfo) const;
834
835 /// This emits visibility information about symbol, if this is supported by
836 /// the target.
837 void emitVisibility(MCSymbol *Sym, unsigned Visibility,
838 bool IsDefinition = true) const;
839
840 /// This emits linkage information about \p GVSym based on \p GV, if this is
841 /// supported by the target.
842 virtual void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const;
843
844 /// Return the alignment for the specified \p GV.
845 static Align getGVAlignment(const GlobalObject *GV, const DataLayout &DL,
846 Align InAlign = Align(1));
847
848private:
849 /// Private state for PrintSpecial()
850 // Assign a unique ID to this machine instruction.
851 mutable const MachineInstr *LastMI = nullptr;
852 mutable unsigned LastFn = 0;
853 mutable unsigned Counter = ~0U;
854
855 bool DwarfUsesRelocationsAcrossSections = false;
856
857 /// This method emits the header for the current function.
858 virtual void emitFunctionHeader();
859
860 /// This method emits a comment next to header for the current function.
861 virtual void emitFunctionHeaderComment();
862
863 /// This method emits prefix-like data before the current function.
864 void emitFunctionPrefix(ArrayRef<const Constant *> Prefix);
865
866 /// Emit a blob of inline asm to the output streamer.
867 void
868 emitInlineAsm(StringRef Str, const MCSubtargetInfo &STI,
869 const MCTargetOptions &MCOptions,
870 const MDNode *LocMDNode = nullptr,
871 InlineAsm::AsmDialect AsmDialect = InlineAsm::AD_ATT) const;
872
873 /// This method formats and emits the specified machine instruction that is an
874 /// inline asm.
875 void emitInlineAsm(const MachineInstr *MI) const;
876
877 /// Add inline assembly info to the diagnostics machinery, so we can
878 /// emit file and position info. Returns SrcMgr memory buffer position.
879 unsigned addInlineAsmDiagBuffer(StringRef AsmStr,
880 const MDNode *LocMDNode) const;
881
882 //===------------------------------------------------------------------===//
883 // Internal Implementation Details
884 //===------------------------------------------------------------------===//
885
886 void emitJumpTableEntry(const MachineJumpTableInfo *MJTI,
887 const MachineBasicBlock *MBB, unsigned uid) const;
888 void emitLLVMUsedList(const ConstantArray *InitList);
889 /// Emit llvm.ident metadata in an '.ident' directive.
890 void emitModuleIdents(Module &M);
891 /// Emit bytes for llvm.commandline metadata.
892 virtual void emitModuleCommandLines(Module &M);
893
894 GCMetadataPrinter *getOrCreateGCPrinter(GCStrategy &S);
895 virtual void emitGlobalAlias(const Module &M, const GlobalAlias &GA);
896 void emitGlobalIFunc(Module &M, const GlobalIFunc &GI);
897
898private:
899 /// This method decides whether the specified basic block requires a label.
900 bool shouldEmitLabelForBasicBlock(const MachineBasicBlock &MBB) const;
901
902protected:
904 return false;
905 }
906};
907
908} // end namespace llvm
909
910#endif // LLVM_CODEGEN_ASMPRINTER_H
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
dxil metadata emit
This file defines the DenseMap class.
This file contains constants used for implementing Dwarf debug support.
std::string Name
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
IRTranslator LLVM IR MI
#define F(x, y, z)
Definition: MD5.cpp:55
Machine Check Debug Module
This file implements a map that provides insertion order iteration.
raw_pwrite_stream & OS
This file defines the SmallVector class.
Represent the analysis usage information of a pass.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:86
virtual void emitInlineAsmEnd(const MCSubtargetInfo &StartInfo, const MCSubtargetInfo *EndInfo) const
Let the target do anything it needs to do after emitting inlineasm.
virtual void emitInstruction(const MachineInstr *)
Targets should implement this to emit instructions.
Definition: AsmPrinter.h:555
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:383
MCSymbol * getSymbolWithGlobalValueBase(const GlobalValue *GV, StringRef Suffix) const
Return the MCSymbol for a private symbol with global value name as its base, with the specified suffi...
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:676
void emitULEB128(uint64_t Value, const char *Desc=nullptr, unsigned PadTo=0) const
Emit the specified unsigned leb128 value.
SmallVector< XRayFunctionEntry, 4 > Sleds
Definition: AsmPrinter.h:357
void emitDwarfSymbolReference(const MCSymbol *Label, bool ForceOffset=false) const
Emit a reference to a symbol for use in dwarf.
MapVector< MBBSectionID, MBBSectionRange > MBBSectionRanges
Definition: AsmPrinter.h:140
bool isDwarf64() const
CFISection getModuleCFISectionType() const
Get the CFISection type for the module.
Definition: AsmPrinter.h:431
void emitNops(unsigned N)
Emit N NOP instructions.
MCSymbol * CurrentFnBegin
Definition: AsmPrinter.h:185
unsigned GetSizeOfEncodedValue(unsigned Encoding) const
Return the size of the encoding in bytes.
MachineLoopInfo * MLI
This is a pointer to the current MachineLoopInfo.
Definition: AsmPrinter.h:113
virtual void emitDebugValue(const MCExpr *Value, unsigned Size) const
Emit the directive and value for debug thread local expression.
Definition: AsmPrinter.cpp:896
void EmitToStreamer(MCStreamer &S, const MCInst &Inst)
Definition: AsmPrinter.cpp:403
virtual void emitConstantPool()
Print to the current output stream assembly representations of the constants in the constant pool MCP...
void emitDwarfDIE(const DIE &Die) const
Recursively emit Dwarf DIE tree.
DwarfDebug * getDwarfDebug()
Definition: AsmPrinter.h:234
virtual void emitGlobalVariable(const GlobalVariable *GV)
Emit the specified global variable to the .s file.
Definition: AsmPrinter.cpp:698
virtual const MCExpr * lowerConstantPtrAuth(const ConstantPtrAuth &CPA)
Definition: AsmPrinter.h:576
void emitDwarfLengthOrOffset(uint64_t Value) const
Emit 32- or 64-bit value depending on the DWARF format.
unsigned int getUnitLengthFieldByteSize() const
Returns 4 for DWARF32 and 12 for DWARF64.
void emitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset, unsigned Size, bool IsSectionRelative=false) const
Emit something like ".long Label+Offset" where the size in bytes of the directive is specified by Siz...
~AsmPrinter() override
Definition: AsmPrinter.cpp:369
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:89
void emitXRayTable()
Emit a table with all XRay instrumentation points.
virtual void emitBasicBlockEnd(const MachineBasicBlock &MBB)
Targets can override this to emit stuff at the end of a basic block.
DwarfDebug * getDwarfDebug() const
Definition: AsmPrinter.h:235
MCSymbol * CurrentFnDescSym
The symbol for the current function descriptor on AIX.
Definition: AsmPrinter.h:127
MCSymbol * CurrentFnBeginLocal
For dso_local functions, the current $local alias for the function.
Definition: AsmPrinter.h:188
MapVector< const MCSymbol *, GOTEquivUsePair > GlobalGOTEquivs
Definition: AsmPrinter.h:145
void emitDwarfStringOffset(DwarfStringPoolEntry S) const
Emit the 4- or 8-byte offset of a string from the start of its section.
virtual MCSymbol * GetCPISymbol(unsigned CPID) const
Return the symbol for the specified constant pool entry.
void emitGlobalGOTEquivs()
Constant expressions using GOT equivalent globals may not be eligible for PC relative GOT entry conve...
virtual void PrintSymbolOperand(const MachineOperand &MO, raw_ostream &OS)
Print the MachineOperand as a symbol.
MCSymbol * getFunctionBegin() const
Definition: AsmPrinter.h:263
void emitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Size) const
Emit something like ".long Hi-Lo" where the size in bytes of the directive is specified by Size and H...
void emitKCFITrapEntry(const MachineFunction &MF, const MCSymbol *Symbol)
virtual void emitMachOIFuncStubHelperBody(Module &M, const GlobalIFunc &GI, MCSymbol *LazyPointer)
Definition: AsmPrinter.h:604
MCSymbol * getMBBExceptionSym(const MachineBasicBlock &MBB)
MCSymbol * getAddrLabelSymbol(const BasicBlock *BB)
Return the symbol to be used for the specified basic block when its address is taken.
Definition: AsmPrinter.h:273
virtual void emitTTypeReference(const GlobalValue *GV, unsigned Encoding)
Emit reference to a ttype global with a specified encoding.
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:92
SmallVector< std::unique_ptr< AsmPrinterHandler >, 2 > Handlers
A vector of all debug/EH info emitters we should use.
Definition: AsmPrinter.h:192
bool emitSpecialLLVMGlobal(const GlobalVariable *GV)
Check to see if the specified global is a special global used by LLVM.
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:104
void emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const
Emit something like ".long Label + Offset" or ".quad Label + Offset" depending on the DWARF format.
virtual void PrintSpecial(const MachineInstr *MI, raw_ostream &OS, StringRef Code) const
Print information related to the specified machine instr that is independent of the operand,...
virtual void emitJumpTableInfo()
Print assembly representations of the jump tables used by the current function to the current output ...
void computeGlobalGOTEquivs(Module &M)
Unnamed constant global variables solely contaning a pointer to another globals variable act like a g...
static Align getGVAlignment(const GlobalObject *GV, const DataLayout &DL, Align InAlign=Align(1))
Return the alignment for the specified GV.
Definition: AsmPrinter.cpp:336
void emitInt8(int Value) const
Emit a byte directive and value.
CFISection getFunctionCFISectionType(const Function &F) const
Get the CFISection type for a function.
void addDebugHandler(std::unique_ptr< DebugHandlerBase > Handler)
virtual void SetupMachineFunction(MachineFunction &MF)
This should be called when a new MachineFunction is being processed from runOnMachineFunction.
void emitFunctionBody()
This method emits the body and trailer for a function.
virtual bool isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const
Return true if the basic block has exactly one predecessor and the control transfer mechanism between...
size_t NumUserDebugHandlers
Definition: AsmPrinter.h:197
void emitBBAddrMapSection(const MachineFunction &MF)
void emitPCSections(const MachineFunction &MF)
Emits the PC sections collected from instructions.
MachineDominatorTree * MDT
This is a pointer to the current MachineDominatorTree.
Definition: AsmPrinter.h:110
virtual void emitStartOfAsmFile(Module &)
This virtual method can be overridden by targets that want to emit something at the start of their fi...
Definition: AsmPrinter.h:531
MCSymbol * GetJTISymbol(unsigned JTID, bool isLinkerPrivate=false) const
Return the symbol for the specified jump table entry.
virtual void emitMachineConstantPoolValue(MachineConstantPoolValue *MCPV)
SmallVector< std::unique_ptr< DebugHandlerBase >, 1 > DebugHandlers
Debuginfo handler. Protected so that targets can add their own.
Definition: AsmPrinter.h:196
void emitStackMaps()
Emit the stack maps.
void emitDwarfUnitLength(uint64_t Length, const Twine &Comment) const
Emit a unit length field.
virtual void emitFunctionBodyStart()
Targets can override this to emit stuff before the first basic block in the function.
Definition: AsmPrinter.h:539
std::pair< const GlobalVariable *, unsigned > GOTEquivUsePair
Map global GOT equivalent MCSymbols to GlobalVariables and keep track of its number of uses by other ...
Definition: AsmPrinter.h:144
void emitPatchableFunctionEntries()
void recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind, uint8_t Version=0)
virtual void emitEndOfAsmFile(Module &)
This virtual method can be overridden by targets that want to emit something at the end of their file...
Definition: AsmPrinter.h:535
bool doInitialization(Module &M) override
Set up the AsmPrinter when we are working on a new module.
Definition: AsmPrinter.cpp:434
MCSymbol * GetJTSetSymbol(unsigned UID, unsigned MBBID) const
Return the symbol for the specified jump table .set FIXME: privatize to AsmPrinter.
virtual void emitMachOIFuncStubBody(Module &M, const GlobalIFunc &GI, MCSymbol *LazyPointer)
Definition: AsmPrinter.h:598
void emitEncodingByte(unsigned Val, const char *Desc=nullptr) const
Emit a .byte 42 directive that corresponds to an encoding.
virtual void emitImplicitDef(const MachineInstr *MI) const
Targets can override this to customize the output of IMPLICIT_DEF instructions in verbose mode.
virtual void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const
This emits linkage information about GVSym based on GV, if this is supported by the target.
Definition: AsmPrinter.cpp:631
void getAnalysisUsage(AnalysisUsage &AU) const override
Record analysis usage.
Definition: AsmPrinter.cpp:425
unsigned getFunctionNumber() const
Return a unique ID for the current function.
Definition: AsmPrinter.cpp:379
MachineOptimizationRemarkEmitter * ORE
Optimization remark emitter.
Definition: AsmPrinter.h:116
virtual bool shouldEmitWeakSwiftAsyncExtendedFramePointerFlags() const
Definition: AsmPrinter.h:903
void printOffset(int64_t Offset, raw_ostream &OS) const
This is just convenient handler for printing offsets.
void emitGlobalConstant(const DataLayout &DL, const Constant *CV, AliasMapTy *AliasList=nullptr)
EmitGlobalConstant - Print a general LLVM constant to the .s file.
virtual const MCSymbol * getFunctionFrameSymbol() const
Return symbol for the function pseudo stack if the stack frame is not a register based.
Definition: AsmPrinter.h:261
void emitFrameAlloc(const MachineInstr &MI)
void emitDwarfStringOffset(DwarfStringPoolEntryRef S) const
Emit the 4-or 8-byte offset of a string from the start of its section.
Definition: AsmPrinter.h:719
void emitStackSizeSection(const MachineFunction &MF)
MCSymbol * getSymbolPreferLocal(const GlobalValue &GV) const
Similar to getSymbol() but preferred for references.
Definition: AsmPrinter.cpp:680
MCSymbol * CurrentFnSym
The symbol for the current function.
Definition: AsmPrinter.h:123
MachineModuleInfo * MMI
This is a pointer to the current MachineModuleInfo.
Definition: AsmPrinter.h:107
void emitDwarfAbbrevs(const T &Abbrevs) const
Emit Dwarf abbreviation table.
Definition: AsmPrinter.h:763
void emitSLEB128(int64_t Value, const char *Desc=nullptr) const
Emit the specified signed leb128 value.
void emitAlignment(Align Alignment, const GlobalObject *GV=nullptr, unsigned MaxBytesToEmit=0) const
Emit an alignment directive to the specified power of two boundary.
MCContext & OutContext
This is the context for the output file that we are streaming.
Definition: AsmPrinter.h:96
void emitCFIInstruction(const MachineInstr &MI)
MCSymbol * createTempSymbol(const Twine &Name) const
bool doFinalization(Module &M) override
Shut down the asmprinter.
MCSymbol * GetExternalSymbolSymbol(Twine Sym) const
Return the MCSymbol for the specified ExternalSymbol.
virtual const MCSubtargetInfo * getIFuncMCSubtargetInfo() const
getSubtargetInfo() cannot be used where this is needed because we don't have a MachineFunction when w...
Definition: AsmPrinter.h:594
void emitStackUsage(const MachineFunction &MF)
virtual void emitKCFITypeId(const MachineFunction &MF)
bool isPositionIndependent() const
Definition: AsmPrinter.cpp:374
virtual void emitXXStructorList(const DataLayout &DL, const Constant *List, bool IsCtor)
This method emits llvm.global_ctors or llvm.global_dtors list.
void emitPCSectionsLabel(const MachineFunction &MF, const MDNode &MD)
Emits a label as reference for PC sections.
void emitCallSiteOffset(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Encoding) const
Emit reference to a call site with a specified encoding.
MCSymbol * CurrentPatchableFunctionEntrySym
The symbol for the entry in __patchable_function_entires.
Definition: AsmPrinter.h:119
virtual void emitBasicBlockStart(const MachineBasicBlock &MBB)
Targets can override this to emit stuff at the start of a basic block.
void takeDeletedSymbolsForFunction(const Function *F, std::vector< MCSymbol * > &Result)
If the specified function has had any references to address-taken blocks generated,...
Definition: AsmPrinter.cpp:269
void emitVisibility(MCSymbol *Sym, unsigned Visibility, bool IsDefinition=true) const
This emits visibility information about symbol, if this is supported by the target.
bool runOnMachineFunction(MachineFunction &MF) override
Emit the specified function out to the OutStreamer.
Definition: AsmPrinter.h:384
void emitDwarfAbbrev(const DIEAbbrev &Abbrev) const
void setDwarfUsesRelocationsAcrossSections(bool Enable)
Definition: AsmPrinter.h:323
void emitInt32(int Value) const
Emit a long directive and value.
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:101
virtual const MCExpr * lowerConstant(const Constant *CV)
Lower the specified LLVM Constant to an MCExpr.
void emitLabelReference(const MCSymbol *Label, unsigned Size, bool IsSectionRelative=false) const
Emit something like ".long Label" where the size in bytes of the directive is specified by Size and L...
Definition: AsmPrinter.h:683
virtual void emitFunctionDescriptor()
Definition: AsmPrinter.h:564
const MCSection * getCurrentSection() const
Return the current section we are emitting to.
Definition: AsmPrinter.cpp:421
unsigned int getDwarfOffsetByteSize() const
Returns 4 for DWARF32 and 8 for DWARF64.
virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS)
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant as...
size_t NumUserHandlers
Definition: AsmPrinter.h:193
MCSymbol * CurrentFnSymForSize
The symbol used to represent the start of the current function for the purpose of calculating its siz...
Definition: AsmPrinter.h:132
virtual unsigned getISAEncoding()
Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
Definition: AsmPrinter.h:747
bool isVerbose() const
Return true if assembly output should contain comments.
Definition: AsmPrinter.h:254
MCSymbol * getFunctionEnd() const
Definition: AsmPrinter.h:264
virtual void emitXXStructor(const DataLayout &DL, const Constant *CV)
Targets can override this to change how global constants that are part of a C++ static/global constru...
Definition: AsmPrinter.h:572
void preprocessXXStructorList(const DataLayout &DL, const Constant *List, SmallVector< Structor, 8 > &Structors)
This method gathers an array of Structors and then sorts them out by Priority.
void emitInt16(int Value) const
Emit a short directive and value.
void setDwarfVersion(uint16_t Version)
void getNameWithPrefix(SmallVectorImpl< char > &Name, const GlobalValue *GV) const
Definition: AsmPrinter.cpp:671
void emitPseudoProbe(const MachineInstr &MI)
unsigned getPointerSize() const
Return the pointer size from the TargetMachine.
Definition: AsmPrinter.cpp:394
void emitRemarksSection(remarks::RemarkStreamer &RS)
StackMaps SM
Definition: AsmPrinter.h:199
MCSymbol * GetBlockAddressSymbol(const BlockAddress *BA) const
Return the MCSymbol used to satisfy BlockAddress uses of the specified basic block.
ArrayRef< MCSymbol * > getAddrLabelSymbolToEmit(const BasicBlock *BB)
Return the symbol to be used for the specified basic block when its address is taken.
Definition: AsmPrinter.cpp:261
virtual void emitFunctionBodyEnd()
Targets can override this to emit stuff after the last basic block in the function.
Definition: AsmPrinter.h:543
const DataLayout & getDataLayout() const
Return information about data layout.
Definition: AsmPrinter.cpp:387
virtual void emitFunctionEntryLabel()
EmitFunctionEntryLabel - Emit the label that is the entrypoint for the function.
void emitInitialRawDwarfLocDirective(const MachineFunction &MF)
Emits inital debug location directive.
Definition: AsmPrinter.cpp:407
void emitInt64(uint64_t Value) const
Emit a long long directive and value.
uint16_t getDwarfVersion() const
dwarf::FormParams getDwarfFormParams() const
Returns information about the byte size of DW_FORM values.
const MCSubtargetInfo & getSubtargetInfo() const
Return information about subtarget.
Definition: AsmPrinter.cpp:398
bool usesCFIWithoutEH() const
Since emitting CFI unwind information is entangled with supporting the exceptions,...
bool doesDwarfUseRelocationsAcrossSections() const
Definition: AsmPrinter.h:319
virtual void emitInlineAsmStart() const
Let the target do anything it needs to do before emitting inlineasm.
@ None
Do not emit either .eh_frame or .debug_frame.
@ Debug
Emit .debug_frame.
void addAsmPrinterHandler(std::unique_ptr< AsmPrinterHandler > Handler)
virtual std::tuple< const MCSymbol *, uint64_t, const MCSymbol *, codeview::JumpTableEntrySize > getCodeViewJumpTableInfo(int JTI, const MachineInstr *BranchInstr, const MCSymbol *BranchLabel) const
Gets information required to create a CodeView debug symbol for a jump table.
virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS)
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant.
void emitCallSiteValue(uint64_t Value, unsigned Encoding) const
Emit an integer value corresponding to the call site encoding.
void emitLabelDifferenceAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo) const
Emit something like ".uleb128 Hi-Lo".
LLVM Basic Block Representation.
Definition: BasicBlock.h:61
The address of a basic block.
Definition: Constants.h:890
ConstantArray - Constant Array Declarations.
Definition: Constants.h:424
A signed pointer, in the ptrauth sense.
Definition: Constants.h:1012
This is an important base class in LLVM.
Definition: Constant.h:42
Dwarf abbreviation, describes the organization of a debug information object.
Definition: DIE.h:79
A structured debug information entry.
Definition: DIE.h:819
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:351
DwarfStringPoolEntryRef: Dwarf string pool entry reference.
const DwarfStringPoolEntry & getEntry() const
GCMetadataPrinter - Emits GC metadata as assembly code.
GCStrategy describes a garbage collector algorithm's code generation requirements,...
Definition: GCStrategy.h:63
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:56
Context object for machine code objects.
Definition: MCContext.h:83
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:34
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:36
Streaming machine code generation interface.
Definition: MCStreamer.h:213
Generic base class for all target subtargets.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
Metadata node.
Definition: Metadata.h:1067
Abstract base class for all machine specific constantpool value subclasses.
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Representation of each machine instruction.
Definition: MachineInstr.h:69
This class contains meta information specific to a module.
MachineOperand class - Representation of each machine instruction operand.
This class implements a map that also provides access to all stored values in a deterministic order.
Definition: MapVector.h:36
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
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
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:77
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
LLVM Value Representation.
Definition: Value.h:74
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
@ BlockAddress
Definition: ISDOpcodes.h:84
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:480
@ Length
Definition: DWP.cpp:480
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:167
@ Enable
Enable colors.
#define N
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
Map a basic block section ID to the begin and end symbols of that section which determine the section...
Definition: AsmPrinter.h:136
llvm.global_ctors and llvm.global_dtors are arrays of Structor structs.
Definition: AsmPrinter.h:463
const class Function * Fn
Definition: AsmPrinter.h:350
Description of the encoding of one expression Op.
Data for a string pool entry.
A helper struct providing information about the byte size of DW_FORM values that vary in size dependi...
Definition: Dwarf.h:1077