1 //===- llvm/CodeGen/AsmPrinter.h - AsmPrinter Framework ---------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
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
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_CODEGEN_ASMPRINTER_H
16 #define LLVM_CODEGEN_ASMPRINTER_H
18 #include "llvm/ADT/MapVector.h"
19 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/ADT/StringRef.h"
21 #include "llvm/ADT/Twine.h"
22 #include "llvm/CodeGen/AsmPrinterHandler.h"
23 #include "llvm/CodeGen/DwarfStringPoolEntry.h"
24 #include "llvm/CodeGen/MachineFunctionPass.h"
25 #include "llvm/IR/InlineAsm.h"
26 #include "llvm/IR/LLVMContext.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include "llvm/Support/SourceMgr.h"
44 class GCMetadataPrinter
;
46 class GlobalIndirectSymbol
;
50 class MachineBasicBlock
;
51 class MachineConstantPoolValue
;
52 class MachineDominatorTree
;
53 class MachineFunction
;
55 class MachineJumpTableInfo
;
56 class MachineLoopInfo
;
57 class MachineModuleInfo
;
58 class MachineOptimizationRemarkEmitter
;
60 class MCCFIInstruction
;
61 struct MCCodePaddingContext
;
67 class MCSubtargetInfo
;
69 class MCTargetOptions
;
74 class TargetLoweringObjectFile
;
77 /// This class is intended to be used as a driving class for all asm writers.
78 class AsmPrinter
: public MachineFunctionPass
{
80 /// Target machine description.
83 /// Target Asm Printer information.
86 /// This is the context for the output file that we are streaming. This owns
87 /// all of the global MC-related objects for the generated translation unit.
88 MCContext
&OutContext
;
90 /// This is the MCStreamer object for the file we are generating. This
91 /// contains the transient state for the current translation unit that we are
92 /// generating (such as the current section etc).
93 std::unique_ptr
<MCStreamer
> OutStreamer
;
95 /// The current machine function.
96 MachineFunction
*MF
= nullptr;
98 /// This is a pointer to the current MachineModuleInfo.
99 MachineModuleInfo
*MMI
= nullptr;
101 /// This is a pointer to the current MachineLoopInfo.
102 MachineDominatorTree
*MDT
= nullptr;
104 /// This is a pointer to the current MachineLoopInfo.
105 MachineLoopInfo
*MLI
= nullptr;
107 /// Optimization remark emitter.
108 MachineOptimizationRemarkEmitter
*ORE
;
110 /// The symbol for the current function. This is recalculated at the beginning
111 /// of each call to runOnMachineFunction().
112 MCSymbol
*CurrentFnSym
= nullptr;
114 /// The symbol used to represent the start of the current function for the
115 /// purpose of calculating its size (e.g. using the .size directive). By
116 /// default, this is equal to CurrentFnSym.
117 MCSymbol
*CurrentFnSymForSize
= nullptr;
119 /// Map global GOT equivalent MCSymbols to GlobalVariables and keep track of
120 /// its number of uses by other globals.
121 using GOTEquivUsePair
= std::pair
<const GlobalVariable
*, unsigned>;
122 MapVector
<const MCSymbol
*, GOTEquivUsePair
> GlobalGOTEquivs
;
125 MCSymbol
*CurrentFnBegin
= nullptr;
126 MCSymbol
*CurrentFnEnd
= nullptr;
127 MCSymbol
*CurExceptionSym
= nullptr;
129 // The garbage collection metadata printer table.
130 void *GCMetadataPrinters
= nullptr; // Really a DenseMap.
132 /// Emit comments in assembly output if this is true.
138 /// Protected struct HandlerInfo and Handlers permit target extended
139 /// AsmPrinter adds their own handlers.
141 std::unique_ptr
<AsmPrinterHandler
> Handler
;
142 const char *TimerName
;
143 const char *TimerDescription
;
144 const char *TimerGroupName
;
145 const char *TimerGroupDescription
;
147 HandlerInfo(std::unique_ptr
<AsmPrinterHandler
> Handler
,
148 const char *TimerName
, const char *TimerDescription
,
149 const char *TimerGroupName
, const char *TimerGroupDescription
)
150 : Handler(std::move(Handler
)), TimerName(TimerName
),
151 TimerDescription(TimerDescription
), TimerGroupName(TimerGroupName
),
152 TimerGroupDescription(TimerGroupDescription
) {}
155 /// A vector of all debug/EH info emitters we should use. This vector
156 /// maintains ownership of the emitters.
157 SmallVector
<HandlerInfo
, 1> Handlers
;
160 struct SrcMgrDiagInfo
{
162 std::vector
<const MDNode
*> LocInfos
;
163 LLVMContext::InlineAsmDiagHandlerTy DiagHandler
;
168 /// If generated on the fly this own the instance.
169 std::unique_ptr
<MachineDominatorTree
> OwnedMDT
;
171 /// If generated on the fly this own the instance.
172 std::unique_ptr
<MachineLoopInfo
> OwnedMLI
;
174 /// Structure for generating diagnostics for inline assembly. Only initialised
176 mutable std::unique_ptr
<SrcMgrDiagInfo
> DiagInfo
;
178 /// If the target supports dwarf debug info, this pointer is non-null.
179 DwarfDebug
*DD
= nullptr;
181 /// If the current module uses dwarf CFI annotations strictly for debugging.
182 bool isCFIMoveForDebugging
= false;
185 explicit AsmPrinter(TargetMachine
&TM
, std::unique_ptr
<MCStreamer
> Streamer
);
188 ~AsmPrinter() override
;
190 DwarfDebug
*getDwarfDebug() { return DD
; }
191 DwarfDebug
*getDwarfDebug() const { return DD
; }
193 uint16_t getDwarfVersion() const;
194 void setDwarfVersion(uint16_t Version
);
196 bool isPositionIndependent() const;
198 /// Return true if assembly output should contain comments.
199 bool isVerbose() const { return VerboseAsm
; }
201 /// Return a unique ID for the current function.
202 unsigned getFunctionNumber() const;
204 /// Return symbol for the function pseudo stack if the stack frame is not a
206 virtual const MCSymbol
*getFunctionFrameSymbol() const { return nullptr; }
208 MCSymbol
*getFunctionBegin() const { return CurrentFnBegin
; }
209 MCSymbol
*getFunctionEnd() const { return CurrentFnEnd
; }
210 MCSymbol
*getCurExceptionSym();
212 /// Return information about object file lowering.
213 const TargetLoweringObjectFile
&getObjFileLowering() const;
215 /// Return information about data layout.
216 const DataLayout
&getDataLayout() const;
218 /// Return the pointer size from the TargetMachine
219 unsigned getPointerSize() const;
221 /// Return information about subtarget.
222 const MCSubtargetInfo
&getSubtargetInfo() const;
224 void EmitToStreamer(MCStreamer
&S
, const MCInst
&Inst
);
226 /// Emits inital debug location directive.
227 void emitInitialRawDwarfLocDirective(const MachineFunction
&MF
);
229 /// Return the current section we are emitting to.
230 const MCSection
*getCurrentSection() const;
232 void getNameWithPrefix(SmallVectorImpl
<char> &Name
,
233 const GlobalValue
*GV
) const;
235 MCSymbol
*getSymbol(const GlobalValue
*GV
) const;
237 //===------------------------------------------------------------------===//
238 // XRay instrumentation implementation.
239 //===------------------------------------------------------------------===//
241 // This describes the kind of sled we're storing in the XRay table.
242 enum class SledKind
: uint8_t {
251 // The table will contain these structs that point to the sled, the function
252 // containing the sled, and what kind of sled (and whether they should always
253 // be instrumented). We also use a version identifier that the runtime can use
254 // to decide what to do with the sled, depending on the version of the sled.
255 struct XRayFunctionEntry
{
256 const MCSymbol
*Sled
;
257 const MCSymbol
*Function
;
259 bool AlwaysInstrument
;
260 const class Function
*Fn
;
263 void emit(int, MCStreamer
*, const MCSymbol
*) const;
266 // All the sleds to be emitted.
267 SmallVector
<XRayFunctionEntry
, 4> Sleds
;
269 // A unique ID used for ELF sections associated with a particular function.
270 unsigned XRayFnUniqueID
= 0;
272 // Helper function to record a given XRay sled.
273 void recordSled(MCSymbol
*Sled
, const MachineInstr
&MI
, SledKind Kind
,
274 uint8_t Version
= 0);
276 /// Emit a table with all XRay instrumentation points.
277 void emitXRayTable();
279 //===------------------------------------------------------------------===//
280 // MachineFunctionPass Implementation.
281 //===------------------------------------------------------------------===//
283 /// Record analysis usage.
284 void getAnalysisUsage(AnalysisUsage
&AU
) const override
;
286 /// Set up the AsmPrinter when we are working on a new module. If your pass
287 /// overrides this, it must make sure to explicitly call this implementation.
288 bool doInitialization(Module
&M
) override
;
290 /// Shut down the asmprinter. If you override this in your pass, you must make
291 /// sure to call it explicitly.
292 bool doFinalization(Module
&M
) override
;
294 /// Emit the specified function out to the OutStreamer.
295 bool runOnMachineFunction(MachineFunction
&MF
) override
{
296 SetupMachineFunction(MF
);
301 //===------------------------------------------------------------------===//
302 // Coarse grained IR lowering routines.
303 //===------------------------------------------------------------------===//
305 /// This should be called when a new MachineFunction is being processed from
306 /// runOnMachineFunction.
307 void SetupMachineFunction(MachineFunction
&MF
);
309 /// This method emits the body and trailer for a function.
310 void EmitFunctionBody();
312 void emitCFIInstruction(const MachineInstr
&MI
);
314 void emitFrameAlloc(const MachineInstr
&MI
);
316 void emitStackSizeSection(const MachineFunction
&MF
);
318 void emitRemarksSection(Module
&M
);
320 enum CFIMoveType
{ CFI_M_None
, CFI_M_EH
, CFI_M_Debug
};
321 CFIMoveType
needsCFIMoves() const;
323 /// Returns false if needsCFIMoves() == CFI_M_EH for any function
325 bool needsOnlyDebugCFIMoves() const { return isCFIMoveForDebugging
; }
327 bool needsSEHMoves();
329 /// Print to the current output stream assembly representations of the
330 /// constants in the constant pool MCP. This is used to print out constants
331 /// which have been "spilled to memory" by the code generator.
332 virtual void EmitConstantPool();
334 /// Print assembly representations of the jump tables used by the current
335 /// function to the current output stream.
336 virtual void EmitJumpTableInfo();
338 /// Emit the specified global variable to the .s file.
339 virtual void EmitGlobalVariable(const GlobalVariable
*GV
);
341 /// Check to see if the specified global is a special global used by LLVM. If
342 /// so, emit it and return true, otherwise do nothing and return false.
343 bool EmitSpecialLLVMGlobal(const GlobalVariable
*GV
);
345 /// Emit an alignment directive to the specified power of two boundary. If a
346 /// global value is specified, and if that global has an explicit alignment
347 /// requested, it will override the alignment request if required for
349 void EmitAlignment(llvm::Align Align
, const GlobalObject
*GV
= nullptr) const;
351 /// Lower the specified LLVM Constant to an MCExpr.
352 virtual const MCExpr
*lowerConstant(const Constant
*CV
);
354 /// Print a general LLVM constant to the .s file.
355 void EmitGlobalConstant(const DataLayout
&DL
, const Constant
*CV
);
357 /// Unnamed constant global variables solely contaning a pointer to
358 /// another globals variable act like a global variable "proxy", or GOT
359 /// equivalents, i.e., it's only used to hold the address of the latter. One
360 /// optimization is to replace accesses to these proxies by using the GOT
361 /// entry for the final global instead. Hence, we select GOT equivalent
362 /// candidates among all the module global variables, avoid emitting them
363 /// unnecessarily and finally replace references to them by pc relative
364 /// accesses to GOT entries.
365 void computeGlobalGOTEquivs(Module
&M
);
367 /// Constant expressions using GOT equivalent globals may not be
368 /// eligible for PC relative GOT entry conversion, in such cases we need to
369 /// emit the proxies we previously omitted in EmitGlobalVariable.
370 void emitGlobalGOTEquivs();
372 /// Emit the stack maps.
373 void emitStackMaps(StackMaps
&SM
);
375 //===------------------------------------------------------------------===//
377 //===------------------------------------------------------------------===//
379 // Targets can, or in the case of EmitInstruction, must implement these to
382 /// This virtual method can be overridden by targets that want to emit
383 /// something at the start of their file.
384 virtual void EmitStartOfAsmFile(Module
&) {}
386 /// This virtual method can be overridden by targets that want to emit
387 /// something at the end of their file.
388 virtual void EmitEndOfAsmFile(Module
&) {}
390 /// Targets can override this to emit stuff before the first basic block in
392 virtual void EmitFunctionBodyStart() {}
394 /// Targets can override this to emit stuff after the last basic block in the
396 virtual void EmitFunctionBodyEnd() {}
398 /// Targets can override this to emit stuff at the start of a basic block.
399 /// By default, this method prints the label for the specified
400 /// MachineBasicBlock, an alignment (if present) and a comment describing it
402 virtual void EmitBasicBlockStart(const MachineBasicBlock
&MBB
);
404 /// Targets can override this to emit stuff at the end of a basic block.
405 virtual void EmitBasicBlockEnd(const MachineBasicBlock
&MBB
);
407 /// Targets should implement this to emit instructions.
408 virtual void EmitInstruction(const MachineInstr
*) {
409 llvm_unreachable("EmitInstruction not implemented");
412 /// Return the symbol for the specified constant pool entry.
413 virtual MCSymbol
*GetCPISymbol(unsigned CPID
) const;
415 virtual void EmitFunctionEntryLabel();
417 virtual void EmitMachineConstantPoolValue(MachineConstantPoolValue
*MCPV
);
419 /// Targets can override this to change how global constants that are part of
420 /// a C++ static/global constructor list are emitted.
421 virtual void EmitXXStructor(const DataLayout
&DL
, const Constant
*CV
) {
422 EmitGlobalConstant(DL
, CV
);
425 /// Return true if the basic block has exactly one predecessor and the control
426 /// transfer mechanism between the predecessor and this block is a
429 isBlockOnlyReachableByFallthrough(const MachineBasicBlock
*MBB
) const;
431 /// Targets can override this to customize the output of IMPLICIT_DEF
432 /// instructions in verbose mode.
433 virtual void emitImplicitDef(const MachineInstr
*MI
) const;
435 //===------------------------------------------------------------------===//
436 // Symbol Lowering Routines.
437 //===------------------------------------------------------------------===//
439 MCSymbol
*createTempSymbol(const Twine
&Name
) const;
441 /// Return the MCSymbol for a private symbol with global value name as its
442 /// base, with the specified suffix.
443 MCSymbol
*getSymbolWithGlobalValueBase(const GlobalValue
*GV
,
444 StringRef Suffix
) const;
446 /// Return the MCSymbol for the specified ExternalSymbol.
447 MCSymbol
*GetExternalSymbolSymbol(StringRef Sym
) const;
449 /// Return the symbol for the specified jump table entry.
450 MCSymbol
*GetJTISymbol(unsigned JTID
, bool isLinkerPrivate
= false) const;
452 /// Return the symbol for the specified jump table .set
453 /// FIXME: privatize to AsmPrinter.
454 MCSymbol
*GetJTSetSymbol(unsigned UID
, unsigned MBBID
) const;
456 /// Return the MCSymbol used to satisfy BlockAddress uses of the specified
458 MCSymbol
*GetBlockAddressSymbol(const BlockAddress
*BA
) const;
459 MCSymbol
*GetBlockAddressSymbol(const BasicBlock
*BB
) const;
461 //===------------------------------------------------------------------===//
462 // Emission Helper Routines.
463 //===------------------------------------------------------------------===//
465 /// This is just convenient handler for printing offsets.
466 void printOffset(int64_t Offset
, raw_ostream
&OS
) const;
468 /// Emit a byte directive and value.
469 void emitInt8(int Value
) const;
471 /// Emit a short directive and value.
472 void emitInt16(int Value
) const;
474 /// Emit a long directive and value.
475 void emitInt32(int Value
) const;
477 /// Emit a long long directive and value.
478 void emitInt64(uint64_t Value
) const;
480 /// Emit something like ".long Hi-Lo" where the size in bytes of the directive
481 /// is specified by Size and Hi/Lo specify the labels. This implicitly uses
482 /// .set if it is available.
483 void EmitLabelDifference(const MCSymbol
*Hi
, const MCSymbol
*Lo
,
484 unsigned Size
) const;
486 /// Emit something like ".uleb128 Hi-Lo".
487 void EmitLabelDifferenceAsULEB128(const MCSymbol
*Hi
,
488 const MCSymbol
*Lo
) const;
490 /// Emit something like ".long Label+Offset" where the size in bytes of the
491 /// directive is specified by Size and Label specifies the label. This
492 /// implicitly uses .set if it is available.
493 void EmitLabelPlusOffset(const MCSymbol
*Label
, uint64_t Offset
,
494 unsigned Size
, bool IsSectionRelative
= false) const;
496 /// Emit something like ".long Label" where the size in bytes of the directive
497 /// is specified by Size and Label specifies the label.
498 void EmitLabelReference(const MCSymbol
*Label
, unsigned Size
,
499 bool IsSectionRelative
= false) const {
500 EmitLabelPlusOffset(Label
, 0, Size
, IsSectionRelative
);
503 /// Emit something like ".long Label + Offset".
504 void EmitDwarfOffset(const MCSymbol
*Label
, uint64_t Offset
) const;
506 //===------------------------------------------------------------------===//
507 // Dwarf Emission Helper Routines
508 //===------------------------------------------------------------------===//
510 /// Emit the specified signed leb128 value.
511 void EmitSLEB128(int64_t Value
, const char *Desc
= nullptr) const;
513 /// Emit the specified unsigned leb128 value.
514 void EmitULEB128(uint64_t Value
, const char *Desc
= nullptr, unsigned PadTo
= 0) const;
516 /// Emit a .byte 42 directive that corresponds to an encoding. If verbose
517 /// assembly output is enabled, we output comments describing the encoding.
518 /// Desc is a string saying what the encoding is specifying (e.g. "LSDA").
519 void EmitEncodingByte(unsigned Val
, const char *Desc
= nullptr) const;
521 /// Return the size of the encoding in bytes.
522 unsigned GetSizeOfEncodedValue(unsigned Encoding
) const;
524 /// Emit reference to a ttype global with a specified encoding.
525 void EmitTTypeReference(const GlobalValue
*GV
, unsigned Encoding
) const;
527 /// Emit a reference to a symbol for use in dwarf. Different object formats
528 /// represent this in different ways. Some use a relocation others encode
529 /// the label offset in its section.
530 void emitDwarfSymbolReference(const MCSymbol
*Label
,
531 bool ForceOffset
= false) const;
533 /// Emit the 4-byte offset of a string from the start of its section.
535 /// When possible, emit a DwarfStringPool section offset without any
536 /// relocations, and without using the symbol. Otherwise, defers to \a
537 /// emitDwarfSymbolReference().
538 void emitDwarfStringOffset(DwarfStringPoolEntry S
) const;
540 /// Emit the 4-byte offset of a string from the start of its section.
541 void emitDwarfStringOffset(DwarfStringPoolEntryRef S
) const {
542 emitDwarfStringOffset(S
.getEntry());
545 /// Emit reference to a call site with a specified encoding
546 void EmitCallSiteOffset(const MCSymbol
*Hi
, const MCSymbol
*Lo
,
547 unsigned Encoding
) const;
548 /// Emit an integer value corresponding to the call site encoding
549 void EmitCallSiteValue(uint64_t Value
, unsigned Encoding
) const;
551 /// Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
552 virtual unsigned getISAEncoding() { return 0; }
554 /// Emit the directive and value for debug thread local expression
556 /// \p Value - The value to emit.
557 /// \p Size - The size of the integer (in bytes) to emit.
558 virtual void EmitDebugValue(const MCExpr
*Value
, unsigned Size
) const;
560 //===------------------------------------------------------------------===//
561 // Dwarf Lowering Routines
562 //===------------------------------------------------------------------===//
564 /// Emit frame instruction to describe the layout of the frame.
565 void emitCFIInstruction(const MCCFIInstruction
&Inst
) const;
567 /// Emit Dwarf abbreviation table.
568 template <typename T
> void emitDwarfAbbrevs(const T
&Abbrevs
) const {
569 // For each abbreviation.
570 for (const auto &Abbrev
: Abbrevs
)
571 emitDwarfAbbrev(*Abbrev
);
573 // Mark end of abbreviations.
574 EmitULEB128(0, "EOM(3)");
577 void emitDwarfAbbrev(const DIEAbbrev
&Abbrev
) const;
579 /// Recursively emit Dwarf DIE tree.
580 void emitDwarfDIE(const DIE
&Die
) const;
582 //===------------------------------------------------------------------===//
583 // Inline Asm Support
584 //===------------------------------------------------------------------===//
586 // These are hooks that targets can override to implement inline asm
587 // support. These should probably be moved out of AsmPrinter someday.
589 /// Print information related to the specified machine instr that is
590 /// independent of the operand, and may be independent of the instr itself.
591 /// This can be useful for portably encoding the comment character or other
592 /// bits of target-specific knowledge into the asmstrings. The syntax used is
593 /// ${:comment}. Targets can override this to add support for their own
595 virtual void PrintSpecial(const MachineInstr
*MI
, raw_ostream
&OS
,
596 const char *Code
) const;
598 /// Print the MachineOperand as a symbol. Targets with complex handling of
599 /// symbol references should override the base implementation.
600 virtual void PrintSymbolOperand(const MachineOperand
&MO
, raw_ostream
&OS
);
602 /// Print the specified operand of MI, an INLINEASM instruction, using the
603 /// specified assembler variant. Targets should override this to format as
604 /// appropriate. This method can return true if the operand is erroneous.
605 virtual bool PrintAsmOperand(const MachineInstr
*MI
, unsigned OpNo
,
606 const char *ExtraCode
, raw_ostream
&OS
);
608 /// Print the specified operand of MI, an INLINEASM instruction, using the
609 /// specified assembler variant as an address. Targets should override this to
610 /// format as appropriate. This method can return true if the operand is
612 virtual bool PrintAsmMemoryOperand(const MachineInstr
*MI
, unsigned OpNo
,
613 const char *ExtraCode
, raw_ostream
&OS
);
615 /// Let the target do anything it needs to do before emitting inlineasm.
616 /// \p StartInfo - the subtarget info before parsing inline asm
617 virtual void emitInlineAsmStart() const;
619 /// Let the target do anything it needs to do after emitting inlineasm.
620 /// This callback can be used restore the original mode in case the
621 /// inlineasm contains directives to switch modes.
622 /// \p StartInfo - the original subtarget info before inline asm
623 /// \p EndInfo - the final subtarget info after parsing the inline asm,
624 /// or NULL if the value is unknown.
625 virtual void emitInlineAsmEnd(const MCSubtargetInfo
&StartInfo
,
626 const MCSubtargetInfo
*EndInfo
) const;
628 /// This emits visibility information about symbol, if this is supported by
630 void EmitVisibility(MCSymbol
*Sym
, unsigned Visibility
,
631 bool IsDefinition
= true) const;
633 /// This emits linkage information about \p GVSym based on \p GV, if this is
634 /// supported by the target.
635 void EmitLinkage(const GlobalValue
*GV
, MCSymbol
*GVSym
) const;
637 /// Return the alignment for the specified \p GV.
638 static llvm::Align
getGVAlignment(const GlobalValue
*GV
, const DataLayout
&DL
,
639 llvm::Align InAlign
= llvm::Align::None());
642 /// Private state for PrintSpecial()
643 // Assign a unique ID to this machine instruction.
644 mutable const MachineInstr
*LastMI
= nullptr;
645 mutable unsigned LastFn
= 0;
646 mutable unsigned Counter
= ~0U;
648 /// This method emits the header for the current function.
649 virtual void EmitFunctionHeader();
651 /// Emit a blob of inline asm to the output streamer.
653 EmitInlineAsm(StringRef Str
, const MCSubtargetInfo
&STI
,
654 const MCTargetOptions
&MCOptions
,
655 const MDNode
*LocMDNode
= nullptr,
656 InlineAsm::AsmDialect AsmDialect
= InlineAsm::AD_ATT
) const;
658 /// This method formats and emits the specified machine instruction that is an
660 void EmitInlineAsm(const MachineInstr
*MI
) const;
662 /// Add inline assembly info to the diagnostics machinery, so we can
663 /// emit file and position info. Returns SrcMgr memory buffer position.
664 unsigned addInlineAsmDiagBuffer(StringRef AsmStr
,
665 const MDNode
*LocMDNode
) const;
667 //===------------------------------------------------------------------===//
668 // Internal Implementation Details
669 //===------------------------------------------------------------------===//
671 void EmitJumpTableEntry(const MachineJumpTableInfo
*MJTI
,
672 const MachineBasicBlock
*MBB
, unsigned uid
) const;
673 void EmitLLVMUsedList(const ConstantArray
*InitList
);
674 /// Emit llvm.ident metadata in an '.ident' directive.
675 void EmitModuleIdents(Module
&M
);
676 /// Emit bytes for llvm.commandline metadata.
677 void EmitModuleCommandLines(Module
&M
);
678 void EmitXXStructorList(const DataLayout
&DL
, const Constant
*List
,
681 GCMetadataPrinter
*GetOrCreateGCPrinter(GCStrategy
&S
);
682 /// Emit GlobalAlias or GlobalIFunc.
683 void emitGlobalIndirectSymbol(Module
&M
, const GlobalIndirectSymbol
&GIS
);
684 void setupCodePaddingContext(const MachineBasicBlock
&MBB
,
685 MCCodePaddingContext
&Context
) const;
688 } // end namespace llvm
690 #endif // LLVM_CODEGEN_ASMPRINTER_H