LLVM  13.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  static char ID;
186 
187 protected:
189 
190  /// A vector of all debug/EH info emitters we should use. This vector
191  /// maintains ownership of the emitters.
192  std::vector<HandlerInfo> Handlers;
193  size_t NumUserHandlers = 0;
194 
195 private:
196  /// If generated on the fly this own the instance.
197  std::unique_ptr<MachineDominatorTree> OwnedMDT;
198 
199  /// If generated on the fly this own the instance.
200  std::unique_ptr<MachineLoopInfo> OwnedMLI;
201 
202  /// If the target supports dwarf debug info, this pointer is non-null.
203  DwarfDebug *DD = nullptr;
204 
205  /// A handler that supports pseudo probe emission with embedded inline
206  /// context.
207  PseudoProbeHandler *PP = nullptr;
208 
209  /// CFISection type the module needs i.e. either .eh_frame or .debug_frame.
210  CFISection ModuleCFISection = CFISection::None;
211 
212 protected:
213  explicit AsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer);
214 
215 public:
216  ~AsmPrinter() override;
217 
218  DwarfDebug *getDwarfDebug() { return DD; }
219  DwarfDebug *getDwarfDebug() const { return DD; }
220 
221  uint16_t getDwarfVersion() const;
223 
224  bool isDwarf64() const;
225 
226  /// Returns 4 for DWARF32 and 8 for DWARF64.
227  unsigned int getDwarfOffsetByteSize() const;
228 
229  /// Returns 4 for DWARF32 and 12 for DWARF64.
230  unsigned int getUnitLengthFieldByteSize() const;
231 
232  bool isPositionIndependent() const;
233 
234  /// Return true if assembly output should contain comments.
235  bool isVerbose() const { return VerboseAsm; }
236 
237  /// Return a unique ID for the current function.
238  unsigned getFunctionNumber() const;
239 
240  /// Return symbol for the function pseudo stack if the stack frame is not a
241  /// register based.
242  virtual const MCSymbol *getFunctionFrameSymbol() const { return nullptr; }
243 
245  MCSymbol *getFunctionEnd() const { return CurrentFnEnd; }
246 
247  // Return the exception symbol associated with the MBB section containing a
248  // given basic block.
250 
251  /// Return information about object file lowering.
253 
254  /// Return information about data layout.
255  const DataLayout &getDataLayout() const;
256 
257  /// Return the pointer size from the TargetMachine
258  unsigned getPointerSize() const;
259 
260  /// Return information about subtarget.
261  const MCSubtargetInfo &getSubtargetInfo() const;
262 
263  void EmitToStreamer(MCStreamer &S, const MCInst &Inst);
264 
265  /// Emits inital debug location directive.
267 
268  /// Return the current section we are emitting to.
269  const MCSection *getCurrentSection() const;
270 
272  const GlobalValue *GV) const;
273 
274  MCSymbol *getSymbol(const GlobalValue *GV) const;
275 
276  /// Similar to getSymbol() but preferred for references. On ELF, this uses a
277  /// local symbol if a reference to GV is guaranteed to be resolved to the
278  /// definition in the same module.
279  MCSymbol *getSymbolPreferLocal(const GlobalValue &GV) const;
280 
281  //===------------------------------------------------------------------===//
282  // XRay instrumentation implementation.
283  //===------------------------------------------------------------------===//
284 public:
285  // This describes the kind of sled we're storing in the XRay table.
286  enum class SledKind : uint8_t {
287  FUNCTION_ENTER = 0,
288  FUNCTION_EXIT = 1,
289  TAIL_CALL = 2,
290  LOG_ARGS_ENTER = 3,
291  CUSTOM_EVENT = 4,
292  TYPED_EVENT = 5,
293  };
294 
295  // The table will contain these structs that point to the sled, the function
296  // containing the sled, and what kind of sled (and whether they should always
297  // be instrumented). We also use a version identifier that the runtime can use
298  // to decide what to do with the sled, depending on the version of the sled.
300  const MCSymbol *Sled;
304  const class Function *Fn;
305  uint8_t Version;
306 
307  void emit(int, MCStreamer *) const;
308  };
309 
310  // All the sleds to be emitted.
312 
313  // Helper function to record a given XRay sled.
314  void recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind,
315  uint8_t Version = 0);
316 
317  /// Emit a table with all XRay instrumentation points.
318  void emitXRayTable();
319 
321 
322  //===------------------------------------------------------------------===//
323  // MachineFunctionPass Implementation.
324  //===------------------------------------------------------------------===//
325 
326  /// Record analysis usage.
327  void getAnalysisUsage(AnalysisUsage &AU) const override;
328 
329  /// Set up the AsmPrinter when we are working on a new module. If your pass
330  /// overrides this, it must make sure to explicitly call this implementation.
331  bool doInitialization(Module &M) override;
332 
333  /// Shut down the asmprinter. If you override this in your pass, you must make
334  /// sure to call it explicitly.
335  bool doFinalization(Module &M) override;
336 
337  /// Emit the specified function out to the OutStreamer.
341  return false;
342  }
343 
344  //===------------------------------------------------------------------===//
345  // Coarse grained IR lowering routines.
346  //===------------------------------------------------------------------===//
347 
348  /// This should be called when a new MachineFunction is being processed from
349  /// runOnMachineFunction.
350  virtual void SetupMachineFunction(MachineFunction &MF);
351 
352  /// This method emits the body and trailer for a function.
353  void emitFunctionBody();
354 
355  void emitCFIInstruction(const MachineInstr &MI);
356 
357  void emitFrameAlloc(const MachineInstr &MI);
358 
360 
362 
363  void emitPseudoProbe(const MachineInstr &MI);
364 
366 
367  /// Get the CFISection type for a function.
369 
370  /// Get the CFISection type for a function.
372 
373  /// Get the CFISection type for the module.
374  CFISection getModuleCFISectionType() const { return ModuleCFISection; }
375 
376  bool needsSEHMoves();
377 
378  /// Since emitting CFI unwind information is entangled with supporting the
379  /// exceptions, this returns true for platforms which use CFI unwind
380  /// information for debugging purpose when
381  /// `MCAsmInfo::ExceptionsType == ExceptionHandling::None`.
382  bool needsCFIForDebug() const;
383 
384  /// Print to the current output stream assembly representations of the
385  /// constants in the constant pool MCP. This is used to print out constants
386  /// which have been "spilled to memory" by the code generator.
387  virtual void emitConstantPool();
388 
389  /// Print assembly representations of the jump tables used by the current
390  /// function to the current output stream.
391  virtual void emitJumpTableInfo();
392 
393  /// Emit the specified global variable to the .s file.
394  virtual void emitGlobalVariable(const GlobalVariable *GV);
395 
396  /// Check to see if the specified global is a special global used by LLVM. If
397  /// so, emit it and return true, otherwise do nothing and return false.
398  bool emitSpecialLLVMGlobal(const GlobalVariable *GV);
399 
400  /// `llvm.global_ctors` and `llvm.global_dtors` are arrays of Structor
401  /// structs.
402  ///
403  /// Priority - init priority
404  /// Func - global initialization or global clean-up function
405  /// ComdatKey - associated data
406  struct Structor {
407  int Priority = 0;
408  Constant *Func = nullptr;
409  GlobalValue *ComdatKey = nullptr;
410 
411  Structor() = default;
412  };
413 
414  /// This method gathers an array of Structors and then sorts them out by
415  /// Priority.
416  /// @param List The initializer of `llvm.global_ctors` or `llvm.global_dtors`
417  /// array.
418  /// @param[out] Structors Sorted Structor structs by Priority.
419  void preprocessXXStructorList(const DataLayout &DL, const Constant *List,
420  SmallVector<Structor, 8> &Structors);
421 
422  /// This method emits `llvm.global_ctors` or `llvm.global_dtors` list.
423  virtual void emitXXStructorList(const DataLayout &DL, const Constant *List,
424  bool IsCtor);
425 
426  /// Emit an alignment directive to the specified power of two boundary. If a
427  /// global value is specified, and if that global has an explicit alignment
428  /// requested, it will override the alignment request if required for
429  /// correctness.
430  void emitAlignment(Align Alignment, const GlobalObject *GV = nullptr) const;
431 
432  /// Lower the specified LLVM Constant to an MCExpr.
433  virtual const MCExpr *lowerConstant(const Constant *CV);
434 
435  /// Print a general LLVM constant to the .s file.
436  void emitGlobalConstant(const DataLayout &DL, const Constant *CV);
437 
438  /// Unnamed constant global variables solely contaning a pointer to
439  /// another globals variable act like a global variable "proxy", or GOT
440  /// equivalents, i.e., it's only used to hold the address of the latter. One
441  /// optimization is to replace accesses to these proxies by using the GOT
442  /// entry for the final global instead. Hence, we select GOT equivalent
443  /// candidates among all the module global variables, avoid emitting them
444  /// unnecessarily and finally replace references to them by pc relative
445  /// accesses to GOT entries.
447 
448  /// Constant expressions using GOT equivalent globals may not be
449  /// eligible for PC relative GOT entry conversion, in such cases we need to
450  /// emit the proxies we previously omitted in EmitGlobalVariable.
451  void emitGlobalGOTEquivs();
452 
453  /// Emit the stack maps.
454  void emitStackMaps(StackMaps &SM);
455 
456  //===------------------------------------------------------------------===//
457  // Overridable Hooks
458  //===------------------------------------------------------------------===//
459 
461  Handlers.insert(Handlers.begin(), std::move(Handler));
462  NumUserHandlers++;
463  }
464 
465  // Targets can, or in the case of EmitInstruction, must implement these to
466  // customize output.
467 
468  /// This virtual method can be overridden by targets that want to emit
469  /// something at the start of their file.
470  virtual void emitStartOfAsmFile(Module &) {}
471 
472  /// This virtual method can be overridden by targets that want to emit
473  /// something at the end of their file.
474  virtual void emitEndOfAsmFile(Module &) {}
475 
476  /// Targets can override this to emit stuff before the first basic block in
477  /// the function.
478  virtual void emitFunctionBodyStart() {}
479 
480  /// Targets can override this to emit stuff after the last basic block in the
481  /// function.
482  virtual void emitFunctionBodyEnd() {}
483 
484  /// Targets can override this to emit stuff at the start of a basic block.
485  /// By default, this method prints the label for the specified
486  /// MachineBasicBlock, an alignment (if present) and a comment describing it
487  /// if appropriate.
488  virtual void emitBasicBlockStart(const MachineBasicBlock &MBB);
489 
490  /// Targets can override this to emit stuff at the end of a basic block.
491  virtual void emitBasicBlockEnd(const MachineBasicBlock &MBB);
492 
493  /// Targets should implement this to emit instructions.
494  virtual void emitInstruction(const MachineInstr *) {
495  llvm_unreachable("EmitInstruction not implemented");
496  }
497 
498  /// Return the symbol for the specified constant pool entry.
499  virtual MCSymbol *GetCPISymbol(unsigned CPID) const;
500 
501  virtual void emitFunctionEntryLabel();
502 
503  virtual void emitFunctionDescriptor() {
504  llvm_unreachable("Function descriptor is target-specific.");
505  }
506 
508 
509  /// Targets can override this to change how global constants that are part of
510  /// a C++ static/global constructor list are emitted.
511  virtual void emitXXStructor(const DataLayout &DL, const Constant *CV) {
512  emitGlobalConstant(DL, CV);
513  }
514 
515  /// Return true if the basic block has exactly one predecessor and the control
516  /// transfer mechanism between the predecessor and this block is a
517  /// fall-through.
518  virtual bool
520 
521  /// Targets can override this to customize the output of IMPLICIT_DEF
522  /// instructions in verbose mode.
523  virtual void emitImplicitDef(const MachineInstr *MI) const;
524 
525  /// Emit N NOP instructions.
526  void emitNops(unsigned N);
527 
528  //===------------------------------------------------------------------===//
529  // Symbol Lowering Routines.
530  //===------------------------------------------------------------------===//
531 
532  MCSymbol *createTempSymbol(const Twine &Name) const;
533 
534  /// Return the MCSymbol for a private symbol with global value name as its
535  /// base, with the specified suffix.
537  StringRef Suffix) const;
538 
539  /// Return the MCSymbol for the specified ExternalSymbol.
541 
542  /// Return the symbol for the specified jump table entry.
543  MCSymbol *GetJTISymbol(unsigned JTID, bool isLinkerPrivate = false) const;
544 
545  /// Return the symbol for the specified jump table .set
546  /// FIXME: privatize to AsmPrinter.
547  MCSymbol *GetJTSetSymbol(unsigned UID, unsigned MBBID) const;
548 
549  /// Return the MCSymbol used to satisfy BlockAddress uses of the specified
550  /// basic block.
551  MCSymbol *GetBlockAddressSymbol(const BlockAddress *BA) const;
553 
554  //===------------------------------------------------------------------===//
555  // Emission Helper Routines.
556  //===------------------------------------------------------------------===//
557 
558  /// This is just convenient handler for printing offsets.
559  void printOffset(int64_t Offset, raw_ostream &OS) const;
560 
561  /// Emit a byte directive and value.
562  void emitInt8(int Value) const;
563 
564  /// Emit a short directive and value.
565  void emitInt16(int Value) const;
566 
567  /// Emit a long directive and value.
568  void emitInt32(int Value) const;
569 
570  /// Emit a long long directive and value.
571  void emitInt64(uint64_t Value) const;
572 
573  /// Emit something like ".long Hi-Lo" where the size in bytes of the directive
574  /// is specified by Size and Hi/Lo specify the labels. This implicitly uses
575  /// .set if it is available.
576  void emitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo,
577  unsigned Size) const;
578 
579  /// Emit something like ".uleb128 Hi-Lo".
581  const MCSymbol *Lo) const;
582 
583  /// Emit something like ".long Label+Offset" where the size in bytes of the
584  /// directive is specified by Size and Label specifies the label. This
585  /// implicitly uses .set if it is available.
586  void emitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset,
587  unsigned Size, bool IsSectionRelative = false) const;
588 
589  /// Emit something like ".long Label" where the size in bytes of the directive
590  /// is specified by Size and Label specifies the label.
591  void emitLabelReference(const MCSymbol *Label, unsigned Size,
592  bool IsSectionRelative = false) const {
593  emitLabelPlusOffset(Label, 0, Size, IsSectionRelative);
594  }
595 
596  //===------------------------------------------------------------------===//
597  // Dwarf Emission Helper Routines
598  //===------------------------------------------------------------------===//
599 
600  /// Emit the specified signed leb128 value.
601  void emitSLEB128(int64_t Value, const char *Desc = nullptr) const;
602 
603  /// Emit the specified unsigned leb128 value.
604  void emitULEB128(uint64_t Value, const char *Desc = nullptr,
605  unsigned PadTo = 0) const;
606 
607  /// Emit a .byte 42 directive that corresponds to an encoding. If verbose
608  /// assembly output is enabled, we output comments describing the encoding.
609  /// Desc is a string saying what the encoding is specifying (e.g. "LSDA").
610  void emitEncodingByte(unsigned Val, const char *Desc = nullptr) const;
611 
612  /// Return the size of the encoding in bytes.
613  unsigned GetSizeOfEncodedValue(unsigned Encoding) const;
614 
615  /// Emit reference to a ttype global with a specified encoding.
616  virtual void emitTTypeReference(const GlobalValue *GV, unsigned Encoding);
617 
618  /// Emit a reference to a symbol for use in dwarf. Different object formats
619  /// represent this in different ways. Some use a relocation others encode
620  /// the label offset in its section.
621  void emitDwarfSymbolReference(const MCSymbol *Label,
622  bool ForceOffset = false) const;
623 
624  /// Emit the 4- or 8-byte offset of a string from the start of its section.
625  ///
626  /// When possible, emit a DwarfStringPool section offset without any
627  /// relocations, and without using the symbol. Otherwise, defers to \a
628  /// emitDwarfSymbolReference().
629  ///
630  /// The length of the emitted value depends on the DWARF format.
632 
633  /// Emit the 4-or 8-byte offset of a string from the start of its section.
635  emitDwarfStringOffset(S.getEntry());
636  }
637 
638  /// Emit something like ".long Label + Offset" or ".quad Label + Offset"
639  /// depending on the DWARF format.
640  void emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const;
641 
642  /// Emit 32- or 64-bit value depending on the DWARF format.
643  void emitDwarfLengthOrOffset(uint64_t Value) const;
644 
645  /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen
646  /// according to the settings.
647  void emitDwarfUnitLength(uint64_t Length, const Twine &Comment) const;
648 
649  /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen
650  /// according to the settings.
651  /// Return the end symbol generated inside, the caller needs to emit it.
653  const Twine &Comment) const;
654 
655  /// Emit reference to a call site with a specified encoding
656  void emitCallSiteOffset(const MCSymbol *Hi, const MCSymbol *Lo,
657  unsigned Encoding) const;
658  /// Emit an integer value corresponding to the call site encoding
659  void emitCallSiteValue(uint64_t Value, unsigned Encoding) const;
660 
661  /// Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
662  virtual unsigned getISAEncoding() { return 0; }
663 
664  /// Emit the directive and value for debug thread local expression
665  ///
666  /// \p Value - The value to emit.
667  /// \p Size - The size of the integer (in bytes) to emit.
668  virtual void emitDebugValue(const MCExpr *Value, unsigned Size) const;
669 
670  //===------------------------------------------------------------------===//
671  // Dwarf Lowering Routines
672  //===------------------------------------------------------------------===//
673 
674  /// Emit frame instruction to describe the layout of the frame.
675  void emitCFIInstruction(const MCCFIInstruction &Inst) const;
676 
677  /// Emit Dwarf abbreviation table.
678  template <typename T> void emitDwarfAbbrevs(const T &Abbrevs) const {
679  // For each abbreviation.
680  for (const auto &Abbrev : Abbrevs)
681  emitDwarfAbbrev(*Abbrev);
682 
683  // Mark end of abbreviations.
684  emitULEB128(0, "EOM(3)");
685  }
686 
687  void emitDwarfAbbrev(const DIEAbbrev &Abbrev) const;
688 
689  /// Recursively emit Dwarf DIE tree.
690  void emitDwarfDIE(const DIE &Die) const;
691 
692  //===------------------------------------------------------------------===//
693  // Inline Asm Support
694  //===------------------------------------------------------------------===//
695 
696  // These are hooks that targets can override to implement inline asm
697  // support. These should probably be moved out of AsmPrinter someday.
698 
699  /// Print information related to the specified machine instr that is
700  /// independent of the operand, and may be independent of the instr itself.
701  /// This can be useful for portably encoding the comment character or other
702  /// bits of target-specific knowledge into the asmstrings. The syntax used is
703  /// ${:comment}. Targets can override this to add support for their own
704  /// strange codes.
705  virtual void PrintSpecial(const MachineInstr *MI, raw_ostream &OS,
706  const char *Code) const;
707 
708  /// Print the MachineOperand as a symbol. Targets with complex handling of
709  /// symbol references should override the base implementation.
710  virtual void PrintSymbolOperand(const MachineOperand &MO, raw_ostream &OS);
711 
712  /// Print the specified operand of MI, an INLINEASM instruction, using the
713  /// specified assembler variant. Targets should override this to format as
714  /// appropriate. This method can return true if the operand is erroneous.
715  virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
716  const char *ExtraCode, raw_ostream &OS);
717 
718  /// Print the specified operand of MI, an INLINEASM instruction, using the
719  /// specified assembler variant as an address. Targets should override this to
720  /// format as appropriate. This method can return true if the operand is
721  /// erroneous.
722  virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
723  const char *ExtraCode, raw_ostream &OS);
724 
725  /// Let the target do anything it needs to do before emitting inlineasm.
726  /// \p StartInfo - the subtarget info before parsing inline asm
727  virtual void emitInlineAsmStart() const;
728 
729  /// Let the target do anything it needs to do after emitting inlineasm.
730  /// This callback can be used restore the original mode in case the
731  /// inlineasm contains directives to switch modes.
732  /// \p StartInfo - the original subtarget info before inline asm
733  /// \p EndInfo - the final subtarget info after parsing the inline asm,
734  /// or NULL if the value is unknown.
735  virtual void emitInlineAsmEnd(const MCSubtargetInfo &StartInfo,
736  const MCSubtargetInfo *EndInfo) const;
737 
738  /// This emits visibility information about symbol, if this is supported by
739  /// the target.
740  void emitVisibility(MCSymbol *Sym, unsigned Visibility,
741  bool IsDefinition = true) const;
742 
743  /// This emits linkage information about \p GVSym based on \p GV, if this is
744  /// supported by the target.
745  virtual void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const;
746 
747  /// Return the alignment for the specified \p GV.
748  static Align getGVAlignment(const GlobalObject *GV, const DataLayout &DL,
749  Align InAlign = Align(1));
750 
751 private:
752  /// Private state for PrintSpecial()
753  // Assign a unique ID to this machine instruction.
754  mutable const MachineInstr *LastMI = nullptr;
755  mutable unsigned LastFn = 0;
756  mutable unsigned Counter = ~0U;
757 
758  /// This method emits the header for the current function.
759  virtual void emitFunctionHeader();
760 
761  /// This method emits a comment next to header for the current function.
762  virtual void emitFunctionHeaderComment();
763 
764  /// Emit a blob of inline asm to the output streamer.
765  void
766  emitInlineAsm(StringRef Str, const MCSubtargetInfo &STI,
767  const MCTargetOptions &MCOptions,
768  const MDNode *LocMDNode = nullptr,
769  InlineAsm::AsmDialect AsmDialect = InlineAsm::AD_ATT) const;
770 
771  /// This method formats and emits the specified machine instruction that is an
772  /// inline asm.
773  void emitInlineAsm(const MachineInstr *MI) const;
774 
775  /// Add inline assembly info to the diagnostics machinery, so we can
776  /// emit file and position info. Returns SrcMgr memory buffer position.
777  unsigned addInlineAsmDiagBuffer(StringRef AsmStr,
778  const MDNode *LocMDNode) const;
779 
780  //===------------------------------------------------------------------===//
781  // Internal Implementation Details
782  //===------------------------------------------------------------------===//
783 
784  void emitJumpTableEntry(const MachineJumpTableInfo *MJTI,
785  const MachineBasicBlock *MBB, unsigned uid) const;
786  void emitLLVMUsedList(const ConstantArray *InitList);
787  /// Emit llvm.ident metadata in an '.ident' directive.
788  void emitModuleIdents(Module &M);
789  /// Emit bytes for llvm.commandline metadata.
790  void emitModuleCommandLines(Module &M);
791 
792  GCMetadataPrinter *GetOrCreateGCPrinter(GCStrategy &S);
793  /// Emit GlobalAlias or GlobalIFunc.
794  void emitGlobalIndirectSymbol(Module &M, const GlobalIndirectSymbol &GIS);
795 
796  /// This method decides whether the specified basic block requires a label.
797  bool shouldEmitLabelForBasicBlock(const MachineBasicBlock &MBB) const;
798 };
799 
800 } // end namespace llvm
801 
802 #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:2359
llvm::AsmPrinter::isPositionIndependent
bool isPositionIndependent() const
Definition: AsmPrinter.cpp:214
llvm::AsmPrinter::NumUserHandlers
size_t NumUserHandlers
Definition: AsmPrinter.h:193
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:100
llvm::AsmPrinter::GlobalGOTEquivs
MapVector< const MCSymbol *, GOTEquivUsePair > GlobalGOTEquivs
Definition: AsmPrinter.h:141
llvm
Definition: AllocatorList.h:23
llvm::AsmPrinter::getFunctionEnd
MCSymbol * getFunctionEnd() const
Definition: AsmPrinter.h:245
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:3032
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:511
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:3261
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:2409
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:3490
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:3049
llvm::AsmPrinter::getDwarfDebug
DwarfDebug * getDwarfDebug()
Definition: AsmPrinter.h:218
llvm::MCContext
Context object for machine code objects.
Definition: MCContext.h:71
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:650
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:3016
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:3503
llvm::MipsISD::Lo
@ Lo
Definition: MipsISelLowering.h:79
llvm::AsmPrinter::Structor::Priority
int Priority
Definition: AsmPrinter.h:407
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:301
llvm::MachineOptimizationRemarkEmitter
The optimization diagnostic interface.
Definition: MachineOptimizationRemarkEmitter.h:144
llvm::AsmPrinter::XRayFunctionEntry::Sled
const MCSymbol * Sled
Definition: AsmPrinter.h:300
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:473
llvm::AsmPrinter::doFinalization
bool doFinalization(Module &M) override
Shut down the asmprinter.
Definition: AsmPrinter.cpp:1659
llvm::AsmPrinter::emitStackMaps
void emitStackMaps(StackMaps &SM)
Emit the stack maps.
Definition: AsmPrinter.cpp:3371
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:590
llvm::AsmPrinter::getFunctionCFISectionType
CFISection getFunctionCFISectionType(const Function &F) const
Get the CFISection type for a function.
Definition: AsmPrinter.cpp:1046
llvm::AsmPrinter::getDwarfOffsetByteSize
unsigned int getDwarfOffsetByteSize() const
Returns 4 for DWARF32 and 8 for DWARF64.
Definition: AsmPrinter.cpp:3550
llvm::AsmPrinter::setDwarfVersion
void setDwarfVersion(uint16_t Version)
Definition: AsmPrinter.cpp:3542
llvm::AsmPrinter::Structor::ComdatKey
GlobalValue * ComdatKey
Definition: AsmPrinter.h:409
llvm::AsmPrinter::Structor::Func
Constant * Func
Definition: AsmPrinter.h:408
AsmPrinterHandler.h
llvm::AsmPrinter::SledKind
SledKind
Definition: AsmPrinter.h:286
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:406
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:591
llvm::MCInst
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:183
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:304
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:1128
llvm::AsmPrinter::emitGlobalVariable
virtual void emitGlobalVariable(const GlobalVariable *GV)
Emit the specified global variable to the .s file.
Definition: AsmPrinter.cpp:500
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:634
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:314
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:433
llvm::ISD::Constant
@ Constant
Definition: ISDOpcodes.h:69
llvm::AsmPrinter::XRayFunctionEntry::Version
uint8_t Version
Definition: AsmPrinter.h:305
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:642
llvm::AsmPrinter::addAsmPrinterHandler
void addAsmPrinterHandler(HandlerInfo Handler)
Definition: AsmPrinter.h:460
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:1909
llvm::AsmPrinter::emitFunctionEntryLabel
virtual void emitFunctionEntryLabel()
EmitFunctionEntryLabel - Emit the label that is the entrypoint for the function.
Definition: AsmPrinter.cpp:835
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:470
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:3309
remarks
annotation remarks
Definition: AnnotationRemarks.cpp:149
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:49
llvm::ConstantArray
ConstantArray - Constant Array Declarations.
Definition: Constants.h:407
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:494
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:219
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:2392
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:50
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:474
llvm::AsmPrinter::getModuleCFISectionType
CFISection getModuleCFISectionType() const
Get the CFISection type for the module.
Definition: AsmPrinter.h:374
DwarfStringPoolEntry.h
llvm::IndexedInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:991
llvm::AsmPrinter::XRayFunctionEntry::AlwaysInstrument
bool AlwaysInstrument
Definition: AsmPrinter.h:303
llvm::AsmPrinter::emitFunctionBodyStart
virtual void emitFunctionBodyStart()
Targets can override this to emit stuff before the first basic block in the function.
Definition: AsmPrinter.h:478
llvm::AsmPrinter::emitDwarfAbbrevs
void emitDwarfAbbrevs(const T &Abbrevs) const
Emit Dwarf abbreviation table.
Definition: AsmPrinter.h:678
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:2343
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:563
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::AsmPrinter::getFunctionBegin
MCSymbol * getFunctionBegin() const
Definition: AsmPrinter.h:244
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:3181
llvm::MCCFIInstruction
Definition: MCDwarf.h:441
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:302
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:192
llvm::AsmPrinter::CFISection::None
@ None
Do not emit either .eh_frame or .debug_frame.
llvm::ISD::BlockAddress
@ BlockAddress
Definition: ISDOpcodes.h:77
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:3027
llvm::PseudoProbeHandler
Definition: PseudoProbePrinter.h:26
llvm::AsmPrinter::emitFrameAlloc
void emitFrameAlloc(const MachineInstr &MI)
Definition: AsmPrinter.cpp:1101
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:3096
llvm::AsmPrinter::emitInt64
void emitInt64(uint64_t Value) const
Emit a long long directive and value.
Definition: AsmPrinter.cpp:2352
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:3062
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:2367
llvm::AsmPrinter::needsCFIForDebug
bool needsCFIForDebug() const
Since emitting CFI unwind information is entangled with supporting the exceptions,...
Definition: AsmPrinter.cpp:1070
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:3053
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:482
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:1066
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:2042
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:242
llvm::AsmPrinter::getSymbol
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:478
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:1540
llvm::AsmPrinter::getMBBExceptionSym
MCSymbol * getMBBExceptionSym(const MachineBasicBlock &MBB)
Definition: AsmPrinter.cpp:1902
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:64
llvm::AsmPrinter::emitRemarksSection
void emitRemarksSection(remarks::RemarkStreamer &RS)
Definition: AsmPrinter.cpp:1631
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:890
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:2184
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:299
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:1525
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:1075
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:698
llvm::AsmPrinter::runOnMachineFunction
bool runOnMachineFunction(MachineFunction &MF) override
Emit the specified function out to the OutStreamer.
Definition: AsmPrinter.h:338
llvm::BlockAddress
The address of a basic block.
Definition: Constants.h:847
llvm::AsmPrinter::GetExternalSymbolSymbol
MCSymbol * GetExternalSymbolSymbol(StringRef Sym) const
Return the MCSymbol for the specified ExternalSymbol.
Definition: AsmPrinter.cpp:3109
llvm::AsmPrinter::emitGlobalGOTEquivs
void emitGlobalGOTEquivs()
Constant expressions using GOT equivalent globals may not be eligible for PC relative GOT entry conve...
Definition: AsmPrinter.cpp:1542
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:3090
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:2229
llvm::AsmPrinter::SledKind::LOG_ARGS_ENTER
@ LOG_ARGS_ENTER
llvm::AsmPrinter::Sleds
SmallVector< XRayFunctionEntry, 4 > Sleds
Definition: AsmPrinter.h:311
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:662
llvm::AsmPrinter::getUnitLengthFieldByteSize
unsigned int getUnitLengthFieldByteSize() const
Returns 4 for DWARF32 and 12 for DWARF64.
Definition: AsmPrinter.cpp:3555
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:172
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::AsmPrinter::emitPseudoProbe
void emitPseudoProbe(const MachineInstr &MI)
Definition: AsmPrinter.cpp:1154
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
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:3039
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:145
llvm::AsmPrinter::isDwarf64
bool isDwarf64() const
Definition: AsmPrinter.cpp:3546
llvm::AsmPrinter::emitInlineAsmStart
virtual void emitInlineAsmStart() const
Let the target do anything it needs to do before emitting inlineasm.
Definition: AsmPrinterInlineAsm.cpp:648
llvm::AsmPrinter::emitStackSizeSection
void emitStackSizeSection(const MachineFunction &MF)
Definition: AsmPrinter.cpp:1163
llvm::AsmPrinter::HandlerInfo::TimerName
StringRef TimerName
Definition: AsmPrinter.h:147
llvm::AsmPrinter::getDwarfVersion
uint16_t getDwarfVersion() const
Definition: AsmPrinter.cpp:3538
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:3269
llvm::AsmPrinter::emitInt32
void emitInt32(int Value) const
Emit a long directive and value.
Definition: AsmPrinter.cpp:2349
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:3103
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:1203
llvm::AsmPrinter::emitFunctionDescriptor
virtual void emitFunctionDescriptor()
Definition: AsmPrinter.h:503
llvm::AsmPrinter::CurrentFnBegin
MCSymbol * CurrentFnBegin
Definition: AsmPrinter.h:188
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:133
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:279
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:3411
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:235
llvm::AsmPrinter::emitFunctionBodyEnd
virtual void emitFunctionBodyEnd()
Targets can override this to emit stuff after the last basic block in the function.
Definition: AsmPrinter.h:482
llvm::MachineDominatorTree
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
Definition: MachineDominators.h:45
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:75
llvm::AsmPrinter::emitInt16
void emitInt16(int Value) const
Emit a short directive and value.
Definition: AsmPrinter.cpp:2346
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:2266
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:600
llvm::AsmPrinter::XRayFunctionEntry::emit
void emit(int, MCStreamer *) const
Definition: AsmPrinter.cpp:3400
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:1965
llvm::ISD::MCSymbol
@ MCSymbol
Definition: ISDOpcodes.h:165
llvm::AsmPrinter::doInitialization
bool doInitialization(Module &M) override
Set up the AsmPrinter when we are working on a new module.
Definition: AsmPrinter.cpp:266