LLVM 19.0.0git
AMDGPUAsmPrinter.h
Go to the documentation of this file.
1//===-- AMDGPUAsmPrinter.h - Print AMDGPU assembly code ---------*- 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/// \file
10/// AMDGPU Assembly printer class.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_TARGET_AMDGPU_AMDGPUASMPRINTER_H
15#define LLVM_LIB_TARGET_AMDGPU_AMDGPUASMPRINTER_H
16
17#include "SIProgramInfo.h"
19
21
22namespace llvm {
23
24class AMDGPUMachineFunction;
25struct AMDGPUResourceUsageAnalysis;
26class AMDGPUTargetStreamer;
27class MCCodeEmitter;
28class MCOperand;
29
30namespace AMDGPU {
31struct MCKernelDescriptor;
32namespace HSAMD {
33class MetadataStreamer;
34}
35} // namespace AMDGPU
36
37class AMDGPUAsmPrinter final : public AsmPrinter {
38private:
39 unsigned CodeObjectVersion;
40 void initializeTargetID(const Module &M);
41
42 AMDGPUResourceUsageAnalysis *ResourceUsage;
43
44 SIProgramInfo CurrentProgramInfo;
45
46 std::unique_ptr<AMDGPU::HSAMD::MetadataStreamer> HSAMetadataStream;
47
48 MCCodeEmitter *DumpCodeInstEmitter = nullptr;
49
50 uint64_t getFunctionCodeSize(const MachineFunction &MF) const;
51
52 void getSIProgramInfo(SIProgramInfo &Out, const MachineFunction &MF);
53 void getAmdKernelCode(amd_kernel_code_t &Out, const SIProgramInfo &KernelInfo,
54 const MachineFunction &MF) const;
55
56 /// Emit register usage information so that the GPU driver
57 /// can correctly setup the GPU state.
58 void EmitProgramInfoSI(const MachineFunction &MF,
60 void EmitPALMetadata(const MachineFunction &MF,
62 void emitPALFunctionMetadata(const MachineFunction &MF);
63 void emitCommonFunctionComments(uint32_t NumVGPR,
64 std::optional<uint32_t> NumAGPR,
65 uint32_t TotalNumVGPR, uint32_t NumSGPR,
66 uint64_t ScratchSize, uint64_t CodeSize,
67 const AMDGPUMachineFunction *MFI);
68 void emitResourceUsageRemarks(const MachineFunction &MF,
69 const SIProgramInfo &CurrentProgramInfo,
70 bool isModuleEntryFunction, bool hasMAIInsts);
71
72 uint16_t getAmdhsaKernelCodeProperties(
73 const MachineFunction &MF) const;
74
76 getAmdhsaKernelDescriptor(const MachineFunction &MF,
77 const SIProgramInfo &PI) const;
78
79 void initTargetStreamer(Module &M);
80
81public:
83 std::unique_ptr<MCStreamer> Streamer);
84
85 StringRef getPassName() const override;
86
87 const MCSubtargetInfo* getGlobalSTI() const;
88
90
91 bool doInitialization(Module &M) override;
92 bool doFinalization(Module &M) override;
94
95 /// Wrapper for MCInstLowering.lowerOperand() for the tblgen'erated
96 /// pseudo lowering.
97 bool lowerOperand(const MachineOperand &MO, MCOperand &MCOp) const;
98
99 /// Lower the specified LLVM Constant to an MCExpr.
100 /// The AsmPrinter::lowerConstantof does not know how to lower
101 /// addrspacecast, therefore they should be lowered by this function.
102 const MCExpr *lowerConstant(const Constant *CV) override;
103
104 /// tblgen'erated driver function for lowering simple MI->MC pseudo
105 /// instructions.
107 const MachineInstr *MI);
108
109 /// Implemented in AMDGPUMCInstLower.cpp
110 void emitInstruction(const MachineInstr *MI) override;
111
112 void emitFunctionBodyStart() override;
113
114 void emitFunctionBodyEnd() override;
115
116 void emitImplicitDef(const MachineInstr *MI) const override;
117
118 void emitFunctionEntryLabel() override;
119
120 void emitBasicBlockStart(const MachineBasicBlock &MBB) override;
121
122 void emitGlobalVariable(const GlobalVariable *GV) override;
123
124 void emitStartOfAsmFile(Module &M) override;
125
126 void emitEndOfAsmFile(Module &M) override;
127
128 bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
129 const char *ExtraCode, raw_ostream &O) override;
130
131protected:
132 void getAnalysisUsage(AnalysisUsage &AU) const override;
133
134 std::vector<std::string> DisasmLines, HexLines;
137};
138
139} // end namespace llvm
140
141#endif // LLVM_LIB_TARGET_AMDGPU_AMDGPUASMPRINTER_H
MachineBasicBlock & MBB
IRTranslator LLVM IR MI
Defines struct to track resource usage and hardware flags for kernels and entry functions.
void emitFunctionEntryLabel() override
EmitFunctionEntryLabel - Emit the label that is the entrypoint for the function.
const MCSubtargetInfo * getGlobalSTI() const
void emitImplicitDef(const MachineInstr *MI) const override
Targets can override this to customize the output of IMPLICIT_DEF instructions in verbose mode.
std::vector< std::string > DisasmLines
void emitStartOfAsmFile(Module &M) override
This virtual method can be overridden by targets that want to emit something at the start of their fi...
StringRef getPassName() const override
getPassName - Return a nice clean name for a pass.
std::vector< std::string > HexLines
bool emitPseudoExpansionLowering(MCStreamer &OutStreamer, const MachineInstr *MI)
tblgen'erated driver function for lowering simple MI->MC pseudo instructions.
void emitGlobalVariable(const GlobalVariable *GV) override
Emit the specified global variable to the .s file.
bool lowerOperand(const MachineOperand &MO, MCOperand &MCOp) const
Wrapper for MCInstLowering.lowerOperand() for the tblgen'erated pseudo lowering.
void getAnalysisUsage(AnalysisUsage &AU) const override
Record analysis usage.
bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &O) override
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant.
bool runOnMachineFunction(MachineFunction &MF) override
Emit the specified function out to the OutStreamer.
void emitFunctionBodyEnd() override
Targets can override this to emit stuff after the last basic block in the function.
bool doFinalization(Module &M) override
Shut down the asmprinter.
void emitEndOfAsmFile(Module &M) override
This virtual method can be overridden by targets that want to emit something at the end of their file...
bool doInitialization(Module &M) override
Set up the AsmPrinter when we are working on a new module.
const MCExpr * lowerConstant(const Constant *CV) override
Lower the specified LLVM Constant to an MCExpr.
void emitFunctionBodyStart() override
Targets can override this to emit stuff before the first basic block in the function.
void emitBasicBlockStart(const MachineBasicBlock &MBB) override
Targets can override this to emit stuff at the start of a basic block.
void emitInstruction(const MachineInstr *MI) override
Implemented in AMDGPUMCInstLower.cpp.
AMDGPUTargetStreamer * getTargetStreamer() const
Represent the analysis usage information of a pass.
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:84
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:87
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:102
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:99
This is an important base class in LLVM.
Definition: Constant.h:41
MCCodeEmitter - Generic instruction encoding interface.
Definition: MCCodeEmitter.h:21
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
Instances of this class represent operands of the MCInst class.
Definition: MCInst.h:36
Streaming machine code generation interface.
Definition: MCStreamer.h:212
Generic base class for all target subtargets.
Representation of each machine instruction.
Definition: MachineInstr.h:69
MachineOperand class - Representation of each machine instruction operand.
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:76
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
AMD Kernel Code Object (amd_kernel_code_t).
Track resource usage for kernels / entry functions.
Definition: SIProgramInfo.h:27