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" 10 #include "AMDGPUArgumentUsageInfo.h" 11 #include "SIRegisterInfo.h" 12 #include "llvm/Support/raw_ostream.h" 13 14 using namespace llvm; 15 16 #define DEBUG_TYPE "amdgpu-argument-reg-usage-info" 17 18 INITIALIZE_PASS(AMDGPUArgumentUsageInfo, DEBUG_TYPE, 19 "Argument Register Usage Information Storage", false, true) 20 21 void ArgDescriptor::print(raw_ostream &OS, 22 const TargetRegisterInfo *TRI) const { 23 if (!isSet()) { 24 OS << "<not set>\n"; 25 return; 26 } 27 28 if (isRegister()) 29 OS << "Reg " << printReg(getRegister(), TRI) << '\n'; 30 else 31 OS << "Stack offset " << getStackOffset() << '\n'; 32 } 33 34 char AMDGPUArgumentUsageInfo::ID = 0; 35 36 const AMDGPUFunctionArgInfo AMDGPUArgumentUsageInfo::ExternFunctionInfo{}; 37 38 bool AMDGPUArgumentUsageInfo::doInitialization(Module &M) { 39 return false; 40 } 41 42 bool AMDGPUArgumentUsageInfo::doFinalization(Module &M) { 43 ArgInfoMap.clear(); 44 return false; 45 } 46 47 void AMDGPUArgumentUsageInfo::print(raw_ostream &OS, const Module *M) const { 48 for (const auto &FI : ArgInfoMap) { 49 OS << "Arguments for " << FI.first->getName() << '\n' 50 << " PrivateSegmentBuffer: " << FI.second.PrivateSegmentBuffer 51 << " DispatchPtr: " << FI.second.DispatchPtr 52 << " QueuePtr: " << FI.second.QueuePtr 53 << " KernargSegmentPtr: " << FI.second.KernargSegmentPtr 54 << " DispatchID: " << FI.second.DispatchID 55 << " FlatScratchInit: " << FI.second.FlatScratchInit 56 << " PrivateSegmentSize: " << FI.second.PrivateSegmentSize 57 << " WorkGroupIDX: " << FI.second.WorkGroupIDX 58 << " WorkGroupIDY: " << FI.second.WorkGroupIDY 59 << " WorkGroupIDZ: " << FI.second.WorkGroupIDZ 60 << " WorkGroupInfo: " << FI.second.WorkGroupInfo 61 << " PrivateSegmentWaveByteOffset: " 62 << FI.second.PrivateSegmentWaveByteOffset 63 << " ImplicitBufferPtr: " << FI.second.ImplicitBufferPtr 64 << " ImplicitArgPtr: " << FI.second.ImplicitArgPtr 65 << " WorkItemIDX " << FI.second.WorkItemIDX 66 << " WorkItemIDY " << FI.second.WorkItemIDY 67 << " WorkItemIDZ " << FI.second.WorkItemIDZ 68 << '\n'; 69 } 70 } 71 72 std::pair<const ArgDescriptor *, const TargetRegisterClass *> 73 AMDGPUFunctionArgInfo::getPreloadedValue( 74 AMDGPUFunctionArgInfo::PreloadedValue Value) const { 75 switch (Value) { 76 case AMDGPUFunctionArgInfo::PRIVATE_SEGMENT_BUFFER: { 77 return std::make_pair( 78 PrivateSegmentBuffer ? &PrivateSegmentBuffer : nullptr, 79 &AMDGPU::SGPR_128RegClass); 80 } 81 case AMDGPUFunctionArgInfo::IMPLICIT_BUFFER_PTR: 82 return std::make_pair(ImplicitBufferPtr ? &ImplicitBufferPtr : nullptr, 83 &AMDGPU::SGPR_64RegClass); 84 case AMDGPUFunctionArgInfo::WORKGROUP_ID_X: 85 return std::make_pair(WorkGroupIDX ? &WorkGroupIDX : nullptr, 86 &AMDGPU::SGPR_32RegClass); 87 88 case AMDGPUFunctionArgInfo::WORKGROUP_ID_Y: 89 return std::make_pair(WorkGroupIDY ? &WorkGroupIDY : nullptr, 90 &AMDGPU::SGPR_32RegClass); 91 case AMDGPUFunctionArgInfo::WORKGROUP_ID_Z: 92 return std::make_pair(WorkGroupIDZ ? &WorkGroupIDZ : nullptr, 93 &AMDGPU::SGPR_32RegClass); 94 case AMDGPUFunctionArgInfo::PRIVATE_SEGMENT_WAVE_BYTE_OFFSET: 95 return std::make_pair( 96 PrivateSegmentWaveByteOffset ? &PrivateSegmentWaveByteOffset : nullptr, 97 &AMDGPU::SGPR_32RegClass); 98 case AMDGPUFunctionArgInfo::KERNARG_SEGMENT_PTR: 99 return std::make_pair(KernargSegmentPtr ? &KernargSegmentPtr : nullptr, 100 &AMDGPU::SGPR_64RegClass); 101 case AMDGPUFunctionArgInfo::IMPLICIT_ARG_PTR: 102 return std::make_pair(ImplicitArgPtr ? &ImplicitArgPtr : nullptr, 103 &AMDGPU::SGPR_64RegClass); 104 case AMDGPUFunctionArgInfo::DISPATCH_ID: 105 return std::make_pair(DispatchID ? &DispatchID : nullptr, 106 &AMDGPU::SGPR_64RegClass); 107 case AMDGPUFunctionArgInfo::FLAT_SCRATCH_INIT: 108 return std::make_pair(FlatScratchInit ? &FlatScratchInit : nullptr, 109 &AMDGPU::SGPR_64RegClass); 110 case AMDGPUFunctionArgInfo::DISPATCH_PTR: 111 return std::make_pair(DispatchPtr ? &DispatchPtr : nullptr, 112 &AMDGPU::SGPR_64RegClass); 113 case AMDGPUFunctionArgInfo::QUEUE_PTR: 114 return std::make_pair(QueuePtr ? &QueuePtr : nullptr, 115 &AMDGPU::SGPR_64RegClass); 116 case AMDGPUFunctionArgInfo::WORKITEM_ID_X: 117 return std::make_pair(WorkItemIDX ? &WorkItemIDX : nullptr, 118 &AMDGPU::VGPR_32RegClass); 119 case AMDGPUFunctionArgInfo::WORKITEM_ID_Y: 120 return std::make_pair(WorkItemIDY ? &WorkItemIDY : nullptr, 121 &AMDGPU::VGPR_32RegClass); 122 case AMDGPUFunctionArgInfo::WORKITEM_ID_Z: 123 return std::make_pair(WorkItemIDZ ? &WorkItemIDZ : nullptr, 124 &AMDGPU::VGPR_32RegClass); 125 } 126 llvm_unreachable("unexpected preloaded value type"); 127 } 128