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