1 //===-- AMDGPULowerIntrinsics.cpp -----------------------------------------===//
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 "AMDGPUSubtarget.h"
11 #include "llvm/Analysis/TargetTransformInfo.h"
12 #include "llvm/CodeGen/TargetPassConfig.h"
13 #include "llvm/IR/Constants.h"
14 #include "llvm/IR/Instructions.h"
15 #include "llvm/IR/IntrinsicInst.h"
16 #include "llvm/IR/IntrinsicsAMDGPU.h"
17 #include "llvm/IR/IntrinsicsR600.h"
18 #include "llvm/IR/Module.h"
19 #include "llvm/Support/CommandLine.h"
20 #include "llvm/Target/TargetMachine.h"
21 #include "llvm/Transforms/Utils/LowerMemIntrinsics.h"
22 
23 #define DEBUG_TYPE "amdgpu-lower-intrinsics"
24 
25 using namespace llvm;
26 
27 namespace {
28 
29 static int MaxStaticSize;
30 
31 static cl::opt<int, true> MemIntrinsicExpandSizeThresholdOpt(
32   "amdgpu-mem-intrinsic-expand-size",
33   cl::desc("Set minimum mem intrinsic size to expand in IR"),
34   cl::location(MaxStaticSize),
35   cl::init(1024),
36   cl::Hidden);
37 
38 
39 class AMDGPULowerIntrinsics : public ModulePass {
40 private:
41   bool makeLIDRangeMetadata(Function &F) const;
42 
43 public:
44   static char ID;
45 
46   AMDGPULowerIntrinsics() : ModulePass(ID) {}
47 
48   bool runOnModule(Module &M) override;
49   bool expandMemIntrinsicUses(Function &F);
50   StringRef getPassName() const override {
51     return "AMDGPU Lower Intrinsics";
52   }
53 
54   void getAnalysisUsage(AnalysisUsage &AU) const override {
55     AU.addRequired<TargetTransformInfoWrapperPass>();
56   }
57 };
58 
59 }
60 
61 char AMDGPULowerIntrinsics::ID = 0;
62 
63 char &llvm::AMDGPULowerIntrinsicsID = AMDGPULowerIntrinsics::ID;
64 
65 INITIALIZE_PASS(AMDGPULowerIntrinsics, DEBUG_TYPE, "Lower intrinsics", false,
66                 false)
67 
68 // TODO: Should refine based on estimated number of accesses (e.g. does it
69 // require splitting based on alignment)
70 static bool shouldExpandOperationWithSize(Value *Size) {
71   ConstantInt *CI = dyn_cast<ConstantInt>(Size);
72   return !CI || (CI->getSExtValue() > MaxStaticSize);
73 }
74 
75 bool AMDGPULowerIntrinsics::expandMemIntrinsicUses(Function &F) {
76   Intrinsic::ID ID = F.getIntrinsicID();
77   bool Changed = false;
78 
79   for (auto I = F.user_begin(), E = F.user_end(); I != E;) {
80     Instruction *Inst = cast<Instruction>(*I);
81     ++I;
82 
83     switch (ID) {
84     case Intrinsic::memcpy: {
85       auto *Memcpy = cast<MemCpyInst>(Inst);
86       if (shouldExpandOperationWithSize(Memcpy->getLength())) {
87         Function *ParentFunc = Memcpy->getParent()->getParent();
88         const TargetTransformInfo &TTI =
89             getAnalysis<TargetTransformInfoWrapperPass>().getTTI(*ParentFunc);
90         expandMemCpyAsLoop(Memcpy, TTI);
91         Changed = true;
92         Memcpy->eraseFromParent();
93       }
94 
95       break;
96     }
97     case Intrinsic::memmove: {
98       auto *Memmove = cast<MemMoveInst>(Inst);
99       if (shouldExpandOperationWithSize(Memmove->getLength())) {
100         expandMemMoveAsLoop(Memmove);
101         Changed = true;
102         Memmove->eraseFromParent();
103       }
104 
105       break;
106     }
107     case Intrinsic::memset: {
108       auto *Memset = cast<MemSetInst>(Inst);
109       if (shouldExpandOperationWithSize(Memset->getLength())) {
110         expandMemSetAsLoop(Memset);
111         Changed = true;
112         Memset->eraseFromParent();
113       }
114 
115       break;
116     }
117     default:
118       break;
119     }
120   }
121 
122   return Changed;
123 }
124 
125 bool AMDGPULowerIntrinsics::makeLIDRangeMetadata(Function &F) const {
126   auto *TPC = getAnalysisIfAvailable<TargetPassConfig>();
127   if (!TPC)
128     return false;
129 
130   const TargetMachine &TM = TPC->getTM<TargetMachine>();
131   bool Changed = false;
132 
133   for (auto *U : F.users()) {
134     auto *CI = dyn_cast<CallInst>(U);
135     if (!CI)
136       continue;
137 
138     Function *Caller = CI->getParent()->getParent();
139     const AMDGPUSubtarget &ST = AMDGPUSubtarget::get(TM, *Caller);
140     Changed |= ST.makeLIDRangeMetadata(CI);
141   }
142   return Changed;
143 }
144 
145 bool AMDGPULowerIntrinsics::runOnModule(Module &M) {
146   bool Changed = false;
147 
148   for (Function &F : M) {
149     if (!F.isDeclaration())
150       continue;
151 
152     switch (F.getIntrinsicID()) {
153     case Intrinsic::memcpy:
154     case Intrinsic::memmove:
155     case Intrinsic::memset:
156       if (expandMemIntrinsicUses(F))
157         Changed = true;
158       break;
159 
160     case Intrinsic::amdgcn_workitem_id_x:
161     case Intrinsic::r600_read_tidig_x:
162     case Intrinsic::amdgcn_workitem_id_y:
163     case Intrinsic::r600_read_tidig_y:
164     case Intrinsic::amdgcn_workitem_id_z:
165     case Intrinsic::r600_read_tidig_z:
166     case Intrinsic::r600_read_local_size_x:
167     case Intrinsic::r600_read_local_size_y:
168     case Intrinsic::r600_read_local_size_z:
169       Changed |= makeLIDRangeMetadata(F);
170       break;
171 
172     default:
173       break;
174     }
175   }
176 
177   return Changed;
178 }
179 
180 ModulePass *llvm::createAMDGPULowerIntrinsicsPass() {
181   return new AMDGPULowerIntrinsics();
182 }
183