LLVM  12.0.0git
AMDGPUArgumentUsageInfo.cpp
Go to the documentation of this file.
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 "AMDGPU.h"
11 #include "AMDGPUTargetMachine.h"
13 #include "SIRegisterInfo.h"
16 
17 using namespace llvm;
18 
19 #define DEBUG_TYPE "amdgpu-argument-reg-usage-info"
20 
22  "Argument Register Usage Information Storage", false, true)
23 
25  const TargetRegisterInfo *TRI) const {
26  if (!isSet()) {
27  OS << "<not set>\n";
28  return;
29  }
30 
31  if (isRegister())
32  OS << "Reg " << printReg(getRegister(), TRI);
33  else
34  OS << "Stack offset " << getStackOffset();
35 
36  if (isMasked()) {
37  OS << " & ";
39  }
40 
41  OS << '\n';
42 }
43 
45 
47 
48 // Hardcoded registers from fixed function ABI
51 
53  return false;
54 }
55 
57  ArgInfoMap.clear();
58  return false;
59 }
60 
62  for (const auto &FI : ArgInfoMap) {
63  OS << "Arguments for " << FI.first->getName() << '\n'
64  << " PrivateSegmentBuffer: " << FI.second.PrivateSegmentBuffer
65  << " DispatchPtr: " << FI.second.DispatchPtr
66  << " QueuePtr: " << FI.second.QueuePtr
67  << " KernargSegmentPtr: " << FI.second.KernargSegmentPtr
68  << " DispatchID: " << FI.second.DispatchID
69  << " FlatScratchInit: " << FI.second.FlatScratchInit
70  << " PrivateSegmentSize: " << FI.second.PrivateSegmentSize
71  << " WorkGroupIDX: " << FI.second.WorkGroupIDX
72  << " WorkGroupIDY: " << FI.second.WorkGroupIDY
73  << " WorkGroupIDZ: " << FI.second.WorkGroupIDZ
74  << " WorkGroupInfo: " << FI.second.WorkGroupInfo
75  << " PrivateSegmentWaveByteOffset: "
76  << FI.second.PrivateSegmentWaveByteOffset
77  << " ImplicitBufferPtr: " << FI.second.ImplicitBufferPtr
78  << " ImplicitArgPtr: " << FI.second.ImplicitArgPtr
79  << " WorkItemIDX " << FI.second.WorkItemIDX
80  << " WorkItemIDY " << FI.second.WorkItemIDY
81  << " WorkItemIDZ " << FI.second.WorkItemIDZ
82  << '\n';
83  }
84 }
85 
86 std::tuple<const ArgDescriptor *, const TargetRegisterClass *, LLT>
89  switch (Value) {
91  return std::make_tuple(PrivateSegmentBuffer ? &PrivateSegmentBuffer
92  : nullptr,
93  &AMDGPU::SGPR_128RegClass, LLT::vector(4, 32));
94  }
96  return std::make_tuple(ImplicitBufferPtr ? &ImplicitBufferPtr : nullptr,
97  &AMDGPU::SGPR_64RegClass,
100  return std::make_tuple(WorkGroupIDX ? &WorkGroupIDX : nullptr,
101  &AMDGPU::SGPR_32RegClass, LLT::scalar(32));
103  return std::make_tuple(WorkGroupIDY ? &WorkGroupIDY : nullptr,
104  &AMDGPU::SGPR_32RegClass, LLT::scalar(32));
106  return std::make_tuple(WorkGroupIDZ ? &WorkGroupIDZ : nullptr,
107  &AMDGPU::SGPR_32RegClass, LLT::scalar(32));
109  return std::make_tuple(
110  PrivateSegmentWaveByteOffset ? &PrivateSegmentWaveByteOffset : nullptr,
111  &AMDGPU::SGPR_32RegClass, LLT::scalar(32));
113  return std::make_tuple(KernargSegmentPtr ? &KernargSegmentPtr : nullptr,
114  &AMDGPU::SGPR_64RegClass,
117  return std::make_tuple(ImplicitArgPtr ? &ImplicitArgPtr : nullptr,
118  &AMDGPU::SGPR_64RegClass,
121  return std::make_tuple(DispatchID ? &DispatchID : nullptr,
122  &AMDGPU::SGPR_64RegClass, LLT::scalar(64));
124  return std::make_tuple(FlatScratchInit ? &FlatScratchInit : nullptr,
125  &AMDGPU::SGPR_64RegClass, LLT::scalar(64));
127  return std::make_tuple(DispatchPtr ? &DispatchPtr : nullptr,
128  &AMDGPU::SGPR_64RegClass,
131  return std::make_tuple(QueuePtr ? &QueuePtr : nullptr,
132  &AMDGPU::SGPR_64RegClass,
135  return std::make_tuple(WorkItemIDX ? &WorkItemIDX : nullptr,
136  &AMDGPU::VGPR_32RegClass, LLT::scalar(32));
138  return std::make_tuple(WorkItemIDY ? &WorkItemIDY : nullptr,
139  &AMDGPU::VGPR_32RegClass, LLT::scalar(32));
141  return std::make_tuple(WorkItemIDZ ? &WorkItemIDZ : nullptr,
142  &AMDGPU::VGPR_32RegClass, LLT::scalar(32));
143  }
144  llvm_unreachable("unexpected preloaded value type");
145 }
146 
150  = ArgDescriptor::createRegister(AMDGPU::SGPR0_SGPR1_SGPR2_SGPR3);
151  AI.DispatchPtr = ArgDescriptor::createRegister(AMDGPU::SGPR4_SGPR5);
152  AI.QueuePtr = ArgDescriptor::createRegister(AMDGPU::SGPR6_SGPR7);
153 
154  // Do not pass kernarg segment pointer, only pass increment version in its
155  // place.
156  AI.ImplicitArgPtr = ArgDescriptor::createRegister(AMDGPU::SGPR8_SGPR9);
157  AI.DispatchID = ArgDescriptor::createRegister(AMDGPU::SGPR10_SGPR11);
158 
159  // Skip FlatScratchInit/PrivateSegmentSize
160  AI.WorkGroupIDX = ArgDescriptor::createRegister(AMDGPU::SGPR12);
161  AI.WorkGroupIDY = ArgDescriptor::createRegister(AMDGPU::SGPR13);
162  AI.WorkGroupIDZ = ArgDescriptor::createRegister(AMDGPU::SGPR14);
163 
164  const unsigned Mask = 0x3ff;
165  AI.WorkItemIDX = ArgDescriptor::createRegister(AMDGPU::VGPR31, Mask);
166  AI.WorkItemIDY = ArgDescriptor::createRegister(AMDGPU::VGPR31, Mask << 10);
167  AI.WorkItemIDZ = ArgDescriptor::createRegister(AMDGPU::VGPR31, Mask << 20);
168  return AI;
169 }
170 
171 const AMDGPUFunctionArgInfo &
173  auto I = ArgInfoMap.find(&F);
174  if (I == ArgInfoMap.end()) {
176  return FixedABIFunctionInfo;
177 
178  // Without the fixed ABI, we assume no function has special inputs.
179  assert(F.isDeclaration());
180  return ExternFunctionInfo;
181  }
182 
183  return I->second;
184 }
void print(raw_ostream &OS, const Module *M=nullptr) const override
print - Print out the internal state of the pass.
Interface definition for SIRegisterInfo.
static LLT pointer(unsigned AddressSpace, unsigned SizeInBits)
Get a low-level pointer in the given address space.
static constexpr ArgDescriptor createRegister(Register Reg, unsigned Mask=~0u)
This class represents lattice values for constants.
Definition: AllocatorList.h:23
static constexpr AMDGPUFunctionArgInfo fixedABILayout()
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:67
std::tuple< const ArgDescriptor *, const TargetRegisterClass *, LLT > getPreloadedValue(PreloadedValue Value) const
unsigned const TargetRegisterInfo * TRI
F(f)
Printable printReg(Register Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubIdx=0, const MachineRegisterInfo *MRI=nullptr)
Prints virtual and physical registers with or without a TRI instance.
Address space for constant memory (VTX2).
Definition: AMDGPU.h:301
std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E&#39;s largest value.
Definition: BitmaskEnum.h:80
static LLT scalar(unsigned SizeInBits)
Get a low-level scalar or aggregate "bag of bits".
static StackOffset getStackOffset(const MachineFunction &MF, int64_t ObjectOffset)
bool doInitialization(Module &M) override
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
The AMDGPU TargetMachine interface definition for hw codgen targets.
const AMDGPUFunctionArgInfo & lookupFuncArgInfo(const Function &F) const
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:37
static const AMDGPUFunctionArgInfo FixedABIFunctionInfo
Provides AMDGPU specific target descriptions.
void write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style, Optional< size_t > Width=None)
static const AMDGPUFunctionArgInfo ExternFunctionInfo
#define I(x, y, z)
Definition: MD5.cpp:59
#define DEBUG_TYPE
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:227
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
aarch64 promote const
LLVM Value Representation.
Definition: Value.h:74
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
static LLT vector(uint16_t NumElements, unsigned ScalarSizeInBits)
Get a low-level vector of some number of elements and element width.
bool doFinalization(Module &M) override
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...