1 //===----------------------------------------------------------------------===//
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 #include "AMDGPUArgumentUsageInfo.h"
10 #include "AMDGPU.h"
11 #include "AMDGPUTargetMachine.h"
12 #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
13 #include "SIRegisterInfo.h"
14 #include "llvm/CodeGen/TargetRegisterInfo.h"
15 #include "llvm/IR/Function.h"
16 #include "llvm/Support/NativeFormatting.h"
17 #include "llvm/Support/raw_ostream.h"
18 
19 using namespace llvm;
20 
21 #define DEBUG_TYPE "amdgpu-argument-reg-usage-info"
22 
23 INITIALIZE_PASS(AMDGPUArgumentUsageInfo, DEBUG_TYPE,
24                 "Argument Register Usage Information Storage", false, true)
25 
print(raw_ostream & OS,const TargetRegisterInfo * TRI) const26 void ArgDescriptor::print(raw_ostream &OS,
27                           const TargetRegisterInfo *TRI) const {
28   if (!isSet()) {
29     OS << "<not set>\n";
30     return;
31   }
32 
33   if (isRegister())
34     OS << "Reg " << printReg(getRegister(), TRI);
35   else
36     OS << "Stack offset " << getStackOffset();
37 
38   if (isMasked()) {
39     OS << " & ";
40     llvm::write_hex(OS, Mask, llvm::HexPrintStyle::PrefixLower);
41   }
42 
43   OS << '\n';
44 }
45 
46 char AMDGPUArgumentUsageInfo::ID = 0;
47 
48 const AMDGPUFunctionArgInfo AMDGPUArgumentUsageInfo::ExternFunctionInfo{};
49 
50 // Hardcoded registers from fixed function ABI
51 const AMDGPUFunctionArgInfo AMDGPUArgumentUsageInfo::FixedABIFunctionInfo
52   = AMDGPUFunctionArgInfo::fixedABILayout();
53 
doInitialization(Module & M)54 bool AMDGPUArgumentUsageInfo::doInitialization(Module &M) {
55   return false;
56 }
57 
doFinalization(Module & M)58 bool AMDGPUArgumentUsageInfo::doFinalization(Module &M) {
59   ArgInfoMap.clear();
60   return false;
61 }
62 
print(raw_ostream & OS,const Module * M) const63 void AMDGPUArgumentUsageInfo::print(raw_ostream &OS, const Module *M) const {
64   for (const auto &FI : ArgInfoMap) {
65     OS << "Arguments for " << FI.first->getName() << '\n'
66        << "  PrivateSegmentBuffer: " << FI.second.PrivateSegmentBuffer
67        << "  DispatchPtr: " << FI.second.DispatchPtr
68        << "  QueuePtr: " << FI.second.QueuePtr
69        << "  KernargSegmentPtr: " << FI.second.KernargSegmentPtr
70        << "  DispatchID: " << FI.second.DispatchID
71        << "  FlatScratchInit: " << FI.second.FlatScratchInit
72        << "  PrivateSegmentSize: " << FI.second.PrivateSegmentSize
73        << "  WorkGroupIDX: " << FI.second.WorkGroupIDX
74        << "  WorkGroupIDY: " << FI.second.WorkGroupIDY
75        << "  WorkGroupIDZ: " << FI.second.WorkGroupIDZ
76        << "  WorkGroupInfo: " << FI.second.WorkGroupInfo
77        << "  LDSKernelId: " << FI.second.LDSKernelId
78        << "  PrivateSegmentWaveByteOffset: "
79           << FI.second.PrivateSegmentWaveByteOffset
80        << "  ImplicitBufferPtr: " << FI.second.ImplicitBufferPtr
81        << "  ImplicitArgPtr: " << FI.second.ImplicitArgPtr
82        << "  WorkItemIDX " << FI.second.WorkItemIDX
83        << "  WorkItemIDY " << FI.second.WorkItemIDY
84        << "  WorkItemIDZ " << FI.second.WorkItemIDZ
85        << '\n';
86   }
87 }
88 
89 std::tuple<const ArgDescriptor *, const TargetRegisterClass *, LLT>
getPreloadedValue(AMDGPUFunctionArgInfo::PreloadedValue Value) const90 AMDGPUFunctionArgInfo::getPreloadedValue(
91     AMDGPUFunctionArgInfo::PreloadedValue Value) const {
92   switch (Value) {
93   case AMDGPUFunctionArgInfo::PRIVATE_SEGMENT_BUFFER: {
94     return std::make_tuple(PrivateSegmentBuffer ? &PrivateSegmentBuffer
95                                                 : nullptr,
96                            &AMDGPU::SGPR_128RegClass, LLT::fixed_vector(4, 32));
97   }
98   case AMDGPUFunctionArgInfo::IMPLICIT_BUFFER_PTR:
99     return std::make_tuple(ImplicitBufferPtr ? &ImplicitBufferPtr : nullptr,
100                            &AMDGPU::SGPR_64RegClass,
101                            LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS, 64));
102   case AMDGPUFunctionArgInfo::WORKGROUP_ID_X:
103     return std::make_tuple(WorkGroupIDX ? &WorkGroupIDX : nullptr,
104                            &AMDGPU::SGPR_32RegClass, LLT::scalar(32));
105   case AMDGPUFunctionArgInfo::WORKGROUP_ID_Y:
106     return std::make_tuple(WorkGroupIDY ? &WorkGroupIDY : nullptr,
107                            &AMDGPU::SGPR_32RegClass, LLT::scalar(32));
108   case AMDGPUFunctionArgInfo::WORKGROUP_ID_Z:
109     return std::make_tuple(WorkGroupIDZ ? &WorkGroupIDZ : nullptr,
110                            &AMDGPU::SGPR_32RegClass, LLT::scalar(32));
111   case AMDGPUFunctionArgInfo::LDS_KERNEL_ID:
112     return std::make_tuple(LDSKernelId ? &LDSKernelId : nullptr,
113                            &AMDGPU::SGPR_32RegClass, LLT::scalar(32));
114   case AMDGPUFunctionArgInfo::PRIVATE_SEGMENT_WAVE_BYTE_OFFSET:
115     return std::make_tuple(
116         PrivateSegmentWaveByteOffset ? &PrivateSegmentWaveByteOffset : nullptr,
117         &AMDGPU::SGPR_32RegClass, LLT::scalar(32));
118   case AMDGPUFunctionArgInfo::KERNARG_SEGMENT_PTR:
119     return std::make_tuple(KernargSegmentPtr ? &KernargSegmentPtr : nullptr,
120                            &AMDGPU::SGPR_64RegClass,
121                            LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS, 64));
122   case AMDGPUFunctionArgInfo::IMPLICIT_ARG_PTR:
123     return std::make_tuple(ImplicitArgPtr ? &ImplicitArgPtr : nullptr,
124                            &AMDGPU::SGPR_64RegClass,
125                            LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS, 64));
126   case AMDGPUFunctionArgInfo::DISPATCH_ID:
127     return std::make_tuple(DispatchID ? &DispatchID : nullptr,
128                            &AMDGPU::SGPR_64RegClass, LLT::scalar(64));
129   case AMDGPUFunctionArgInfo::FLAT_SCRATCH_INIT:
130     return std::make_tuple(FlatScratchInit ? &FlatScratchInit : nullptr,
131                            &AMDGPU::SGPR_64RegClass, LLT::scalar(64));
132   case AMDGPUFunctionArgInfo::DISPATCH_PTR:
133     return std::make_tuple(DispatchPtr ? &DispatchPtr : nullptr,
134                            &AMDGPU::SGPR_64RegClass,
135                            LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS, 64));
136   case AMDGPUFunctionArgInfo::QUEUE_PTR:
137     return std::make_tuple(QueuePtr ? &QueuePtr : nullptr,
138                            &AMDGPU::SGPR_64RegClass,
139                            LLT::pointer(AMDGPUAS::CONSTANT_ADDRESS, 64));
140   case AMDGPUFunctionArgInfo::WORKITEM_ID_X:
141     return std::make_tuple(WorkItemIDX ? &WorkItemIDX : nullptr,
142                            &AMDGPU::VGPR_32RegClass, LLT::scalar(32));
143   case AMDGPUFunctionArgInfo::WORKITEM_ID_Y:
144     return std::make_tuple(WorkItemIDY ? &WorkItemIDY : nullptr,
145                            &AMDGPU::VGPR_32RegClass, LLT::scalar(32));
146   case AMDGPUFunctionArgInfo::WORKITEM_ID_Z:
147     return std::make_tuple(WorkItemIDZ ? &WorkItemIDZ : nullptr,
148                            &AMDGPU::VGPR_32RegClass, LLT::scalar(32));
149   }
150   llvm_unreachable("unexpected preloaded value type");
151 }
152 
fixedABILayout()153 constexpr AMDGPUFunctionArgInfo AMDGPUFunctionArgInfo::fixedABILayout() {
154   AMDGPUFunctionArgInfo AI;
155   AI.PrivateSegmentBuffer
156     = ArgDescriptor::createRegister(AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3);
157   AI.DispatchPtr = ArgDescriptor::createRegister(AMDGPU::SGPR4_SGPR5);
158   AI.QueuePtr = ArgDescriptor::createRegister(AMDGPU::SGPR6_SGPR7);
159 
160   // Do not pass kernarg segment pointer, only pass increment version in its
161   // place.
162   AI.ImplicitArgPtr = ArgDescriptor::createRegister(AMDGPU::SGPR8_SGPR9);
163   AI.DispatchID = ArgDescriptor::createRegister(AMDGPU::SGPR10_SGPR11);
164 
165   // Skip FlatScratchInit/PrivateSegmentSize
166   AI.WorkGroupIDX = ArgDescriptor::createRegister(AMDGPU::SGPR12);
167   AI.WorkGroupIDY = ArgDescriptor::createRegister(AMDGPU::SGPR13);
168   AI.WorkGroupIDZ = ArgDescriptor::createRegister(AMDGPU::SGPR14);
169   AI.LDSKernelId = ArgDescriptor::createRegister(AMDGPU::SGPR15);
170 
171   const unsigned Mask = 0x3ff;
172   AI.WorkItemIDX = ArgDescriptor::createRegister(AMDGPU::VGPR31, Mask);
173   AI.WorkItemIDY = ArgDescriptor::createRegister(AMDGPU::VGPR31, Mask << 10);
174   AI.WorkItemIDZ = ArgDescriptor::createRegister(AMDGPU::VGPR31, Mask << 20);
175   return AI;
176 }
177 
178 const AMDGPUFunctionArgInfo &
lookupFuncArgInfo(const Function & F) const179 AMDGPUArgumentUsageInfo::lookupFuncArgInfo(const Function &F) const {
180   auto I = ArgInfoMap.find(&F);
181   if (I == ArgInfoMap.end())
182     return FixedABIFunctionInfo;
183   return I->second;
184 }
185