LLVM 19.0.0git
AMDGPUArgumentUsageInfo.h
Go to the documentation of this file.
1//==- AMDGPUArgumentrUsageInfo.h - Function Arg Usage Info -------*- 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#ifndef LLVM_LIB_TARGET_AMDGPU_AMDGPUARGUMENTUSAGEINFO_H
10#define LLVM_LIB_TARGET_AMDGPU_AMDGPUARGUMENTUSAGEINFO_H
11
12#include "llvm/ADT/DenseMap.h"
14#include "llvm/Pass.h"
15
16namespace llvm {
17
18class Function;
19class LLT;
20class raw_ostream;
21class TargetRegisterClass;
22class TargetRegisterInfo;
23
25private:
26 friend struct AMDGPUFunctionArgInfo;
28
29 union {
31 unsigned StackOffset;
32 };
33
34 // Bitmask to locate argument within the register.
35 unsigned Mask;
36
37 bool IsStack : 1;
38 bool IsSet : 1;
39
40public:
41 ArgDescriptor(unsigned Val = 0, unsigned Mask = ~0u, bool IsStack = false,
42 bool IsSet = false)
43 : Reg(Val), Mask(Mask), IsStack(IsStack), IsSet(IsSet) {}
44
45 static ArgDescriptor createRegister(Register Reg, unsigned Mask = ~0u) {
46 return ArgDescriptor(Reg, Mask, false, true);
47 }
48
49 static ArgDescriptor createStack(unsigned Offset, unsigned Mask = ~0u) {
50 return ArgDescriptor(Offset, Mask, true, true);
51 }
52
53 static ArgDescriptor createArg(const ArgDescriptor &Arg, unsigned Mask) {
54 return ArgDescriptor(Arg.Reg, Mask, Arg.IsStack, Arg.IsSet);
55 }
56
57 bool isSet() const {
58 return IsSet;
59 }
60
61 explicit operator bool() const {
62 return isSet();
63 }
64
65 bool isRegister() const {
66 return !IsStack;
67 }
68
70 assert(!IsStack);
71 return Reg;
72 }
73
74 unsigned getStackOffset() const {
75 assert(IsStack);
76 return StackOffset;
77 }
78
79 unsigned getMask() const {
80 return Mask;
81 }
82
83 bool isMasked() const {
84 return Mask != ~0u;
85 }
86
87 void print(raw_ostream &OS, const TargetRegisterInfo *TRI = nullptr) const;
88};
89
91 Arg.print(OS);
92 return OS;
93}
94
98};
99
101 // clang-format off
103 // SGPRS:
110 LDS_KERNEL_ID = 6, // LLVM internal, not part of the ABI
117
118 // VGPRS:
123 };
124 // clang-format on
125
126 // Kernel input registers setup for the HSA ABI in allocation order.
127
128 // User SGPRs in kernels
129 // XXX - Can these require argument spills?
138
139 // System SGPRs in kernels.
145
146 // Pointer with offset from kernargsegmentptr to where special ABI arguments
147 // are passed to callable functions.
149
150 // Input registers for non-HSA ABI
152
153 // VGPRs inputs. For entry functions these are either v0, v1 and v2 or packed
154 // into v0, 10 bits per dimension if packed-tid is set.
158
159 // Map the index of preloaded kernel arguments to its descriptor.
161
162 std::tuple<const ArgDescriptor *, const TargetRegisterClass *, LLT>
164
166};
167
169private:
171
172public:
173 static char ID;
174
177
179
180 void getAnalysisUsage(AnalysisUsage &AU) const override {
181 AU.setPreservesAll();
182 }
183
184 bool doInitialization(Module &M) override;
185 bool doFinalization(Module &M) override;
186
187 void print(raw_ostream &OS, const Module *M = nullptr) const override;
188
190 ArgInfoMap[&F] = ArgInfo;
191 }
192
194};
195
196} // end namespace llvm
197
198#endif
This file defines the DenseMap class.
#define F(x, y, z)
Definition: MD5.cpp:55
unsigned const TargetRegisterInfo * TRI
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
static const AMDGPUFunctionArgInfo ExternFunctionInfo
static const AMDGPUFunctionArgInfo FixedABIFunctionInfo
const AMDGPUFunctionArgInfo & lookupFuncArgInfo(const Function &F) const
void setFuncArgInfo(const Function &F, const AMDGPUFunctionArgInfo &ArgInfo)
void print(raw_ostream &OS, const Module *M=nullptr) const override
print - Print out the internal state of the pass.
bool doInitialization(Module &M) override
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...
bool doFinalization(Module &M) override
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
Represent the analysis usage information of a pass.
void setPreservesAll()
Set by analyses that do not transform their input at all.
ImmutablePass class - This class is used to provide information that does not need to be run.
Definition: Pass.h:282
Wrapper class representing physical registers. Should be passed by value.
Definition: MCRegister.h:33
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
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:52
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:293
SmallDenseMap< int, KernArgPreloadDescriptor > PreloadKernArgs
static AMDGPUFunctionArgInfo fixedABILayout()
std::tuple< const ArgDescriptor *, const TargetRegisterClass *, LLT > getPreloadedValue(PreloadedValue Value) const
static ArgDescriptor createStack(unsigned Offset, unsigned Mask=~0u)
MCRegister getRegister() const
static ArgDescriptor createArg(const ArgDescriptor &Arg, unsigned Mask)
void print(raw_ostream &OS, const TargetRegisterInfo *TRI=nullptr) const
static ArgDescriptor createRegister(Register Reg, unsigned Mask=~0u)
unsigned getStackOffset() const
ArgDescriptor(unsigned Val=0, unsigned Mask=~0u, bool IsStack=false, bool IsSet=false)
Helper struct shared between Function Specialization and SCCP Solver.
Definition: SCCPSolver.h:41