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 {
31namespace HSAMD {
32class MetadataStreamer;
33}
34} // namespace AMDGPU
35
36namespace amdhsa {
37struct kernel_descriptor_t;
38}
39
40class AMDGPUAsmPrinter final : public AsmPrinter {
41private:
42 unsigned CodeObjectVersion;
43 void initializeTargetID(const Module &M);
44
45 AMDGPUResourceUsageAnalysis *ResourceUsage;
46
47 SIProgramInfo CurrentProgramInfo;
48
49 std::unique_ptr<AMDGPU::HSAMD::MetadataStreamer> HSAMetadataStream;
50
51 MCCodeEmitter *DumpCodeInstEmitter = nullptr;
52
53 uint64_t getFunctionCodeSize(const MachineFunction &MF) const;
54
55 void getSIProgramInfo(SIProgramInfo &Out, const MachineFunction &MF);
56 void getAmdKernelCode(amd_kernel_code_t &Out, const SIProgramInfo &KernelInfo,
57 const MachineFunction &MF) const;
58
59 /// Emit register usage information so that the GPU driver
60 /// can correctly setup the GPU state.
61 void EmitProgramInfoSI(const MachineFunction &MF,
63 void EmitPALMetadata(const MachineFunction &MF,
65 void emitPALFunctionMetadata(const MachineFunction &MF);
66 void emitCommonFunctionComments(uint32_t NumVGPR,
67 std::optional<uint32_t> NumAGPR,
68 uint32_t TotalNumVGPR, uint32_t NumSGPR,
69 uint64_t ScratchSize, uint64_t CodeSize,
70 const AMDGPUMachineFunction *MFI);
71 void emitResourceUsageRemarks(const MachineFunction &MF,
72 const SIProgramInfo &CurrentProgramInfo,
73 bool isModuleEntryFunction, bool hasMAIInsts);
74
75 uint16_t getAmdhsaKernelCodeProperties(
76 const MachineFunction &MF) const;
77
78 amdhsa::kernel_descriptor_t getAmdhsaKernelDescriptor(
79 const MachineFunction &MF,
80 const SIProgramInfo &PI) const;
81
82 void initTargetStreamer(Module &M);
83
84public:
86 std::unique_ptr<MCStreamer> Streamer);
87
88 StringRef getPassName() const override;
89
90 const MCSubtargetInfo* getGlobalSTI() const;
91
93
94 bool doInitialization(Module &M) override;
95 bool doFinalization(Module &M) override;
97
98 /// Wrapper for MCInstLowering.lowerOperand() for the tblgen'erated
99 /// pseudo lowering.
100 bool lowerOperand(const MachineOperand &MO, MCOperand &MCOp) const;
101
102 /// Lower the specified LLVM Constant to an MCExpr.
103 /// The AsmPrinter::lowerConstantof does not know how to lower
104 /// addrspacecast, therefore they should be lowered by this function.
105 const MCExpr *lowerConstant(const Constant *CV) override;
106
107 /// tblgen'erated driver function for lowering simple MI->MC pseudo
108 /// instructions.
110 const MachineInstr *MI);
111
112 /// Implemented in AMDGPUMCInstLower.cpp
113 void emitInstruction(const MachineInstr *MI) override;
114
115 void emitFunctionBodyStart() override;
116
117 void emitFunctionBodyEnd() override;
118
119 void emitImplicitDef(const MachineInstr *MI) const override;
120
121 void emitFunctionEntryLabel() override;
122
123 void emitBasicBlockStart(const MachineBasicBlock &MBB) override;
124
125 void emitGlobalVariable(const GlobalVariable *GV) override;
126
127 void emitStartOfAsmFile(Module &M) override;
128
129 void emitEndOfAsmFile(Module &M) override;
130
131 bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
132 const char *ExtraCode, raw_ostream &O) override;
133
134protected:
135 void getAnalysisUsage(AnalysisUsage &AU) const override;
136
137 std::vector<std::string> DisasmLines, HexLines;
140};
141
142} // end namespace llvm
143
144#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