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