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