LLVM  9.0.0svn
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/MapVector.h"
19 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/ADT/StringRef.h"
21 #include "llvm/ADT/Twine.h"
24 #include "llvm/IR/InlineAsm.h"
25 #include "llvm/IR/LLVMContext.h"
27 #include "llvm/Support/SourceMgr.h"
28 #include <cstdint>
29 #include <memory>
30 #include <utility>
31 #include <vector>
32 
33 namespace llvm {
34 
35 class AsmPrinterHandler;
36 class BasicBlock;
37 class BlockAddress;
38 class Constant;
39 class ConstantArray;
40 class DataLayout;
41 class DIE;
42 class DIEAbbrev;
43 class DwarfDebug;
44 class GCMetadataPrinter;
45 class GCStrategy;
46 class GlobalIndirectSymbol;
47 class GlobalObject;
48 class GlobalValue;
49 class GlobalVariable;
50 class MachineBasicBlock;
51 class MachineConstantPoolValue;
52 class MachineDominatorTree;
53 class MachineFunction;
54 class MachineInstr;
55 class MachineJumpTableInfo;
56 class MachineLoopInfo;
57 class MachineModuleInfo;
58 class MachineOptimizationRemarkEmitter;
59 class MCAsmInfo;
60 class MCCFIInstruction;
61 struct MCCodePaddingContext;
62 class MCContext;
63 class MCExpr;
64 class MCInst;
65 class MCSection;
66 class MCStreamer;
67 class MCSubtargetInfo;
68 class MCSymbol;
69 class MCTargetOptions;
70 class MDNode;
71 class Module;
72 class raw_ostream;
73 class StackMaps;
74 class TargetLoweringObjectFile;
75 class TargetMachine;
76 
77 /// This class is intended to be used as a driving class for all asm writers.
79 public:
80  /// Target machine description.
82 
83  /// Target Asm Printer information.
84  const MCAsmInfo *MAI;
85 
86  /// This is the context for the output file that we are streaming. This owns
87  /// all of the global MC-related objects for the generated translation unit.
89 
90  /// This is the MCStreamer object for the file we are generating. This
91  /// contains the transient state for the current translation unit that we are
92  /// generating (such as the current section etc).
93  std::unique_ptr<MCStreamer> OutStreamer;
94 
95  /// The current machine function.
96  MachineFunction *MF = nullptr;
97 
98  /// This is a pointer to the current MachineModuleInfo.
99  MachineModuleInfo *MMI = nullptr;
100 
101  /// This is a pointer to the current MachineLoopInfo.
103 
104  /// This is a pointer to the current MachineLoopInfo.
105  MachineLoopInfo *MLI = nullptr;
106 
107  /// Optimization remark emitter.
109 
110  /// The symbol for the current function. This is recalculated at the beginning
111  /// of each call to runOnMachineFunction().
112  MCSymbol *CurrentFnSym = nullptr;
113 
114  /// The symbol used to represent the start of the current function for the
115  /// purpose of calculating its size (e.g. using the .size directive). By
116  /// default, this is equal to CurrentFnSym.
118 
119  /// Map global GOT equivalent MCSymbols to GlobalVariables and keep track of
120  /// its number of uses by other globals.
121  using GOTEquivUsePair = std::pair<const GlobalVariable *, unsigned>;
123 
124 private:
125  MCSymbol *CurrentFnBegin = nullptr;
126  MCSymbol *CurrentFnEnd = nullptr;
127  MCSymbol *CurExceptionSym = nullptr;
128 
129  // The garbage collection metadata printer table.
130  void *GCMetadataPrinters = nullptr; // Really a DenseMap.
131 
132  /// Emit comments in assembly output if this is true.
133  bool VerboseAsm;
134 
135  static char ID;
136 
137 protected:
138  /// Protected struct HandlerInfo and Handlers permit target extended
139  /// AsmPrinter adds their own handlers.
140  struct HandlerInfo {
142  const char *TimerName;
143  const char *TimerDescription;
144  const char *TimerGroupName;
146 
147  HandlerInfo(AsmPrinterHandler *Handler, const char *TimerName,
148  const char *TimerDescription, const char *TimerGroupName,
149  const char *TimerGroupDescription)
150  : Handler(Handler), TimerName(TimerName),
151  TimerDescription(TimerDescription), TimerGroupName(TimerGroupName),
152  TimerGroupDescription(TimerGroupDescription) {}
153  };
154 
155  /// A vector of all debug/EH info emitters we should use. This vector
156  /// maintains ownership of the emitters.
158 
159 public:
160  struct SrcMgrDiagInfo {
162  std::vector<const MDNode *> LocInfos;
164  void *DiagContext;
165  };
166 
167 private:
168  /// If generated on the fly this own the instance.
169  std::unique_ptr<MachineDominatorTree> OwnedMDT;
170 
171  /// If generated on the fly this own the instance.
172  std::unique_ptr<MachineLoopInfo> OwnedMLI;
173 
174  /// Structure for generating diagnostics for inline assembly. Only initialised
175  /// when necessary.
176  mutable std::unique_ptr<SrcMgrDiagInfo> DiagInfo;
177 
178  /// If the target supports dwarf debug info, this pointer is non-null.
179  DwarfDebug *DD = nullptr;
180 
181  /// If the current module uses dwarf CFI annotations strictly for debugging.
182  bool isCFIMoveForDebugging = false;
183 
184 protected:
185  explicit AsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer);
186 
187 public:
188  ~AsmPrinter() override;
189 
190  DwarfDebug *getDwarfDebug() { return DD; }
191  DwarfDebug *getDwarfDebug() const { return DD; }
192 
193  uint16_t getDwarfVersion() const;
194  void setDwarfVersion(uint16_t Version);
195 
196  bool isPositionIndependent() const;
197 
198  /// Return true if assembly output should contain comments.
199  bool isVerbose() const { return VerboseAsm; }
200 
201  /// Return a unique ID for the current function.
202  unsigned getFunctionNumber() const;
203 
204  /// Return symbol for the function pseudo stack if the stack frame is not a
205  /// register based.
206  virtual const MCSymbol *getFunctionFrameSymbol() const { return nullptr; }
207 
208  MCSymbol *getFunctionBegin() const { return CurrentFnBegin; }
209  MCSymbol *getFunctionEnd() const { return CurrentFnEnd; }
211 
212  /// Return information about object file lowering.
214 
215  /// Return information about data layout.
216  const DataLayout &getDataLayout() const;
217 
218  /// Return the pointer size from the TargetMachine
219  unsigned getPointerSize() const;
220 
221  /// Return information about subtarget.
222  const MCSubtargetInfo &getSubtargetInfo() const;
223 
224  void EmitToStreamer(MCStreamer &S, const MCInst &Inst);
225 
226  /// Emits inital debug location directive.
228 
229  /// Return the current section we are emitting to.
230  const MCSection *getCurrentSection() const;
231 
233  const GlobalValue *GV) const;
234 
235  MCSymbol *getSymbol(const GlobalValue *GV) const;
236 
237  //===------------------------------------------------------------------===//
238  // XRay instrumentation implementation.
239  //===------------------------------------------------------------------===//
240 public:
241  // This describes the kind of sled we're storing in the XRay table.
242  enum class SledKind : uint8_t {
243  FUNCTION_ENTER = 0,
244  FUNCTION_EXIT = 1,
245  TAIL_CALL = 2,
246  LOG_ARGS_ENTER = 3,
247  CUSTOM_EVENT = 4,
248  TYPED_EVENT = 5,
249  };
250 
251  // The table will contain these structs that point to the sled, the function
252  // containing the sled, and what kind of sled (and whether they should always
253  // be instrumented). We also use a version identifier that the runtime can use
254  // to decide what to do with the sled, depending on the version of the sled.
256  const MCSymbol *Sled;
260  const class Function *Fn;
261  uint8_t Version;
262 
263  void emit(int, MCStreamer *, const MCSymbol *) const;
264  };
265 
266  // All the sleds to be emitted.
268 
269  // A unique ID used for ELF sections associated with a particular function.
270  unsigned XRayFnUniqueID = 0;
271 
272  // Helper function to record a given XRay sled.
273  void recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind,
274  uint8_t Version = 0);
275 
276  /// Emit a table with all XRay instrumentation points.
277  void emitXRayTable();
278 
279  //===------------------------------------------------------------------===//
280  // MachineFunctionPass Implementation.
281  //===------------------------------------------------------------------===//
282 
283  /// Record analysis usage.
284  void getAnalysisUsage(AnalysisUsage &AU) const override;
285 
286  /// Set up the AsmPrinter when we are working on a new module. If your pass
287  /// overrides this, it must make sure to explicitly call this implementation.
288  bool doInitialization(Module &M) override;
289 
290  /// Shut down the asmprinter. If you override this in your pass, you must make
291  /// sure to call it explicitly.
292  bool doFinalization(Module &M) override;
293 
294  /// Emit the specified function out to the OutStreamer.
298  return false;
299  }
300 
301  //===------------------------------------------------------------------===//
302  // Coarse grained IR lowering routines.
303  //===------------------------------------------------------------------===//
304 
305  /// This should be called when a new MachineFunction is being processed from
306  /// runOnMachineFunction.
308 
309  /// This method emits the body and trailer for a function.
310  void EmitFunctionBody();
311 
312  void emitCFIInstruction(const MachineInstr &MI);
313 
314  void emitFrameAlloc(const MachineInstr &MI);
315 
316  void emitStackSizeSection(const MachineFunction &MF);
317 
319  CFIMoveType needsCFIMoves() const;
320 
321  /// Returns false if needsCFIMoves() == CFI_M_EH for any function
322  /// in the module.
323  bool needsOnlyDebugCFIMoves() const { return isCFIMoveForDebugging; }
324 
325  bool needsSEHMoves();
326 
327  /// Print to the current output stream assembly representations of the
328  /// constants in the constant pool MCP. This is used to print out constants
329  /// which have been "spilled to memory" by the code generator.
330  virtual void EmitConstantPool();
331 
332  /// Print assembly representations of the jump tables used by the current
333  /// function to the current output stream.
334  virtual void EmitJumpTableInfo();
335 
336  /// Emit the specified global variable to the .s file.
337  virtual void EmitGlobalVariable(const GlobalVariable *GV);
338 
339  /// Check to see if the specified global is a special global used by LLVM. If
340  /// so, emit it and return true, otherwise do nothing and return false.
341  bool EmitSpecialLLVMGlobal(const GlobalVariable *GV);
342 
343  /// Emit an alignment directive to the specified power of two boundary. For
344  /// example, if you pass in 3 here, you will get an 8 byte alignment. If a
345  /// global value is specified, and if that global has an explicit alignment
346  /// requested, it will override the alignment request if required for
347  /// correctness.
348  void EmitAlignment(unsigned NumBits, const GlobalObject *GV = nullptr) const;
349 
350  /// Lower the specified LLVM Constant to an MCExpr.
351  virtual const MCExpr *lowerConstant(const Constant *CV);
352 
353  /// Print a general LLVM constant to the .s file.
354  void EmitGlobalConstant(const DataLayout &DL, const Constant *CV);
355 
356  /// Unnamed constant global variables solely contaning a pointer to
357  /// another globals variable act like a global variable "proxy", or GOT
358  /// equivalents, i.e., it's only used to hold the address of the latter. One
359  /// optimization is to replace accesses to these proxies by using the GOT
360  /// entry for the final global instead. Hence, we select GOT equivalent
361  /// candidates among all the module global variables, avoid emitting them
362  /// unnecessarily and finally replace references to them by pc relative
363  /// accesses to GOT entries.
365 
366  /// Constant expressions using GOT equivalent globals may not be
367  /// eligible for PC relative GOT entry conversion, in such cases we need to
368  /// emit the proxies we previously omitted in EmitGlobalVariable.
369  void emitGlobalGOTEquivs();
370 
371  /// Emit the stack maps.
372  void emitStackMaps(StackMaps &SM);
373 
374  //===------------------------------------------------------------------===//
375  // Overridable Hooks
376  //===------------------------------------------------------------------===//
377 
378  // Targets can, or in the case of EmitInstruction, must implement these to
379  // customize output.
380 
381  /// This virtual method can be overridden by targets that want to emit
382  /// something at the start of their file.
383  virtual void EmitStartOfAsmFile(Module &) {}
384 
385  /// This virtual method can be overridden by targets that want to emit
386  /// something at the end of their file.
387  virtual void EmitEndOfAsmFile(Module &) {}
388 
389  /// Targets can override this to emit stuff before the first basic block in
390  /// the function.
391  virtual void EmitFunctionBodyStart() {}
392 
393  /// Targets can override this to emit stuff after the last basic block in the
394  /// function.
395  virtual void EmitFunctionBodyEnd() {}
396 
397  /// Targets can override this to emit stuff at the start of a basic block.
398  /// By default, this method prints the label for the specified
399  /// MachineBasicBlock, an alignment (if present) and a comment describing it
400  /// if appropriate.
401  virtual void EmitBasicBlockStart(const MachineBasicBlock &MBB) const;
402 
403  /// Targets can override this to emit stuff at the end of a basic block.
404  virtual void EmitBasicBlockEnd(const MachineBasicBlock &MBB);
405 
406  /// Targets should implement this to emit instructions.
407  virtual void EmitInstruction(const MachineInstr *) {
408  llvm_unreachable("EmitInstruction not implemented");
409  }
410 
411  /// Return the symbol for the specified constant pool entry.
412  virtual MCSymbol *GetCPISymbol(unsigned CPID) const;
413 
414  virtual void EmitFunctionEntryLabel();
415 
417 
418  /// Targets can override this to change how global constants that are part of
419  /// a C++ static/global constructor list are emitted.
420  virtual void EmitXXStructor(const DataLayout &DL, const Constant *CV) {
421  EmitGlobalConstant(DL, CV);
422  }
423 
424  /// Return true if the basic block has exactly one predecessor and the control
425  /// transfer mechanism between the predecessor and this block is a
426  /// fall-through.
427  virtual bool
429 
430  /// Targets can override this to customize the output of IMPLICIT_DEF
431  /// instructions in verbose mode.
432  virtual void emitImplicitDef(const MachineInstr *MI) const;
433 
434  //===------------------------------------------------------------------===//
435  // Symbol Lowering Routines.
436  //===------------------------------------------------------------------===//
437 
438  MCSymbol *createTempSymbol(const Twine &Name) const;
439 
440  /// Return the MCSymbol for a private symbol with global value name as its
441  /// base, with the specified suffix.
443  StringRef Suffix) const;
444 
445  /// Return the MCSymbol for the specified ExternalSymbol.
447 
448  /// Return the symbol for the specified jump table entry.
449  MCSymbol *GetJTISymbol(unsigned JTID, bool isLinkerPrivate = false) const;
450 
451  /// Return the symbol for the specified jump table .set
452  /// FIXME: privatize to AsmPrinter.
453  MCSymbol *GetJTSetSymbol(unsigned UID, unsigned MBBID) const;
454 
455  /// Return the MCSymbol used to satisfy BlockAddress uses of the specified
456  /// basic block.
457  MCSymbol *GetBlockAddressSymbol(const BlockAddress *BA) const;
458  MCSymbol *GetBlockAddressSymbol(const BasicBlock *BB) const;
459 
460  //===------------------------------------------------------------------===//
461  // Emission Helper Routines.
462  //===------------------------------------------------------------------===//
463 
464  /// This is just convenient handler for printing offsets.
465  void printOffset(int64_t Offset, raw_ostream &OS) const;
466 
467  /// Emit a byte directive and value.
468  void emitInt8(int Value) const;
469 
470  /// Emit a short directive and value.
471  void emitInt16(int Value) const;
472 
473  /// Emit a long directive and value.
474  void emitInt32(int Value) const;
475 
476  /// Emit a long long directive and value.
477  void emitInt64(uint64_t Value) const;
478 
479  /// Emit something like ".long Hi-Lo" where the size in bytes of the directive
480  /// is specified by Size and Hi/Lo specify the labels. This implicitly uses
481  /// .set if it is available.
482  void EmitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo,
483  unsigned Size) const;
484 
485  /// Emit something like ".uleb128 Hi-Lo".
486  void EmitLabelDifferenceAsULEB128(const MCSymbol *Hi,
487  const MCSymbol *Lo) const;
488 
489  /// Emit something like ".long Label+Offset" where the size in bytes of the
490  /// directive is specified by Size and Label specifies the label. This
491  /// implicitly uses .set if it is available.
492  void EmitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset,
493  unsigned Size, bool IsSectionRelative = false) const;
494 
495  /// Emit something like ".long Label" where the size in bytes of the directive
496  /// is specified by Size and Label specifies the label.
497  void EmitLabelReference(const MCSymbol *Label, unsigned Size,
498  bool IsSectionRelative = false) const {
499  EmitLabelPlusOffset(Label, 0, Size, IsSectionRelative);
500  }
501 
502  /// Emit something like ".long Label + Offset".
503  void EmitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const;
504 
505  //===------------------------------------------------------------------===//
506  // Dwarf Emission Helper Routines
507  //===------------------------------------------------------------------===//
508 
509  /// Emit the specified signed leb128 value.
510  void EmitSLEB128(int64_t Value, const char *Desc = nullptr) const;
511 
512  /// Emit the specified unsigned leb128 value.
513  void EmitULEB128(uint64_t Value, const char *Desc = nullptr) const;
514 
515  /// Emit a .byte 42 directive that corresponds to an encoding. If verbose
516  /// assembly output is enabled, we output comments describing the encoding.
517  /// Desc is a string saying what the encoding is specifying (e.g. "LSDA").
518  void EmitEncodingByte(unsigned Val, const char *Desc = nullptr) const;
519 
520  /// Return the size of the encoding in bytes.
521  unsigned GetSizeOfEncodedValue(unsigned Encoding) const;
522 
523  /// Emit reference to a ttype global with a specified encoding.
524  void EmitTTypeReference(const GlobalValue *GV, unsigned Encoding) const;
525 
526  /// Emit a reference to a symbol for use in dwarf. Different object formats
527  /// represent this in different ways. Some use a relocation others encode
528  /// the label offset in its section.
529  void emitDwarfSymbolReference(const MCSymbol *Label,
530  bool ForceOffset = false) const;
531 
532  /// Emit the 4-byte offset of a string from the start of its section.
533  ///
534  /// When possible, emit a DwarfStringPool section offset without any
535  /// relocations, and without using the symbol. Otherwise, defers to \a
536  /// emitDwarfSymbolReference().
538 
539  /// Emit the 4-byte offset of a string from the start of its section.
542  }
543 
544  /// Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
545  virtual unsigned getISAEncoding() { return 0; }
546 
547  /// Emit the directive and value for debug thread local expression
548  ///
549  /// \p Value - The value to emit.
550  /// \p Size - The size of the integer (in bytes) to emit.
551  virtual void EmitDebugValue(const MCExpr *Value, unsigned Size) const;
552 
553  //===------------------------------------------------------------------===//
554  // Dwarf Lowering Routines
555  //===------------------------------------------------------------------===//
556 
557  /// Emit frame instruction to describe the layout of the frame.
558  void emitCFIInstruction(const MCCFIInstruction &Inst) const;
559 
560  /// Emit Dwarf abbreviation table.
561  template <typename T> void emitDwarfAbbrevs(const T &Abbrevs) const {
562  // For each abbreviation.
563  for (const auto &Abbrev : Abbrevs)
564  emitDwarfAbbrev(*Abbrev);
565 
566  // Mark end of abbreviations.
567  EmitULEB128(0, "EOM(3)");
568  }
569 
570  void emitDwarfAbbrev(const DIEAbbrev &Abbrev) const;
571 
572  /// Recursively emit Dwarf DIE tree.
573  void emitDwarfDIE(const DIE &Die) const;
574 
575  //===------------------------------------------------------------------===//
576  // Inline Asm Support
577  //===------------------------------------------------------------------===//
578 
579  // These are hooks that targets can override to implement inline asm
580  // support. These should probably be moved out of AsmPrinter someday.
581 
582  /// Print information related to the specified machine instr that is
583  /// independent of the operand, and may be independent of the instr itself.
584  /// This can be useful for portably encoding the comment character or other
585  /// bits of target-specific knowledge into the asmstrings. The syntax used is
586  /// ${:comment}. Targets can override this to add support for their own
587  /// strange codes.
588  virtual void PrintSpecial(const MachineInstr *MI, raw_ostream &OS,
589  const char *Code) const;
590 
591  /// Print the specified operand of MI, an INLINEASM instruction, using the
592  /// specified assembler variant. Targets should override this to format as
593  /// appropriate. This method can return true if the operand is erroneous.
594  virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
595  unsigned AsmVariant, const char *ExtraCode,
596  raw_ostream &OS);
597 
598  /// Print the specified operand of MI, an INLINEASM instruction, using the
599  /// specified assembler variant as an address. Targets should override this to
600  /// format as appropriate. This method can return true if the operand is
601  /// erroneous.
602  virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
603  unsigned AsmVariant, const char *ExtraCode,
604  raw_ostream &OS);
605 
606  /// Let the target do anything it needs to do before emitting inlineasm.
607  /// \p StartInfo - the subtarget info before parsing inline asm
608  virtual void emitInlineAsmStart() const;
609 
610  /// Let the target do anything it needs to do after emitting inlineasm.
611  /// This callback can be used restore the original mode in case the
612  /// inlineasm contains directives to switch modes.
613  /// \p StartInfo - the original subtarget info before inline asm
614  /// \p EndInfo - the final subtarget info after parsing the inline asm,
615  /// or NULL if the value is unknown.
616  virtual void emitInlineAsmEnd(const MCSubtargetInfo &StartInfo,
617  const MCSubtargetInfo *EndInfo) const;
618 
619 private:
620  /// Private state for PrintSpecial()
621  // Assign a unique ID to this machine instruction.
622  mutable const MachineInstr *LastMI = nullptr;
623  mutable unsigned LastFn = 0;
624  mutable unsigned Counter = ~0U;
625 
626  /// This method emits the header for the current function.
627  virtual void EmitFunctionHeader();
628 
629  /// Emit a blob of inline asm to the output streamer.
630  void
631  EmitInlineAsm(StringRef Str, const MCSubtargetInfo &STI,
632  const MCTargetOptions &MCOptions,
633  const MDNode *LocMDNode = nullptr,
634  InlineAsm::AsmDialect AsmDialect = InlineAsm::AD_ATT) const;
635 
636  /// This method formats and emits the specified machine instruction that is an
637  /// inline asm.
638  void EmitInlineAsm(const MachineInstr *MI) const;
639 
640  /// Add inline assembly info to the diagnostics machinery, so we can
641  /// emit file and position info. Returns SrcMgr memory buffer position.
642  unsigned addInlineAsmDiagBuffer(StringRef AsmStr,
643  const MDNode *LocMDNode) const;
644 
645  //===------------------------------------------------------------------===//
646  // Internal Implementation Details
647  //===------------------------------------------------------------------===//
648 
649  /// This emits visibility information about symbol, if this is supported by
650  /// the target.
651  void EmitVisibility(MCSymbol *Sym, unsigned Visibility,
652  bool IsDefinition = true) const;
653 
654  void EmitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const;
655 
656  void EmitJumpTableEntry(const MachineJumpTableInfo *MJTI,
657  const MachineBasicBlock *MBB, unsigned uid) const;
658  void EmitLLVMUsedList(const ConstantArray *InitList);
659  /// Emit llvm.ident metadata in an '.ident' directive.
660  void EmitModuleIdents(Module &M);
661  /// Emit bytes for llvm.commandline metadata.
662  void EmitModuleCommandLines(Module &M);
663  void EmitXXStructorList(const DataLayout &DL, const Constant *List,
664  bool isCtor);
665 
666  GCMetadataPrinter *GetOrCreateGCPrinter(GCStrategy &S);
667  /// Emit GlobalAlias or GlobalIFunc.
668  void emitGlobalIndirectSymbol(Module &M, const GlobalIndirectSymbol &GIS);
669  void setupCodePaddingContext(const MachineBasicBlock &MBB,
671 };
672 
673 } // end namespace llvm
674 
675 #endif // LLVM_CODEGEN_ASMPRINTER_H
virtual void EmitGlobalVariable(const GlobalVariable *GV)
Emit the specified global variable to the .s file.
Definition: AsmPrinter.cpp:435
void setDwarfVersion(uint16_t Version)
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:206
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:38
virtual void emitInlineAsmStart() const
Let the target do anything it needs to do before emitting inlineasm.
void emitInt64(uint64_t Value) const
Emit a long long directive and value.
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:383
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:110
LLVMContext & Context
unsigned XRayFnUniqueID
Definition: AsmPrinter.h:270
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:93
MCSymbol * GetExternalSymbolSymbol(StringRef Sym) const
Return the MCSymbol for the specified ExternalSymbol.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Various leaf nodes.
Definition: ISDOpcodes.h:59
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
bool needsOnlyDebugCFIMoves() const
Returns false if needsCFIMoves() == CFI_M_EH for any function in the module.
Definition: AsmPrinter.h:323
bool doFinalization(Module &M) override
Shut down the asmprinter.
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
MCContext & OutContext
This is the context for the output file that we are streaming.
Definition: AsmPrinter.h:88
const MCSubtargetInfo & getSubtargetInfo() const
Return information about subtarget.
Definition: AsmPrinter.cpp:220
uint16_t getDwarfVersion() const
CFIMoveType needsCFIMoves() const
Definition: AsmPrinter.cpp:912
virtual void EmitJumpTableInfo()
Print assembly representations of the jump tables used by the current function to the current output ...
Collects and handles AsmPrinter objects required to build debug or EH information.
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:280
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:420
virtual void EmitConstantPool()
Print to the current output stream assembly representations of the constants in the constant pool MCP...
void emitDwarfSymbolReference(const MCSymbol *Label, bool ForceOffset=false) const
Emit a reference to a symbol for use in dwarf.
This class implements a map that also provides access to all stored values in a deterministic order...
Definition: MapVector.h:37
Metadata node.
Definition: Metadata.h:863
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:96
SmallVector< HandlerInfo, 1 > Handlers
A vector of all debug/EH info emitters we should use.
Definition: AsmPrinter.h:157
ELFYAML::ELF_STV Visibility
Definition: ELFYAML.cpp:807
LLVMContext::InlineAsmDiagHandlerTy DiagHandler
Definition: AsmPrinter.h:163
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:121
virtual void EmitDebugValue(const MCExpr *Value, unsigned Size) const
Emit the directive and value for debug thread local expression.
Definition: AsmPrinter.cpp:633
DwarfStringPoolEntry getEntry() const
Return the entire string pool entry for convenience.
const char * TimerGroupDescription
Definition: AsmPrinter.h:145
The address of a basic block.
Definition: Constants.h:839
void recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind, uint8_t Version=0)
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
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:387
void emitDwarfDIE(const DIE &Die) const
Recursively emit Dwarf DIE tree.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
SmallVector< XRayFunctionEntry, 4 > Sleds
Definition: AsmPrinter.h:267
unsigned getPointerSize() const
Return the pointer size from the TargetMachine.
Definition: AsmPrinter.cpp:216
void emitXRayTable()
Emit a table with all XRay instrumentation points.
Context object for machine code objects.
Definition: MCContext.h:62
void getAnalysisUsage(AnalysisUsage &AU) const override
Record analysis usage.
Definition: AsmPrinter.cpp:240
void EmitFunctionBody()
This method emits the body and trailer for a function.
bool runOnMachineFunction(MachineFunction &MF) override
Emit the specified function out to the OutStreamer.
Definition: AsmPrinter.h:295
MCSymbol * getFunctionBegin() const
Definition: AsmPrinter.h:208
virtual void EmitBasicBlockEnd(const MachineBasicBlock &MBB)
Targets can override this to emit stuff at the end of a basic block.
bool isPositionIndependent() const
Definition: AsmPrinter.cpp:197
virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, unsigned AsmVariant, const char *ExtraCode, raw_ostream &OS)
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant as...
Protected struct HandlerInfo and Handlers permit target extended AsmPrinter adds their own handlers...
Definition: AsmPrinter.h:140
void printOffset(int64_t Offset, raw_ostream &OS) const
This is just convenient handler for printing offsets.
bool isVerbose() const
Return true if assembly output should contain comments.
Definition: AsmPrinter.h:199
Data for a string pool entry.
void EmitLabelDifferenceAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo) const
Emit something like ".uleb128 Hi-Lo".
void emitGlobalGOTEquivs()
Constant expressions using GOT equivalent globals may not be eligible for PC relative GOT entry conve...
MachineModuleInfo * MMI
This is a pointer to the current MachineModuleInfo.
Definition: AsmPrinter.h:99
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:158
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...
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:55
Streaming machine code generation interface.
Definition: MCStreamer.h:188
virtual void EmitFunctionBodyEnd()
Targets can override this to emit stuff after the last basic block in the function.
Definition: AsmPrinter.h:395
MCSymbol * CurrentFnSym
The symbol for the current function.
Definition: AsmPrinter.h:112
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:84
AsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > Streamer)
Definition: AsmPrinter.cpp:180
This is an important base class in LLVM.
Definition: Constant.h:41
A structured debug information entry.
Definition: DIE.h:661
virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, unsigned AsmVariant, const char *ExtraCode, raw_ostream &OS)
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant...
void EmitEncodingByte(unsigned Val, const char *Desc=nullptr) const
Emit a .byte 42 directive that corresponds to an encoding.
virtual bool isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const
Return true if the basic block has exactly one predecessor and the control transfer mechanism between...
void EmitAlignment(unsigned NumBits, const GlobalObject *GV=nullptr) const
Emit an alignment directive to the specified power of two boundary.
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:81
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:78
void getNameWithPrefix(SmallVectorImpl< char > &Name, const GlobalValue *GV) const
Definition: AsmPrinter.cpp:425
Represent the analysis usage information of a pass.
DwarfDebug * getDwarfDebug()
Definition: AsmPrinter.h:190
static void EmitInlineAsm(LLVMContext &C, BasicBlock *BB, StringRef AsmText)
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:497
~AsmPrinter() override
Definition: AsmPrinter.cpp:186
void emitFrameAlloc(const MachineInstr &MI)
Definition: AsmPrinter.cpp:952
This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling...
Definition: SourceMgr.h:41
void computeGlobalGOTEquivs(Module &M)
Unnamed constant global variables solely contaning a pointer to another globals variable act like a g...
void emitStackMaps(StackMaps &SM)
Emit the stack maps.
Abstract base class for all machine specific constantpool value subclasses.
virtual MCSymbol * GetCPISymbol(unsigned CPID) const
Return the symbol for the specified constant pool entry.
unsigned GetSizeOfEncodedValue(unsigned Encoding) const
Return the size of the encoding in bytes.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
unsigned getFunctionNumber() const
Return a unique ID for the current function.
Definition: AsmPrinter.cpp:202
void emitCFIInstruction(const MachineInstr &MI)
Definition: AsmPrinter.cpp:927
virtual void emitImplicitDef(const MachineInstr *MI) const
Targets can override this to customize the output of IMPLICIT_DEF instructions in verbose mode...
Definition: AsmPrinter.cpp:772
MCSymbol * GetBlockAddressSymbol(const BlockAddress *BA) const
Return the MCSymbol used to satisfy BlockAddress uses of the specified basic block.
void EmitSLEB128(int64_t Value, const char *Desc=nullptr) const
Emit the specified signed leb128 value.
MapVector< const MCSymbol *, GOTEquivUsePair > GlobalGOTEquivs
Definition: AsmPrinter.h:122
void emitDwarfStringOffset(DwarfStringPoolEntry S) const
Emit the 4-byte offset of a string from the start of its section.
The optimization diagnostic interface.
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:430
virtual const MCExpr * lowerConstant(const Constant *CV)
Lower the specified LLVM Constant to an MCExpr.
virtual void EmitInstruction(const MachineInstr *)
Targets should implement this to emit instructions.
Definition: AsmPrinter.h:407
AsmPrinterHandler * Handler
Definition: AsmPrinter.h:141
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:839
DwarfDebug * getDwarfDebug() const
Definition: AsmPrinter.h:191
void EmitToStreamer(MCStreamer &S, const MCInst &Inst)
Definition: AsmPrinter.cpp:225
bool EmitSpecialLLVMGlobal(const GlobalVariable *GV)
Check to see if the specified global is a special global used by LLVM.
virtual void emitInlineAsmEnd(const MCSubtargetInfo &StartInfo, const MCSubtargetInfo *EndInfo) const
Let the target do anything it needs to do after emitting inlineasm.
const class Function * Fn
Definition: AsmPrinter.h:260
void EmitTTypeReference(const GlobalValue *GV, unsigned Encoding) const
Emit reference to a ttype global with a specified encoding.
void emitInt32(int Value) const
Emit a long directive and value.
MCSymbol * getFunctionEnd() const
Definition: AsmPrinter.h:209
MachineDominatorTree * MDT
This is a pointer to the current MachineLoopInfo.
Definition: AsmPrinter.h:102
ConstantArray - Constant Array Declarations.
Definition: Constants.h:413
void emitDwarfAbbrevs(const T &Abbrevs) const
Emit Dwarf abbreviation table.
Definition: AsmPrinter.h:561
virtual void EmitFunctionBodyStart()
Targets can override this to emit stuff before the first basic block in the function.
Definition: AsmPrinter.h:391
MCSymbol * getCurExceptionSym()
void(*)(const SMDiagnostic &, void *Context, unsigned LocCookie) InlineAsmDiagHandlerTy
Definition: LLVMContext.h:172
virtual const MCSymbol * getFunctionFrameSymbol() const
Return symbol for the function pseudo stack if the stack frame is not a register based.
Definition: AsmPrinter.h:206
void emitDwarfAbbrev(const DIEAbbrev &Abbrev) const
String pool entry reference.
virtual void EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV)
MachineLoopInfo * MLI
This is a pointer to the current MachineLoopInfo.
Definition: AsmPrinter.h:105
Representation of each machine instruction.
Definition: MachineInstr.h:63
void emitInitialRawDwarfLocDirective(const MachineFunction &MF)
Emits inital debug location directive.
Definition: AsmPrinter.cpp:229
Dwarf abbreviation, describes the organization of a debug information object.
Definition: DIE.h:78
bool doInitialization(Module &M) override
Set up the AsmPrinter when we are working on a new module.
Definition: AsmPrinter.cpp:248
GCStrategy describes a garbage collector algorithm&#39;s code generation requirements, and provides overridable hooks for those needs which cannot be abstractly described.
Definition: GCStrategy.h:66
void SetupMachineFunction(MachineFunction &MF)
This should be called when a new MachineFunction is being processed from runOnMachineFunction.
void emitDwarfStringOffset(DwarfStringPoolEntryRef S) const
Emit the 4-byte offset of a string from the start of its section.
Definition: AsmPrinter.h:540
MCSymbol * GetJTISymbol(unsigned JTID, bool isLinkerPrivate=false) const
Return the symbol for the specified jump table entry.
void EmitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const
Emit something like ".long Label + Offset".
virtual void EmitBasicBlockStart(const MachineBasicBlock &MBB) const
Targets can override this to emit stuff at the start of a basic block.
MCSymbol * GetJTSetSymbol(unsigned UID, unsigned MBBID) const
Return the symbol for the specified jump table .set FIXME: privatize to AsmPrinter.
const NodeList & List
Definition: RDFGraph.cpp:209
Generic base class for all target subtargets.
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...
uint32_t Size
Definition: Profile.cpp:46
virtual unsigned getISAEncoding()
Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
Definition: AsmPrinter.h:545
virtual void EmitFunctionEntryLabel()
EmitFunctionEntryLabel - Emit the label that is the entrypoint for the function.
Definition: AsmPrinter.cpp:728
const unsigned Kind
void EmitGlobalConstant(const DataLayout &DL, const Constant *CV)
Print a general LLVM constant to the .s file.
void emitInt8(int Value) const
Emit a byte directive and value.
LLVM Value Representation.
Definition: Value.h:72
void EmitULEB128(uint64_t Value, const char *Desc=nullptr) const
Emit the specified unsigned leb128 value.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:58
MCSymbol * CurrentFnSymForSize
The symbol used to represent the start of the current function for the purpose of calculating its siz...
Definition: AsmPrinter.h:117
const DataLayout & getDataLayout() const
Return information about data layout.
Definition: AsmPrinter.cpp:210
GCMetadataPrinter - Emits GC metadata as assembly code.
IRTranslator LLVM IR MI
MachineOptimizationRemarkEmitter * ORE
Optimization remark emitter.
Definition: AsmPrinter.h:108
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
HandlerInfo(AsmPrinterHandler *Handler, const char *TimerName, const char *TimerDescription, const char *TimerGroupName, const char *TimerGroupDescription)
Definition: AsmPrinter.h:147
std::vector< const MDNode * > LocInfos
Definition: AsmPrinter.h:162
const MCSection * getCurrentSection() const
Return the current section we are emitting to.
Definition: AsmPrinter.cpp:236
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 * createTempSymbol(const Twine &Name) const
const uint64_t Version
Definition: InstrProf.h:894
virtual void PrintSpecial(const MachineInstr *MI, raw_ostream &OS, const char *Code) const
Print information related to the specified machine instr that is independent of the operand...
void emitStackSizeSection(const MachineFunction &MF)
Definition: AsmPrinter.cpp:962
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
void emitInt16(int Value) const
Emit a short directive and value.
This class contains meta information specific to a module.