LLVM  14.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/MapVector.h"
19 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/IR/InlineAsm.h"
24 #include "llvm/IR/LLVMContext.h"
26 #include "llvm/Support/SourceMgr.h"
27 #include <cstdint>
28 #include <memory>
29 #include <utility>
30 #include <vector>
31 
32 namespace llvm {
33 
34 class BasicBlock;
35 class BlockAddress;
36 class Constant;
37 class ConstantArray;
38 class DataLayout;
39 class DIE;
40 class DIEAbbrev;
41 class DwarfDebug;
42 class GCMetadataPrinter;
43 class GCStrategy;
44 class GlobalObject;
45 class GlobalValue;
46 class GlobalVariable;
47 class MachineBasicBlock;
48 class MachineConstantPoolValue;
49 class MachineDominatorTree;
50 class MachineFunction;
51 class MachineInstr;
52 class MachineJumpTableInfo;
53 class MachineLoopInfo;
54 class MachineModuleInfo;
55 class MachineOptimizationRemarkEmitter;
56 class MCAsmInfo;
57 class MCCFIInstruction;
58 class MCContext;
59 class MCExpr;
60 class MCInst;
61 class MCSection;
62 class MCStreamer;
63 class MCSubtargetInfo;
64 class MCSymbol;
65 class MCTargetOptions;
66 class MDNode;
67 class Module;
68 class PseudoProbeHandler;
69 class raw_ostream;
70 class StackMaps;
71 class StringRef;
72 class TargetLoweringObjectFile;
73 class TargetMachine;
74 class Twine;
75 
76 namespace remarks {
77 class RemarkStreamer;
78 }
79 
80 /// This class is intended to be used as a driving class for all asm writers.
82 public:
83  /// Target machine description.
85 
86  /// Target Asm Printer information.
87  const MCAsmInfo *MAI;
88 
89  /// This is the context for the output file that we are streaming. This owns
90  /// all of the global MC-related objects for the generated translation unit.
92 
93  /// This is the MCStreamer object for the file we are generating. This
94  /// contains the transient state for the current translation unit that we are
95  /// generating (such as the current section etc).
96  std::unique_ptr<MCStreamer> OutStreamer;
97 
98  /// The current machine function.
99  MachineFunction *MF = nullptr;
100 
101  /// This is a pointer to the current MachineModuleInfo.
102  MachineModuleInfo *MMI = nullptr;
103 
104  /// This is a pointer to the current MachineDominatorTree.
106 
107  /// This is a pointer to the current MachineLoopInfo.
108  MachineLoopInfo *MLI = nullptr;
109 
110  /// Optimization remark emitter.
112 
113  /// The symbol for the entry in __patchable_function_entires.
115 
116  /// The symbol for the current function. This is recalculated at the beginning
117  /// of each call to runOnMachineFunction().
118  MCSymbol *CurrentFnSym = nullptr;
119 
120  /// The symbol for the current function descriptor on AIX. This is created
121  /// at the beginning of each call to SetupMachineFunction().
123 
124  /// The symbol used to represent the start of the current function for the
125  /// purpose of calculating its size (e.g. using the .size directive). By
126  /// default, this is equal to CurrentFnSym.
128 
129  /// Map a basic block section ID to the begin and end symbols of that section
130  /// which determine the section's range.
133  };
134 
136 
137  /// Map global GOT equivalent MCSymbols to GlobalVariables and keep track of
138  /// its number of uses by other globals.
139  using GOTEquivUsePair = std::pair<const GlobalVariable *, unsigned>;
141 
142  /// struct HandlerInfo and Handlers permit users or target extended
143  /// AsmPrinter to add their own handlers.
144  struct HandlerInfo {
145  std::unique_ptr<AsmPrinterHandler> Handler;
150 
151  HandlerInfo(std::unique_ptr<AsmPrinterHandler> Handler, StringRef TimerName,
157  };
158 
159  // Flags representing which CFI section is required for a function/module.
160  enum class CFISection : unsigned {
161  None = 0, ///< Do not emit either .eh_frame or .debug_frame
162  EH = 1, ///< Emit .eh_frame
163  Debug = 2 ///< Emit .debug_frame
164  };
165 
166 private:
167  MCSymbol *CurrentFnEnd = nullptr;
168 
169  /// Map a basic block section ID to the exception symbol associated with that
170  /// section. Map entries are assigned and looked up via
171  /// AsmPrinter::getMBBExceptionSym.
172  DenseMap<unsigned, MCSymbol *> MBBSectionExceptionSyms;
173 
174  // The symbol used to represent the start of the current BB section of the
175  // function. This is used to calculate the size of the BB section.
176  MCSymbol *CurrentSectionBeginSym = nullptr;
177 
178  // The garbage collection metadata printer table.
179  void *GCMetadataPrinters = nullptr; // Really a DenseMap.
180 
181  /// Emit comments in assembly output if this is true.
182  bool VerboseAsm;
183 
184  /// Output stream for the stack usage file (i.e., .su file).
185  std::unique_ptr<raw_fd_ostream> StackUsageStream;
186 
187  static char ID;
188 
189 protected:
191 
192  /// A vector of all debug/EH info emitters we should use. This vector
193  /// maintains ownership of the emitters.
194  std::vector<HandlerInfo> Handlers;
195  size_t NumUserHandlers = 0;
196 
197 private:
198  /// If generated on the fly this own the instance.
199  std::unique_ptr<MachineDominatorTree> OwnedMDT;
200 
201  /// If generated on the fly this own the instance.
202  std::unique_ptr<MachineLoopInfo> OwnedMLI;
203 
204  /// If the target supports dwarf debug info, this pointer is non-null.
205  DwarfDebug *DD = nullptr;
206 
207  /// A handler that supports pseudo probe emission with embedded inline
208  /// context.
209  PseudoProbeHandler *PP = nullptr;
210 
211  /// CFISection type the module needs i.e. either .eh_frame or .debug_frame.
212  CFISection ModuleCFISection = CFISection::None;
213 
214 protected:
215  explicit AsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer);
216 
217 public:
218  ~AsmPrinter() override;
219 
220  DwarfDebug *getDwarfDebug() { return DD; }
221  DwarfDebug *getDwarfDebug() const { return DD; }
222 
223  uint16_t getDwarfVersion() const;
225 
226  bool isDwarf64() const;
227 
228  /// Returns 4 for DWARF32 and 8 for DWARF64.
229  unsigned int getDwarfOffsetByteSize() const;
230 
231  /// Returns 4 for DWARF32 and 12 for DWARF64.
232  unsigned int getUnitLengthFieldByteSize() const;
233 
234  bool isPositionIndependent() const;
235 
236  /// Return true if assembly output should contain comments.
237  bool isVerbose() const { return VerboseAsm; }
238 
239  /// Return a unique ID for the current function.
240  unsigned getFunctionNumber() const;
241 
242  /// Return symbol for the function pseudo stack if the stack frame is not a
243  /// register based.
244  virtual const MCSymbol *getFunctionFrameSymbol() const { return nullptr; }
245 
247  MCSymbol *getFunctionEnd() const { return CurrentFnEnd; }
248 
249  // Return the exception symbol associated with the MBB section containing a
250  // given basic block.
252 
253  /// Return information about object file lowering.
255 
256  /// Return information about data layout.
257  const DataLayout &getDataLayout() const;
258 
259  /// Return the pointer size from the TargetMachine
260  unsigned getPointerSize() const;
261 
262  /// Return information about subtarget.
263  const MCSubtargetInfo &getSubtargetInfo() const;
264 
265  void EmitToStreamer(MCStreamer &S, const MCInst &Inst);
266 
267  /// Emits inital debug location directive.
269 
270  /// Return the current section we are emitting to.
271  const MCSection *getCurrentSection() const;
272 
274  const GlobalValue *GV) const;
275 
276  MCSymbol *getSymbol(const GlobalValue *GV) const;
277 
278  /// Similar to getSymbol() but preferred for references. On ELF, this uses a
279  /// local symbol if a reference to GV is guaranteed to be resolved to the
280  /// definition in the same module.
281  MCSymbol *getSymbolPreferLocal(const GlobalValue &GV) const;
282 
283  //===------------------------------------------------------------------===//
284  // XRay instrumentation implementation.
285  //===------------------------------------------------------------------===//
286 public:
287  // This describes the kind of sled we're storing in the XRay table.
288  enum class SledKind : uint8_t {
289  FUNCTION_ENTER = 0,
290  FUNCTION_EXIT = 1,
291  TAIL_CALL = 2,
292  LOG_ARGS_ENTER = 3,
293  CUSTOM_EVENT = 4,
294  TYPED_EVENT = 5,
295  };
296 
297  // The table will contain these structs that point to the sled, the function
298  // containing the sled, and what kind of sled (and whether they should always
299  // be instrumented). We also use a version identifier that the runtime can use
300  // to decide what to do with the sled, depending on the version of the sled.
302  const MCSymbol *Sled;
306  const class Function *Fn;
307  uint8_t Version;
308 
309  void emit(int, MCStreamer *) const;
310  };
311 
312  // All the sleds to be emitted.
314 
315  // Helper function to record a given XRay sled.
316  void recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind,
317  uint8_t Version = 0);
318 
319  /// Emit a table with all XRay instrumentation points.
320  void emitXRayTable();
321 
323 
324  //===------------------------------------------------------------------===//
325  // MachineFunctionPass Implementation.
326  //===------------------------------------------------------------------===//
327 
328  /// Record analysis usage.
329  void getAnalysisUsage(AnalysisUsage &AU) const override;
330 
331  /// Set up the AsmPrinter when we are working on a new module. If your pass
332  /// overrides this, it must make sure to explicitly call this implementation.
333  bool doInitialization(Module &M) override;
334 
335  /// Shut down the asmprinter. If you override this in your pass, you must make
336  /// sure to call it explicitly.
337  bool doFinalization(Module &M) override;
338 
339  /// Emit the specified function out to the OutStreamer.
343  return false;
344  }
345 
346  //===------------------------------------------------------------------===//
347  // Coarse grained IR lowering routines.
348  //===------------------------------------------------------------------===//
349 
350  /// This should be called when a new MachineFunction is being processed from
351  /// runOnMachineFunction.
352  virtual void SetupMachineFunction(MachineFunction &MF);
353 
354  /// This method emits the body and trailer for a function.
355  void emitFunctionBody();
356 
357  void emitCFIInstruction(const MachineInstr &MI);
358 
359  void emitFrameAlloc(const MachineInstr &MI);
360 
362 
363  void emitStackUsage(const MachineFunction &MF);
364 
366 
367  void emitPseudoProbe(const MachineInstr &MI);
368 
370 
371  /// Get the CFISection type for a function.
373 
374  /// Get the CFISection type for a function.
376 
377  /// Get the CFISection type for the module.
378  CFISection getModuleCFISectionType() const { return ModuleCFISection; }
379 
380  bool needsSEHMoves();
381 
382  /// Since emitting CFI unwind information is entangled with supporting the
383  /// exceptions, this returns true for platforms which use CFI unwind
384  /// information for debugging purpose when
385  /// `MCAsmInfo::ExceptionsType == ExceptionHandling::None`.
386  bool needsCFIForDebug() const;
387 
388  /// Print to the current output stream assembly representations of the
389  /// constants in the constant pool MCP. This is used to print out constants
390  /// which have been "spilled to memory" by the code generator.
391  virtual void emitConstantPool();
392 
393  /// Print assembly representations of the jump tables used by the current
394  /// function to the current output stream.
395  virtual void emitJumpTableInfo();
396 
397  /// Emit the specified global variable to the .s file.
398  virtual void emitGlobalVariable(const GlobalVariable *GV);
399 
400  /// Check to see if the specified global is a special global used by LLVM. If
401  /// so, emit it and return true, otherwise do nothing and return false.
402  bool emitSpecialLLVMGlobal(const GlobalVariable *GV);
403 
404  /// `llvm.global_ctors` and `llvm.global_dtors` are arrays of Structor
405  /// structs.
406  ///
407  /// Priority - init priority
408  /// Func - global initialization or global clean-up function
409  /// ComdatKey - associated data
410  struct Structor {
411  int Priority = 0;
412  Constant *Func = nullptr;
413  GlobalValue *ComdatKey = nullptr;
414 
415  Structor() = default;
416  };
417 
418  /// This method gathers an array of Structors and then sorts them out by
419  /// Priority.
420  /// @param List The initializer of `llvm.global_ctors` or `llvm.global_dtors`
421  /// array.
422  /// @param[out] Structors Sorted Structor structs by Priority.
423  void preprocessXXStructorList(const DataLayout &DL, const Constant *List,
424  SmallVector<Structor, 8> &Structors);
425 
426  /// This method emits `llvm.global_ctors` or `llvm.global_dtors` list.
427  virtual void emitXXStructorList(const DataLayout &DL, const Constant *List,
428  bool IsCtor);
429 
430  /// Emit an alignment directive to the specified power of two boundary. If a
431  /// global value is specified, and if that global has an explicit alignment
432  /// requested, it will override the alignment request if required for
433  /// correctness.
434  void emitAlignment(Align Alignment, const GlobalObject *GV = nullptr) const;
435 
436  /// Lower the specified LLVM Constant to an MCExpr.
437  virtual const MCExpr *lowerConstant(const Constant *CV);
438 
439  /// Print a general LLVM constant to the .s file.
440  void emitGlobalConstant(const DataLayout &DL, const Constant *CV);
441 
442  /// Unnamed constant global variables solely contaning a pointer to
443  /// another globals variable act like a global variable "proxy", or GOT
444  /// equivalents, i.e., it's only used to hold the address of the latter. One
445  /// optimization is to replace accesses to these proxies by using the GOT
446  /// entry for the final global instead. Hence, we select GOT equivalent
447  /// candidates among all the module global variables, avoid emitting them
448  /// unnecessarily and finally replace references to them by pc relative
449  /// accesses to GOT entries.
451 
452  /// Constant expressions using GOT equivalent globals may not be
453  /// eligible for PC relative GOT entry conversion, in such cases we need to
454  /// emit the proxies we previously omitted in EmitGlobalVariable.
455  void emitGlobalGOTEquivs();
456 
457  /// Emit the stack maps.
458  void emitStackMaps(StackMaps &SM);
459 
460  //===------------------------------------------------------------------===//
461  // Overridable Hooks
462  //===------------------------------------------------------------------===//
463 
465  Handlers.insert(Handlers.begin(), std::move(Handler));
466  NumUserHandlers++;
467  }
468 
469  // Targets can, or in the case of EmitInstruction, must implement these to
470  // customize output.
471 
472  /// This virtual method can be overridden by targets that want to emit
473  /// something at the start of their file.
474  virtual void emitStartOfAsmFile(Module &) {}
475 
476  /// This virtual method can be overridden by targets that want to emit
477  /// something at the end of their file.
478  virtual void emitEndOfAsmFile(Module &) {}
479 
480  /// Targets can override this to emit stuff before the first basic block in
481  /// the function.
482  virtual void emitFunctionBodyStart() {}
483 
484  /// Targets can override this to emit stuff after the last basic block in the
485  /// function.
486  virtual void emitFunctionBodyEnd() {}
487 
488  /// Targets can override this to emit stuff at the start of a basic block.
489  /// By default, this method prints the label for the specified
490  /// MachineBasicBlock, an alignment (if present) and a comment describing it
491  /// if appropriate.
492  virtual void emitBasicBlockStart(const MachineBasicBlock &MBB);
493 
494  /// Targets can override this to emit stuff at the end of a basic block.
495  virtual void emitBasicBlockEnd(const MachineBasicBlock &MBB);
496 
497  /// Targets should implement this to emit instructions.
498  virtual void emitInstruction(const MachineInstr *) {
499  llvm_unreachable("EmitInstruction not implemented");
500  }
501 
502  /// Return the symbol for the specified constant pool entry.
503  virtual MCSymbol *GetCPISymbol(unsigned CPID) const;
504 
505  virtual void emitFunctionEntryLabel();
506 
507  virtual void emitFunctionDescriptor() {
508  llvm_unreachable("Function descriptor is target-specific.");
509  }
510 
512 
513  /// Targets can override this to change how global constants that are part of
514  /// a C++ static/global constructor list are emitted.
515  virtual void emitXXStructor(const DataLayout &DL, const Constant *CV) {
516  emitGlobalConstant(DL, CV);
517  }
518 
519  /// Return true if the basic block has exactly one predecessor and the control
520  /// transfer mechanism between the predecessor and this block is a
521  /// fall-through.
522  virtual bool
524 
525  /// Targets can override this to customize the output of IMPLICIT_DEF
526  /// instructions in verbose mode.
527  virtual void emitImplicitDef(const MachineInstr *MI) const;
528 
529  /// Emit N NOP instructions.
530  void emitNops(unsigned N);
531 
532  //===------------------------------------------------------------------===//
533  // Symbol Lowering Routines.
534  //===------------------------------------------------------------------===//
535 
536  MCSymbol *createTempSymbol(const Twine &Name) const;
537 
538  /// Return the MCSymbol for a private symbol with global value name as its
539  /// base, with the specified suffix.
541  StringRef Suffix) const;
542 
543  /// Return the MCSymbol for the specified ExternalSymbol.
545 
546  /// Return the symbol for the specified jump table entry.
547  MCSymbol *GetJTISymbol(unsigned JTID, bool isLinkerPrivate = false) const;
548 
549  /// Return the symbol for the specified jump table .set
550  /// FIXME: privatize to AsmPrinter.
551  MCSymbol *GetJTSetSymbol(unsigned UID, unsigned MBBID) const;
552 
553  /// Return the MCSymbol used to satisfy BlockAddress uses of the specified
554  /// basic block.
555  MCSymbol *GetBlockAddressSymbol(const BlockAddress *BA) const;
557 
558  //===------------------------------------------------------------------===//
559  // Emission Helper Routines.
560  //===------------------------------------------------------------------===//
561 
562  /// This is just convenient handler for printing offsets.
563  void printOffset(int64_t Offset, raw_ostream &OS) const;
564 
565  /// Emit a byte directive and value.
566  void emitInt8(int Value) const;
567 
568  /// Emit a short directive and value.
569  void emitInt16(int Value) const;
570 
571  /// Emit a long directive and value.
572  void emitInt32(int Value) const;
573 
574  /// Emit a long long directive and value.
575  void emitInt64(uint64_t Value) const;
576 
577  /// Emit something like ".long Hi-Lo" where the size in bytes of the directive
578  /// is specified by Size and Hi/Lo specify the labels. This implicitly uses
579  /// .set if it is available.
580  void emitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo,
581  unsigned Size) const;
582 
583  /// Emit something like ".uleb128 Hi-Lo".
585  const MCSymbol *Lo) const;
586 
587  /// Emit something like ".long Label+Offset" where the size in bytes of the
588  /// directive is specified by Size and Label specifies the label. This
589  /// implicitly uses .set if it is available.
590  void emitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset,
591  unsigned Size, bool IsSectionRelative = false) const;
592 
593  /// Emit something like ".long Label" where the size in bytes of the directive
594  /// is specified by Size and Label specifies the label.
595  void emitLabelReference(const MCSymbol *Label, unsigned Size,
596  bool IsSectionRelative = false) const {
597  emitLabelPlusOffset(Label, 0, Size, IsSectionRelative);
598  }
599 
600  //===------------------------------------------------------------------===//
601  // Dwarf Emission Helper Routines
602  //===------------------------------------------------------------------===//
603 
604  /// Emit the specified signed leb128 value.
605  void emitSLEB128(int64_t Value, const char *Desc = nullptr) const;
606 
607  /// Emit the specified unsigned leb128 value.
608  void emitULEB128(uint64_t Value, const char *Desc = nullptr,
609  unsigned PadTo = 0) const;
610 
611  /// Emit a .byte 42 directive that corresponds to an encoding. If verbose
612  /// assembly output is enabled, we output comments describing the encoding.
613  /// Desc is a string saying what the encoding is specifying (e.g. "LSDA").
614  void emitEncodingByte(unsigned Val, const char *Desc = nullptr) const;
615 
616  /// Return the size of the encoding in bytes.
617  unsigned GetSizeOfEncodedValue(unsigned Encoding) const;
618 
619  /// Emit reference to a ttype global with a specified encoding.
620  virtual void emitTTypeReference(const GlobalValue *GV, unsigned Encoding);
621 
622  /// Emit a reference to a symbol for use in dwarf. Different object formats
623  /// represent this in different ways. Some use a relocation others encode
624  /// the label offset in its section.
625  void emitDwarfSymbolReference(const MCSymbol *Label,
626  bool ForceOffset = false) const;
627 
628  /// Emit the 4- or 8-byte offset of a string from the start of its section.
629  ///
630  /// When possible, emit a DwarfStringPool section offset without any
631  /// relocations, and without using the symbol. Otherwise, defers to \a
632  /// emitDwarfSymbolReference().
633  ///
634  /// The length of the emitted value depends on the DWARF format.
636 
637  /// Emit the 4-or 8-byte offset of a string from the start of its section.
639  emitDwarfStringOffset(S.getEntry());
640  }
641 
642  /// Emit something like ".long Label + Offset" or ".quad Label + Offset"
643  /// depending on the DWARF format.
644  void emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const;
645 
646  /// Emit 32- or 64-bit value depending on the DWARF format.
648 
649  /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen
650  /// according to the settings.
651  void emitDwarfUnitLength(uint64_t Length, const Twine &Comment) const;
652 
653  /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen
654  /// according to the settings.
655  /// Return the end symbol generated inside, the caller needs to emit it.
657  const Twine &Comment) const;
658 
659  /// Emit reference to a call site with a specified encoding
660  void emitCallSiteOffset(const MCSymbol *Hi, const MCSymbol *Lo,
661  unsigned Encoding) const;
662  /// Emit an integer value corresponding to the call site encoding
663  void emitCallSiteValue(uint64_t Value, unsigned Encoding) const;
664 
665  /// Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
666  virtual unsigned getISAEncoding() { return 0; }
667 
668  /// Emit the directive and value for debug thread local expression
669  ///
670  /// \p Value - The value to emit.
671  /// \p Size - The size of the integer (in bytes) to emit.
672  virtual void emitDebugValue(const MCExpr *Value, unsigned Size) const;
673 
674  //===------------------------------------------------------------------===//
675  // Dwarf Lowering Routines
676  //===------------------------------------------------------------------===//
677 
678  /// Emit frame instruction to describe the layout of the frame.
679  void emitCFIInstruction(const MCCFIInstruction &Inst) const;
680 
681  /// Emit Dwarf abbreviation table.
682  template <typename T> void emitDwarfAbbrevs(const T &Abbrevs) const {
683  // For each abbreviation.
684  for (const auto &Abbrev : Abbrevs)
685  emitDwarfAbbrev(*Abbrev);
686 
687  // Mark end of abbreviations.
688  emitULEB128(0, "EOM(3)");
689  }
690 
691  void emitDwarfAbbrev(const DIEAbbrev &Abbrev) const;
692 
693  /// Recursively emit Dwarf DIE tree.
694  void emitDwarfDIE(const DIE &Die) const;
695 
696  //===------------------------------------------------------------------===//
697  // Inline Asm Support
698  //===------------------------------------------------------------------===//
699 
700  // These are hooks that targets can override to implement inline asm
701  // support. These should probably be moved out of AsmPrinter someday.
702 
703  /// Print information related to the specified machine instr that is
704  /// independent of the operand, and may be independent of the instr itself.
705  /// This can be useful for portably encoding the comment character or other
706  /// bits of target-specific knowledge into the asmstrings. The syntax used is
707  /// ${:comment}. Targets can override this to add support for their own
708  /// strange codes.
709  virtual void PrintSpecial(const MachineInstr *MI, raw_ostream &OS,
710  StringRef Code) const;
711 
712  /// Print the MachineOperand as a symbol. Targets with complex handling of
713  /// symbol references should override the base implementation.
714  virtual void PrintSymbolOperand(const MachineOperand &MO, raw_ostream &OS);
715 
716  /// Print the specified operand of MI, an INLINEASM instruction, using the
717  /// specified assembler variant. Targets should override this to format as
718  /// appropriate. This method can return true if the operand is erroneous.
719  virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
720  const char *ExtraCode, raw_ostream &OS);
721 
722  /// Print the specified operand of MI, an INLINEASM instruction, using the
723  /// specified assembler variant as an address. Targets should override this to
724  /// format as appropriate. This method can return true if the operand is
725  /// erroneous.
726  virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
727  const char *ExtraCode, raw_ostream &OS);
728 
729  /// Let the target do anything it needs to do before emitting inlineasm.
730  /// \p StartInfo - the subtarget info before parsing inline asm
731  virtual void emitInlineAsmStart() const;
732 
733  /// Let the target do anything it needs to do after emitting inlineasm.
734  /// This callback can be used restore the original mode in case the
735  /// inlineasm contains directives to switch modes.
736  /// \p StartInfo - the original subtarget info before inline asm
737  /// \p EndInfo - the final subtarget info after parsing the inline asm,
738  /// or NULL if the value is unknown.
739  virtual void emitInlineAsmEnd(const MCSubtargetInfo &StartInfo,
740  const MCSubtargetInfo *EndInfo) const;
741 
742  /// This emits visibility information about symbol, if this is supported by
743  /// the target.
744  void emitVisibility(MCSymbol *Sym, unsigned Visibility,
745  bool IsDefinition = true) const;
746 
747  /// This emits linkage information about \p GVSym based on \p GV, if this is
748  /// supported by the target.
749  virtual void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const;
750 
751  /// Return the alignment for the specified \p GV.
752  static Align getGVAlignment(const GlobalObject *GV, const DataLayout &DL,
753  Align InAlign = Align(1));
754 
755 private:
756  /// Private state for PrintSpecial()
757  // Assign a unique ID to this machine instruction.
758  mutable const MachineInstr *LastMI = nullptr;
759  mutable unsigned LastFn = 0;
760  mutable unsigned Counter = ~0U;
761 
762  /// This method emits the header for the current function.
763  virtual void emitFunctionHeader();
764 
765  /// This method emits a comment next to header for the current function.
766  virtual void emitFunctionHeaderComment();
767 
768  /// Emit a blob of inline asm to the output streamer.
769  void
770  emitInlineAsm(StringRef Str, const MCSubtargetInfo &STI,
771  const MCTargetOptions &MCOptions,
772  const MDNode *LocMDNode = nullptr,
773  InlineAsm::AsmDialect AsmDialect = InlineAsm::AD_ATT) const;
774 
775  /// This method formats and emits the specified machine instruction that is an
776  /// inline asm.
777  void emitInlineAsm(const MachineInstr *MI) const;
778 
779  /// Add inline assembly info to the diagnostics machinery, so we can
780  /// emit file and position info. Returns SrcMgr memory buffer position.
781  unsigned addInlineAsmDiagBuffer(StringRef AsmStr,
782  const MDNode *LocMDNode) const;
783 
784  //===------------------------------------------------------------------===//
785  // Internal Implementation Details
786  //===------------------------------------------------------------------===//
787 
788  void emitJumpTableEntry(const MachineJumpTableInfo *MJTI,
789  const MachineBasicBlock *MBB, unsigned uid) const;
790  void emitLLVMUsedList(const ConstantArray *InitList);
791  /// Emit llvm.ident metadata in an '.ident' directive.
792  void emitModuleIdents(Module &M);
793  /// Emit bytes for llvm.commandline metadata.
794  void emitModuleCommandLines(Module &M);
795 
796  GCMetadataPrinter *GetOrCreateGCPrinter(GCStrategy &S);
797  void emitGlobalAlias(Module &M, const GlobalAlias &GA);
798  void emitGlobalIFunc(Module &M, const GlobalIFunc &GI);
799 
800  /// This method decides whether the specified basic block requires a label.
801  bool shouldEmitLabelForBasicBlock(const MachineBasicBlock &MBB) const;
802 };
803 
804 } // end namespace llvm
805 
806 #endif // LLVM_CODEGEN_ASMPRINTER_H
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::AsmPrinter::emitLabelDifference
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...
Definition: AsmPrinter.cpp:2432
llvm::AsmPrinter::isPositionIndependent
bool isPositionIndependent() const
Definition: AsmPrinter.cpp:214
llvm::AsmPrinter::NumUserHandlers
size_t NumUserHandlers
Definition: AsmPrinter.h:195
llvm::AsmPrinter::emitLabelDifferenceAsULEB128
void emitLabelDifferenceAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo) const
Emit something like ".uleb128 Hi-Lo".
Definition: AsmPrinterDwarf.cpp:56
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:105
llvm::AsmPrinter::GlobalGOTEquivs
MapVector< const MCSymbol *, GOTEquivUsePair > GlobalGOTEquivs
Definition: AsmPrinter.h:140
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
llvm::AsmPrinter::getFunctionEnd
MCSymbol * getFunctionEnd() const
Definition: AsmPrinter.h:247
llvm::InlineAsm::AsmDialect
AsmDialect
Definition: InlineAsm.h:33
llvm::AsmPrinter::printOffset
void printOffset(int64_t Offset, raw_ostream &OS) const
This is just convenient handler for printing offsets.
Definition: AsmPrinter.cpp:3110
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::AsmPrinter::MBBSectionRange::BeginLabel
MCSymbol * BeginLabel
Definition: AsmPrinter.h:132
llvm::AsmPrinter::CFISection
CFISection
Definition: AsmPrinter.h:160
llvm::AsmPrinter::HandlerInfo::TimerGroupDescription
StringRef TimerGroupDescription
Definition: AsmPrinter.h:149
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:113
llvm::AsmPrinter::emitXXStructor
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:515
llvm::AsmPrinter::emitBasicBlockEnd
virtual void emitBasicBlockEnd(const MachineBasicBlock &MBB)
Targets can override this to emit stuff at the end of a basic block.
Definition: AsmPrinter.cpp:3339
llvm::remarks::RemarkStreamer
Definition: RemarkStreamer.h:42
llvm::AsmPrinter::lowerConstant
virtual const MCExpr * lowerConstant(const Constant *CV)
Lower the specified LLVM Constant to an MCExpr.
Definition: AsmPrinter.cpp:2487
llvm::GCStrategy
GCStrategy describes a garbage collector algorithm's code generation requirements,...
Definition: GCStrategy.h:66
llvm::AsmPrinter::emitULEB128
void emitULEB128(uint64_t Value, const char *Desc=nullptr, unsigned PadTo=0) const
Emit the specified unsigned leb128 value.
Definition: AsmPrinterDwarf.cpp:47
llvm::AsmPrinter::recordSled
void recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind, uint8_t Version=0)
Definition: AsmPrinter.cpp:3568
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:164
llvm::AsmPrinter::CurrentFnSymForSize
MCSymbol * CurrentFnSymForSize
The symbol used to represent the start of the current function for the purpose of calculating its siz...
Definition: AsmPrinter.h:127
llvm::AsmPrinter::createTempSymbol
MCSymbol * createTempSymbol(const Twine &Name) const
Definition: AsmPrinter.cpp:3127
llvm::AsmPrinter::getDwarfDebug
DwarfDebug * getDwarfDebug()
Definition: AsmPrinter.h:220
llvm::MCContext
Context object for machine code objects.
Definition: MCContext.h:72
llvm::Function
Definition: Function.h:62
llvm::AsmPrinter::SledKind::CUSTOM_EVENT
@ CUSTOM_EVENT
llvm::AsmPrinter::MBBSectionRange
Map a basic block section ID to the begin and end symbols of that section which determine the section...
Definition: AsmPrinter.h:131
llvm::AsmPrinter::emitInlineAsmEnd
virtual void emitInlineAsmEnd(const MCSubtargetInfo &StartInfo, const MCSubtargetInfo *EndInfo) const
Let the target do anything it needs to do after emitting inlineasm.
Definition: AsmPrinterInlineAsm.cpp:516
llvm::InlineAsm::AD_ATT
@ AD_ATT
Definition: InlineAsm.h:34
llvm::AsmPrinter::MAI
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:87
llvm::MCAsmInfo
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:56
llvm::AsmPrinter::emitGlobalConstant
void emitGlobalConstant(const DataLayout &DL, const Constant *CV)
Print a general LLVM constant to the .s file.
Definition: AsmPrinter.cpp:3094
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
InlineAsm.h
llvm::AsmPrinter::CFISection::Debug
@ Debug
Emit .debug_frame.
llvm::AsmPrinter::emitPatchableFunctionEntries
void emitPatchableFunctionEntries()
Definition: AsmPrinter.cpp:3581
llvm::MipsISD::Lo
@ Lo
Definition: MipsISelLowering.h:79
llvm::AsmPrinter::Structor::Priority
int Priority
Definition: AsmPrinter.h:411
ErrorHandling.h
llvm::AsmPrinter::emitSLEB128
void emitSLEB128(int64_t Value, const char *Desc=nullptr) const
Emit the specified signed leb128 value.
Definition: AsmPrinterDwarf.cpp:40
MapVector.h
llvm::GlobalVariable
Definition: GlobalVariable.h:40
llvm::AsmPrinter::XRayFunctionEntry::Function
const MCSymbol * Function
Definition: AsmPrinter.h:303
llvm::MachineOptimizationRemarkEmitter
The optimization diagnostic interface.
Definition: MachineOptimizationRemarkEmitter.h:150
llvm::AsmPrinter::XRayFunctionEntry::Sled
const MCSymbol * Sled
Definition: AsmPrinter.h:302
llvm::MachineFunctionPass
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Definition: MachineFunctionPass.h:30
llvm::GlobalAlias
Definition: GlobalAlias.h:28
llvm::AsmPrinter::getNameWithPrefix
void getNameWithPrefix(SmallVectorImpl< char > &Name, const GlobalValue *GV) const
Definition: AsmPrinter.cpp:480
llvm::AsmPrinter::doFinalization
bool doFinalization(Module &M) override
Shut down the asmprinter.
Definition: AsmPrinter.cpp:1723
llvm::AsmPrinter::emitStackMaps
void emitStackMaps(StackMaps &SM)
Emit the stack maps.
Definition: AsmPrinter.cpp:3449
llvm::MachineConstantPoolValue
Abstract base class for all machine specific constantpool value subclasses.
Definition: MachineConstantPool.h:35
llvm::AsmPrinter::PrintSymbolOperand
virtual void PrintSymbolOperand(const MachineOperand &MO, raw_ostream &OS)
Print the MachineOperand as a symbol.
Definition: AsmPrinterInlineAsm.cpp:456
llvm::AsmPrinter::getFunctionCFISectionType
CFISection getFunctionCFISectionType(const Function &F) const
Get the CFISection type for a function.
Definition: AsmPrinter.cpp:1052
llvm::AsmPrinter::getDwarfOffsetByteSize
unsigned int getDwarfOffsetByteSize() const
Returns 4 for DWARF32 and 8 for DWARF64.
Definition: AsmPrinter.cpp:3628
llvm::AsmPrinter::setDwarfVersion
void setDwarfVersion(uint16_t Version)
Definition: AsmPrinter.cpp:3620
llvm::AsmPrinter::Structor::ComdatKey
GlobalValue * ComdatKey
Definition: AsmPrinter.h:413
llvm::AsmPrinter::Structor::Func
Constant * Func
Definition: AsmPrinter.h:412
AsmPrinterHandler.h
llvm::AsmPrinter::SledKind
SledKind
Definition: AsmPrinter.h:288
llvm::AsmPrinter::emitDwarfOffset
void emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const
Emit something like ".long Label + Offset" or ".quad Label + Offset" depending on the DWARF format.
Definition: AsmPrinterDwarf.cpp:192
llvm::AsmPrinter::Structor
llvm.global_ctors and llvm.global_dtors are arrays of Structor structs.
Definition: AsmPrinter.h:410
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::MapVector
This class implements a map that also provides access to all stored values in a deterministic order.
Definition: MapVector.h:37
llvm::DIE
A structured debug information entry.
Definition: DIE.h:739
llvm::AsmPrinter::emitLabelReference
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:595
llvm::MCInst
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
llvm::GCMetadataPrinter
GCMetadataPrinter - Emits GC metadata as assembly code.
Definition: GCMetadataPrinter.h:39
llvm::AsmPrinter::ORE
MachineOptimizationRemarkEmitter * ORE
Optimization remark emitter.
Definition: AsmPrinter.h:111
llvm::AsmPrinter::XRayFunctionEntry::Fn
const class Function * Fn
Definition: AsmPrinter.h:306
llvm::AsmPrinter::CurrentFnDescSym
MCSymbol * CurrentFnDescSym
The symbol for the current function descriptor on AIX.
Definition: AsmPrinter.h:122
llvm::AsmPrinter::emitCallSiteOffset
void emitCallSiteOffset(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Encoding) const
Emit reference to a call site with a specified encoding.
Definition: AsmPrinterDwarf.cpp:211
llvm::StackMaps
Definition: StackMaps.h:251
llvm::DwarfStringPoolEntryRef
String pool entry reference.
Definition: DwarfStringPoolEntry.h:31
llvm::AsmPrinter::emitBBAddrMapSection
void emitBBAddrMapSection(const MachineFunction &MF)
Definition: AsmPrinter.cpp:1134
llvm::AsmPrinter::emitGlobalVariable
virtual void emitGlobalVariable(const GlobalVariable *GV)
Emit the specified global variable to the .s file.
Definition: AsmPrinter.cpp:507
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::MachineLoopInfo
Definition: MachineLoopInfo.h:90
llvm::AsmPrinter::EmitToStreamer
void EmitToStreamer(MCStreamer &S, const MCInst &Inst)
Definition: AsmPrinter.cpp:242
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::MipsISD::Hi
@ Hi
Definition: MipsISelLowering.h:75
llvm::AsmPrinter::emitDwarfStringOffset
void emitDwarfStringOffset(DwarfStringPoolEntryRef S) const
Emit the 4-or 8-byte offset of a string from the start of its section.
Definition: AsmPrinter.h:638
llvm::TargetLoweringObjectFile
Definition: TargetLoweringObjectFile.h:44
llvm::AsmPrinter::GOTEquivUsePair
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:139
llvm::MCStreamer
Streaming machine code generation interface.
Definition: MCStreamer.h:199
llvm::DIEAbbrev
Dwarf abbreviation, describes the organization of a debug information object.
Definition: DIE.h:79
llvm::AsmPrinter::emitDwarfAbbrev
void emitDwarfAbbrev(const DIEAbbrev &Abbrev) const
Definition: AsmPrinterDwarf.cpp:318
llvm::AsmPrinter::emitLinkage
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:440
llvm::ISD::Constant
@ Constant
Definition: ISDOpcodes.h:76
llvm::AsmPrinter::XRayFunctionEntry::Version
uint8_t Version
Definition: AsmPrinter.h:307
llvm::AsmPrinter::OutStreamer
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:96
llvm::AsmPrinter::PrintAsmMemoryOperand
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...
Definition: AsmPrinterInlineAsm.cpp:508
llvm::AsmPrinter::addAsmPrinterHandler
void addAsmPrinterHandler(HandlerInfo Handler)
Definition: AsmPrinter.h:464
llvm::GlobalObject
Definition: GlobalObject.h:28
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
llvm::AsmPrinter::SetupMachineFunction
virtual void SetupMachineFunction(MachineFunction &MF)
This should be called when a new MachineFunction is being processed from runOnMachineFunction.
Definition: AsmPrinter.cpp:1978
llvm::AsmPrinter::emitFunctionEntryLabel
virtual void emitFunctionEntryLabel()
EmitFunctionEntryLabel - Emit the label that is the entrypoint for the function.
Definition: AsmPrinter.cpp:842
llvm::AsmPrinter::Structor::Structor
Structor()=default
llvm::AsmPrinter::emitStartOfAsmFile
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:474
llvm::AsmPrinter::isBlockOnlyReachableByFallthrough
virtual bool isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const
Return true if the basic block has exactly one predecessor and the control transfer mechanism between...
Definition: AsmPrinter.cpp:3387
remarks
annotation remarks
Definition: AnnotationRemarks.cpp:117
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:49
llvm::ConstantArray
ConstantArray - Constant Array Declarations.
Definition: Constants.h:409
llvm::MachineModuleInfo
This class contains meta information specific to a module.
Definition: MachineModuleInfo.h:78
llvm::AsmPrinter::emitInstruction
virtual void emitInstruction(const MachineInstr *)
Targets should implement this to emit instructions.
Definition: AsmPrinter.h:498
llvm::AsmPrinter::MLI
MachineLoopInfo * MLI
This is a pointer to the current MachineLoopInfo.
Definition: AsmPrinter.h:108
llvm::AsmPrinter::getDwarfDebug
DwarfDebug * getDwarfDebug() const
Definition: AsmPrinter.h:221
llvm::AsmPrinter::CurrentFnSym
MCSymbol * CurrentFnSym
The symbol for the current function.
Definition: AsmPrinter.h:118
llvm::AsmPrinter::emitAlignment
void emitAlignment(Align Alignment, const GlobalObject *GV=nullptr) const
Emit an alignment directive to the specified power of two boundary.
Definition: AsmPrinter.cpp:2465
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::AsmPrinter::emitEndOfAsmFile
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:478
llvm::AsmPrinter::getModuleCFISectionType
CFISection getModuleCFISectionType() const
Get the CFISection type for the module.
Definition: AsmPrinter.h:378
DwarfStringPoolEntry.h
llvm::AsmPrinter::XRayFunctionEntry::AlwaysInstrument
bool AlwaysInstrument
Definition: AsmPrinter.h:305
llvm::AsmPrinter::emitFunctionBodyStart
virtual void emitFunctionBodyStart()
Targets can override this to emit stuff before the first basic block in the function.
Definition: AsmPrinter.h:482
llvm::AsmPrinter::emitDwarfAbbrevs
void emitDwarfAbbrevs(const T &Abbrevs) const
Emit Dwarf abbreviation table.
Definition: AsmPrinter.h:682
llvm::AsmPrinter::emitDwarfSymbolReference
void emitDwarfSymbolReference(const MCSymbol *Label, bool ForceOffset=false) const
Emit a reference to a symbol for use in dwarf.
Definition: AsmPrinterDwarf.cpp:158
llvm::AsmPrinter::CurrentPatchableFunctionEntrySym
MCSymbol * CurrentPatchableFunctionEntrySym
The symbol for the entry in __patchable_function_entires.
Definition: AsmPrinter.h:114
Align
uint64_t Align
Definition: ELFObjHandler.cpp:83
llvm::AsmPrinter::emitInt8
void emitInt8(int Value) const
Emit a byte directive and value.
Definition: AsmPrinter.cpp:2416
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::AsmPrinter::HandlerInfo::TimerDescription
StringRef TimerDescription
Definition: AsmPrinter.h:147
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::AsmPrinter::getFunctionBegin
MCSymbol * getFunctionBegin() const
Definition: AsmPrinter.h:246
llvm::AsmPrinter::emitBasicBlockStart
virtual void emitBasicBlockStart(const MachineBasicBlock &MBB)
Targets can override this to emit stuff at the start of a basic block.
Definition: AsmPrinter.cpp:3259
llvm::MCCFIInstruction
Definition: MCDwarf.h:470
SourceMgr.h
llvm::AsmPrinter::getPointerSize
unsigned getPointerSize() const
Return the pointer size from the TargetMachine.
Definition: AsmPrinter.cpp:233
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
llvm::AsmPrinter::XRayFunctionEntry::Kind
SledKind Kind
Definition: AsmPrinter.h:304
llvm::AsmPrinter::HandlerInfo::Handler
std::unique_ptr< AsmPrinterHandler > Handler
Definition: AsmPrinter.h:145
llvm::AsmPrinter::Handlers
std::vector< HandlerInfo > Handlers
A vector of all debug/EH info emitters we should use.
Definition: AsmPrinter.h:194
llvm::AsmPrinter::CFISection::None
@ None
Do not emit either .eh_frame or .debug_frame.
llvm::ISD::BlockAddress
@ BlockAddress
Definition: ISDOpcodes.h:84
llvm::AsmPrinter::AsmPrinter
AsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > Streamer)
Definition: AsmPrinter.cpp:196
llvm::AsmPrinter::emitMachineConstantPoolValue
virtual void emitMachineConstantPoolValue(MachineConstantPoolValue *MCPV)
Definition: AsmPrinter.cpp:3105
llvm::PseudoProbeHandler
Definition: PseudoProbePrinter.h:26
llvm::AsmPrinter::emitFrameAlloc
void emitFrameAlloc(const MachineInstr &MI)
Definition: AsmPrinter.cpp:1107
llvm::AsmPrinter::GetJTSetSymbol
MCSymbol * GetJTSetSymbol(unsigned UID, unsigned MBBID) const
Return the symbol for the specified jump table .set FIXME: privatize to AsmPrinter.
Definition: AsmPrinter.cpp:3174
llvm::AsmPrinter::emitInt64
void emitInt64(uint64_t Value) const
Emit a long long directive and value.
Definition: AsmPrinter.cpp:2425
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::DwarfStringPoolEntry
Data for a string pool entry.
Definition: DwarfStringPoolEntry.h:20
llvm::AsmPrinter::PrintSpecial
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,...
Definition: AsmPrinterInlineAsm.cpp:429
llvm::AsmPrinter::GetCPISymbol
virtual MCSymbol * GetCPISymbol(unsigned CPID) const
Return the symbol for the specified constant pool entry.
Definition: AsmPrinter.cpp:3140
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::DwarfDebug
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:296
llvm::AsmPrinter::emitLabelPlusOffset
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...
Definition: AsmPrinter.cpp:2440
uint64_t
llvm::AsmPrinter::needsCFIForDebug
bool needsCFIForDebug() const
Since emitting CFI unwind information is entangled with supporting the exceptions,...
Definition: AsmPrinter.cpp:1076
llvm::AsmPrinter::GetSizeOfEncodedValue
unsigned GetSizeOfEncodedValue(unsigned Encoding) const
Return the size of the encoding in bytes.
Definition: AsmPrinterDwarf.cpp:129
llvm::AsmPrinter::GetBlockAddressSymbol
MCSymbol * GetBlockAddressSymbol(const BlockAddress *BA) const
Return the MCSymbol used to satisfy BlockAddress uses of the specified basic block.
Definition: AsmPrinter.cpp:3131
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::AsmPrinter::getSymbolPreferLocal
MCSymbol * getSymbolPreferLocal(const GlobalValue &GV) const
Similar to getSymbol() but preferred for references.
Definition: AsmPrinter.cpp:489
llvm::DenseMap
Definition: DenseMap.h:714
llvm::AsmPrinter::HandlerInfo::HandlerInfo
HandlerInfo(std::unique_ptr< AsmPrinterHandler > Handler, StringRef TimerName, StringRef TimerDescription, StringRef TimerGroupName, StringRef TimerGroupDescription)
Definition: AsmPrinter.h:151
llvm::AsmPrinter::needsSEHMoves
bool needsSEHMoves()
Definition: AsmPrinter.cpp:1072
MachineFunctionPass.h
llvm::AsmPrinter::emitJumpTableInfo
virtual void emitJumpTableInfo()
Print assembly representations of the jump tables used by the current function to the current output ...
Definition: AsmPrinter.cpp:2111
llvm::AsmPrinter::getFunctionFrameSymbol
virtual const MCSymbol * getFunctionFrameSymbol() const
Return symbol for the function pseudo stack if the stack frame is not a register based.
Definition: AsmPrinter.h:244
llvm::AsmPrinter::getSymbol
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:485
llvm::TargetMachine
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:80
llvm::AsmPrinter::emitDwarfUnitLength
void emitDwarfUnitLength(uint64_t Length, const Twine &Comment) const
Emit a unit length field.
Definition: AsmPrinterDwarf.cpp:201
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1658
llvm::AsmPrinter::getMBBExceptionSym
MCSymbol * getMBBExceptionSym(const MachineBasicBlock &MBB)
Definition: AsmPrinter.cpp:1971
llvm::AsmPrinter::MF
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:99
llvm::AsmPrinter::OutContext
MCContext & OutContext
This is the context for the output file that we are streaming.
Definition: AsmPrinter.h:91
llvm::ISD::BasicBlock
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
llvm::AsmPrinter::emitRemarksSection
void emitRemarksSection(remarks::RemarkStreamer &RS)
Definition: AsmPrinter.cpp:1695
llvm::AsmPrinter::emitImplicitDef
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:897
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::MDNode
Metadata node.
Definition: Metadata.h:906
llvm::MCTargetOptions
Definition: MCTargetOptions.h:36
llvm::AsmPrinter::emitSpecialLLVMGlobal
bool emitSpecialLLVMGlobal(const GlobalVariable *GV)
Check to see if the specified global is a special global used by LLVM.
Definition: AsmPrinter.cpp:2252
llvm::AsmPrinter::emitDwarfLengthOrOffset
void emitDwarfLengthOrOffset(uint64_t Value) const
Emit 32- or 64-bit value depending on the DWARF format.
Definition: AsmPrinterDwarf.cpp:196
llvm::AsmPrinter::XRayFunctionEntry
Definition: AsmPrinter.h:301
llvm::AsmPrinter::computeGlobalGOTEquivs
void computeGlobalGOTEquivs(Module &M)
Unnamed constant global variables solely contaning a pointer to another globals variable act like a g...
Definition: AsmPrinter.cpp:1571
llvm::AsmPrinter::MDT
MachineDominatorTree * MDT
This is a pointer to the current MachineDominatorTree.
Definition: AsmPrinter.h:105
llvm::MachineFunction
Definition: MachineFunction.h:234
llvm::AsmPrinter::emitCFIInstruction
void emitCFIInstruction(const MachineInstr &MI)
Definition: AsmPrinter.cpp:1081
llvm::AsmPrinter::emitDebugValue
virtual void emitDebugValue(const MCExpr *Value, unsigned Size) const
Emit the directive and value for debug thread local expression.
Definition: AsmPrinter.cpp:705
llvm::AsmPrinter::runOnMachineFunction
bool runOnMachineFunction(MachineFunction &MF) override
Emit the specified function out to the OutStreamer.
Definition: AsmPrinter.h:340
llvm::BlockAddress
The address of a basic block.
Definition: Constants.h:848
llvm::AsmPrinter::GetExternalSymbolSymbol
MCSymbol * GetExternalSymbolSymbol(StringRef Sym) const
Return the MCSymbol for the specified ExternalSymbol.
Definition: AsmPrinter.cpp:3187
llvm::AsmPrinter::emitGlobalGOTEquivs
void emitGlobalGOTEquivs()
Constant expressions using GOT equivalent globals may not be eligible for PC relative GOT entry conve...
Definition: AsmPrinter.cpp:1588
llvm::AsmPrinter::SledKind::TYPED_EVENT
@ TYPED_EVENT
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::AsmPrinter::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
Record analysis usage.
Definition: AsmPrinter.cpp:259
llvm::AsmPrinter::GetJTISymbol
MCSymbol * GetJTISymbol(unsigned JTID, bool isLinkerPrivate=false) const
Return the symbol for the specified jump table entry.
Definition: AsmPrinter.cpp:3168
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:134
llvm::AsmPrinter::SledKind::FUNCTION_EXIT
@ FUNCTION_EXIT
llvm::AsmPrinter::preprocessXXStructorList
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.
Definition: AsmPrinter.cpp:2297
llvm::AsmPrinter::SledKind::LOG_ARGS_ENTER
@ LOG_ARGS_ENTER
llvm::AsmPrinter::Sleds
SmallVector< XRayFunctionEntry, 4 > Sleds
Definition: AsmPrinter.h:313
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::MCSection
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
Module
Machine Check Debug Module
Definition: MachineCheckDebugify.cpp:122
llvm::AsmPrinter::HandlerInfo::TimerGroupName
StringRef TimerGroupName
Definition: AsmPrinter.h:148
llvm::AsmPrinter::getISAEncoding
virtual unsigned getISAEncoding()
Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
Definition: AsmPrinter.h:666
llvm::AsmPrinter::getUnitLengthFieldByteSize
unsigned int getUnitLengthFieldByteSize() const
Returns 4 for DWARF32 and 12 for DWARF64.
Definition: AsmPrinter.cpp:3633
llvm::AsmPrinter::emitStackUsage
void emitStackUsage(const MachineFunction &MF)
Definition: AsmPrinter.cpp:1194
llvm::AsmPrinter::MMI
MachineModuleInfo * MMI
This is a pointer to the current MachineModuleInfo.
Definition: AsmPrinter.h:102
llvm::AsmPrinter::SledKind::TAIL_CALL
@ TAIL_CALL
llvm::AsmPrinter::getGVAlignment
static Align getGVAlignment(const GlobalObject *GV, const DataLayout &DL, Align InAlign=Align(1))
Return the alignment for the specified GV.
Definition: AsmPrinter.cpp:172
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::AsmPrinter::emitPseudoProbe
void emitPseudoProbe(const MachineInstr &MI)
Definition: AsmPrinter.cpp:1160
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
std
Definition: BitVector.h:838
uint16_t
llvm::AsmPrinter::emitNops
void emitNops(unsigned N)
Emit N NOP instructions.
Definition: AsmPrinter.cpp:3117
llvm::AsmPrinter::getSubtargetInfo
const MCSubtargetInfo & getSubtargetInfo() const
Return information about subtarget.
Definition: AsmPrinter.cpp:237
llvm::AsmPrinter::HandlerInfo
struct HandlerInfo and Handlers permit users or target extended AsmPrinter to add their own handlers.
Definition: AsmPrinter.h:144
llvm::AsmPrinter::isDwarf64
bool isDwarf64() const
Definition: AsmPrinter.cpp:3624
llvm::AsmPrinter::emitInlineAsmStart
virtual void emitInlineAsmStart() const
Let the target do anything it needs to do before emitting inlineasm.
Definition: AsmPrinterInlineAsm.cpp:514
llvm::AsmPrinter::emitStackSizeSection
void emitStackSizeSection(const MachineFunction &MF)
Definition: AsmPrinter.cpp:1169
llvm::AsmPrinter::HandlerInfo::TimerName
StringRef TimerName
Definition: AsmPrinter.h:146
llvm::AsmPrinter::getDwarfVersion
uint16_t getDwarfVersion() const
Definition: AsmPrinter.cpp:3616
llvm::AsmPrinter
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:81
llvm::AsmPrinter::emitVisibility
void emitVisibility(MCSymbol *Sym, unsigned Visibility, bool IsDefinition=true) const
This emits visibility information about symbol, if this is supported by the target.
Definition: AsmPrinter.cpp:3347
llvm::AsmPrinter::emitInt32
void emitInt32(int Value) const
Emit a long directive and value.
Definition: AsmPrinter.cpp:2422
llvm::AsmPrinter::emitTTypeReference
virtual void emitTTypeReference(const GlobalValue *GV, unsigned Encoding)
Emit reference to a ttype global with a specified encoding.
Definition: AsmPrinterDwarf.cpp:147
llvm::AsmPrinter::MBBSectionRanges
MapVector< unsigned, MBBSectionRange > MBBSectionRanges
Definition: AsmPrinter.h:135
llvm::AsmPrinter::TM
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:84
Version
uint64_t Version
Definition: RawMemProfReader.cpp:25
SmallVector.h
llvm::AsmPrinter::getSymbolWithGlobalValueBase
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...
Definition: AsmPrinter.cpp:3181
llvm::AsmPrinter::getObjFileLowering
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:223
N
#define N
llvm::AsmPrinter::emitFunctionBody
void emitFunctionBody()
This method emits the body and trailer for a function.
Definition: AsmPrinter.cpp:1240
llvm::AsmPrinter::emitFunctionDescriptor
virtual void emitFunctionDescriptor()
Definition: AsmPrinter.h:507
llvm::AsmPrinter::CurrentFnBegin
MCSymbol * CurrentFnBegin
Definition: AsmPrinter.h:190
llvm::AsmPrinter::~AsmPrinter
~AsmPrinter() override
Definition: AsmPrinter.cpp:202
llvm::AsmPrinter::getDataLayout
const DataLayout & getDataLayout() const
Return information about data layout.
Definition: AsmPrinter.cpp:227
llvm::AsmPrinter::emitDwarfStringOffset
void emitDwarfStringOffset(DwarfStringPoolEntry S) const
Emit the 4- or 8-byte offset of a string from the start of its section.
Definition: AsmPrinterDwarf.cpp:181
llvm::AsmPrinter::SledKind::FUNCTION_ENTER
@ FUNCTION_ENTER
llvm::SmallVectorImpl< char >
llvm::AsmPrinter::MBBSectionRange::EndLabel
MCSymbol * EndLabel
Definition: AsmPrinter.h:132
llvm::AsmPrinter::getCurrentSection
const MCSection * getCurrentSection() const
Return the current section we are emitting to.
Definition: AsmPrinter.cpp:255
llvm::AsmPrinter::emitDwarfDIE
void emitDwarfDIE(const DIE &Die) const
Recursively emit Dwarf DIE tree.
Definition: AsmPrinterDwarf.cpp:283
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::AsmPrinter::emitInitialRawDwarfLocDirective
void emitInitialRawDwarfLocDirective(const MachineFunction &MF)
Emits inital debug location directive.
Definition: AsmPrinter.cpp:246
llvm::AsmPrinter::emitXRayTable
void emitXRayTable()
Emit a table with all XRay instrumentation points.
Definition: AsmPrinter.cpp:3489
llvm::AsmPrinter::emitCallSiteValue
void emitCallSiteValue(uint64_t Value, unsigned Encoding) const
Emit an integer value corresponding to the call site encoding.
Definition: AsmPrinterDwarf.cpp:220
LLVMContext.h
llvm::MachineJumpTableInfo
Definition: MachineJumpTableInfo.h:42
llvm::AsmPrinter::isVerbose
bool isVerbose() const
Return true if assembly output should contain comments.
Definition: AsmPrinter.h:237
llvm::AsmPrinter::emitFunctionBodyEnd
virtual void emitFunctionBodyEnd()
Targets can override this to emit stuff after the last basic block in the function.
Definition: AsmPrinter.h:486
llvm::MachineDominatorTree
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
Definition: MachineDominators.h:46
llvm::GlobalIFunc
Definition: GlobalIFunc.h:34
llvm::MCSubtargetInfo
Generic base class for all target subtargets.
Definition: MCSubtargetInfo.h:75
llvm::AsmPrinter::getFunctionNumber
unsigned getFunctionNumber() const
Return a unique ID for the current function.
Definition: AsmPrinter.cpp:219
llvm::AsmPrinter::emitEncodingByte
void emitEncodingByte(unsigned Val, const char *Desc=nullptr) const
Emit a .byte 42 directive that corresponds to an encoding.
Definition: AsmPrinterDwarf.cpp:116
llvm::AsmPrinter::CFISection::EH
@ EH
Emit .eh_frame.
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::AsmPrinter::emitInt16
void emitInt16(int Value) const
Emit a short directive and value.
Definition: AsmPrinter.cpp:2419
llvm::AsmPrinter::emitXXStructorList
virtual void emitXXStructorList(const DataLayout &DL, const Constant *List, bool IsCtor)
This method emits llvm.global_ctors or llvm.global_dtors list.
Definition: AsmPrinter.cpp:2334
llvm::MCExpr
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
llvm::AsmPrinter::PrintAsmOperand
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.
Definition: AsmPrinterInlineAsm.cpp:466
llvm::AsmPrinter::XRayFunctionEntry::emit
void emit(int, MCStreamer *) const
Definition: AsmPrinter.cpp:3478
llvm::AsmPrinter::emitConstantPool
virtual void emitConstantPool()
Print to the current output stream assembly representations of the constants in the constant pool MCP...
Definition: AsmPrinter.cpp:2034
llvm::ISD::MCSymbol
@ MCSymbol
Definition: ISDOpcodes.h:172
llvm::AsmPrinter::doInitialization
bool doInitialization(Module &M) override
Set up the AsmPrinter when we are working on a new module.
Definition: AsmPrinter.cpp:266