1//===-- GenericToNVVM.cpp - Convert generic module to NVVM module - 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// Convert generic global variables into either .global or .const access based
10// on the variable's "constant" qualifier.
11//
12//===----------------------------------------------------------------------===//
13
14#include "MCTargetDesc/NVPTXBaseInfo.h"
15#include "NVPTX.h"
16#include "NVPTXUtilities.h"
17#include "llvm/CodeGen/ValueTypes.h"
18#include "llvm/IR/Constants.h"
19#include "llvm/IR/DerivedTypes.h"
20#include "llvm/IR/IRBuilder.h"
21#include "llvm/IR/Instructions.h"
22#include "llvm/IR/Intrinsics.h"
23#include "llvm/IR/LegacyPassManager.h"
24#include "llvm/IR/Module.h"
25#include "llvm/IR/Operator.h"
26#include "llvm/IR/ValueMap.h"
27#include "llvm/Transforms/Utils/ValueMapper.h"
28
29using namespace llvm;
30
31namespace llvm {
32void initializeGenericToNVVMLegacyPassPass(PassRegistry &);
33}
34
35namespace {
36class GenericToNVVM {
37public:
38 bool runOnModule(Module &M);
39
40private:
41 Value *remapConstant(Module *M, Function *F, Constant *C,
42 IRBuilder<> &Builder);
43 Value *remapConstantVectorOrConstantAggregate(Module *M, Function *F,
44 Constant *C,
45 IRBuilder<> &Builder);
46 Value *remapConstantExpr(Module *M, Function *F, ConstantExpr *C,
47 IRBuilder<> &Builder);
48
49 typedef ValueMap<GlobalVariable *, GlobalVariable *> GVMapTy;
50 typedef ValueMap<Constant *, Value *> ConstantToValueMapTy;
51 GVMapTy GVMap;
52 ConstantToValueMapTy ConstantToValueMap;
53};
54} // end namespace
55
56bool GenericToNVVM::runOnModule(Module &M) {
57 // Create a clone of each global variable that has the default address space.
58 // The clone is created with the global address space specifier, and the pair
59 // of original global variable and its clone is placed in the GVMap for later
60 // use.
61
62 for (GlobalVariable &GV : llvm::make_early_inc_range(Range: M.globals())) {
63 if (GV.getType()->getAddressSpace() == llvm::ADDRESS_SPACE_GENERIC &&
64 !llvm::isTexture(GV) && !llvm::isSurface(GV) && !llvm::isSampler(GV) &&
65 !GV.getName().starts_with(Prefix: "llvm.")) {
66 GlobalVariable *NewGV = new GlobalVariable(
67 M, GV.getValueType(), GV.isConstant(), GV.getLinkage(),
68 GV.hasInitializer() ? GV.getInitializer() : nullptr, "", &GV,
69 GV.getThreadLocalMode(), llvm::ADDRESS_SPACE_GLOBAL);
70 NewGV->copyAttributesFrom(Src: &GV);
71 NewGV->copyMetadata(Src: &GV, /*Offset=*/0);
72 GVMap[&GV] = NewGV;
73 }
74 }
75
76 // Return immediately, if every global variable has a specific address space
77 // specifier.
78 if (GVMap.empty()) {
79 return false;
80 }
81
82 // Walk through the instructions in function defitinions, and replace any use
83 // of original global variables in GVMap with a use of the corresponding
84 // copies in GVMap. If necessary, promote constants to instructions.
85 for (Function &F : M) {
86 if (F.isDeclaration()) {
87 continue;
88 }
89 IRBuilder<> Builder(F.getEntryBlock().getFirstNonPHIOrDbg());
90 for (BasicBlock &BB : F) {
91 for (Instruction &II : BB) {
92 for (unsigned i = 0, e = II.getNumOperands(); i < e; ++i) {
93 Value *Operand = II.getOperand(i);
94 if (isa<Constant>(Val: Operand)) {
95 II.setOperand(
96 i, Val: remapConstant(M: &M, F: &F, C: cast<Constant>(Val: Operand), Builder));
97 }
98 }
99 }
100 }
101 ConstantToValueMap.clear();
102 }
103
104 // Copy GVMap over to a standard value map.
105 ValueToValueMapTy VM;
106 for (auto I = GVMap.begin(), E = GVMap.end(); I != E; ++I)
107 VM[I->first] = I->second;
108
109 // Walk through the global variable initializers, and replace any use of
110 // original global variables in GVMap with a use of the corresponding copies
111 // in GVMap. The copies need to be bitcast to the original global variable
112 // types, as we cannot use cvta in global variable initializers.
113 for (GVMapTy::iterator I = GVMap.begin(), E = GVMap.end(); I != E;) {
114 GlobalVariable *GV = I->first;
115 GlobalVariable *NewGV = I->second;
116
117 // Remove GV from the map so that it can be RAUWed. Note that
118 // DenseMap::erase() won't invalidate any iterators but this one.
119 auto Next = std::next(x: I);
120 GVMap.erase(I);
121 I = Next;
122
123 Constant *BitCastNewGV = ConstantExpr::getPointerCast(C: NewGV, Ty: GV->getType());
124 // At this point, the remaining uses of GV should be found only in global
125 // variable initializers, as other uses have been already been removed
126 // while walking through the instructions in function definitions.
127 GV->replaceAllUsesWith(V: BitCastNewGV);
128 std::string Name = std::string(GV->getName());
129 GV->eraseFromParent();
130 NewGV->setName(Name);
131 }
132 assert(GVMap.empty() && "Expected it to be empty by now");
133
134 return true;
135}
136
137Value *GenericToNVVM::remapConstant(Module *M, Function *F, Constant *C,
138 IRBuilder<> &Builder) {
139 // If the constant C has been converted already in the given function F, just
140 // return the converted value.
141 ConstantToValueMapTy::iterator CTII = ConstantToValueMap.find(Val: C);
142 if (CTII != ConstantToValueMap.end()) {
143 return CTII->second;
144 }
145
146 Value *NewValue = C;
147 if (isa<GlobalVariable>(Val: C)) {
148 // If the constant C is a global variable and is found in GVMap, substitute
149 //
150 // addrspacecast GVMap[C] to addrspace(0)
151 //
152 // for our use of C.
153 GVMapTy::iterator I = GVMap.find(Val: cast<GlobalVariable>(Val: C));
154 if (I != GVMap.end()) {
155 GlobalVariable *GV = I->second;
156 NewValue = Builder.CreateAddrSpaceCast(
157 V: GV,
158 DestTy: PointerType::get(ElementType: GV->getValueType(), AddressSpace: llvm::ADDRESS_SPACE_GENERIC));
159 }
160 } else if (isa<ConstantAggregate>(Val: C)) {
161 // If any element in the constant vector or aggregate C is or uses a global
162 // variable in GVMap, the constant C needs to be reconstructed, using a set
163 // of instructions.
164 NewValue = remapConstantVectorOrConstantAggregate(M, F, C, Builder);
165 } else if (isa<ConstantExpr>(Val: C)) {
166 // If any operand in the constant expression C is or uses a global variable
167 // in GVMap, the constant expression C needs to be reconstructed, using a
168 // set of instructions.
169 NewValue = remapConstantExpr(M, F, C: cast<ConstantExpr>(Val: C), Builder);
170 }
171
172 ConstantToValueMap[C] = NewValue;
173 return NewValue;
174}
175
176Value *GenericToNVVM::remapConstantVectorOrConstantAggregate(
177 Module *M, Function *F, Constant *C, IRBuilder<> &Builder) {
178 bool OperandChanged = false;
179 SmallVector<Value *, 4> NewOperands;
180 unsigned NumOperands = C->getNumOperands();
181
182 // Check if any element is or uses a global variable in GVMap, and thus
183 // converted to another value.
184 for (unsigned i = 0; i < NumOperands; ++i) {
185 Value *Operand = C->getOperand(i);
186 Value *NewOperand = remapConstant(M, F, C: cast<Constant>(Val: Operand), Builder);
187 OperandChanged |= Operand != NewOperand;
188 NewOperands.push_back(Elt: NewOperand);
189 }
190
191 // If none of the elements has been modified, return C as it is.
192 if (!OperandChanged) {
193 return C;
194 }
195
196 // If any of the elements has been modified, construct the equivalent
197 // vector or aggregate value with a set instructions and the converted
198 // elements.
199 Value *NewValue = PoisonValue::get(T: C->getType());
200 if (isa<ConstantVector>(Val: C)) {
201 for (unsigned i = 0; i < NumOperands; ++i) {
202 Value *Idx = ConstantInt::get(Ty: Type::getInt32Ty(C&: M->getContext()), V: i);
203 NewValue = Builder.CreateInsertElement(Vec: NewValue, NewElt: NewOperands[i], Idx);
204 }
205 } else {
206 for (unsigned i = 0; i < NumOperands; ++i) {
207 NewValue =
208 Builder.CreateInsertValue(Agg: NewValue, Val: NewOperands[i], Idxs: ArrayRef(i));
209 }
210 }
211
212 return NewValue;
213}
214
215Value *GenericToNVVM::remapConstantExpr(Module *M, Function *F, ConstantExpr *C,
216 IRBuilder<> &Builder) {
217 bool OperandChanged = false;
218 SmallVector<Value *, 4> NewOperands;
219 unsigned NumOperands = C->getNumOperands();
220
221 // Check if any operand is or uses a global variable in GVMap, and thus
222 // converted to another value.
223 for (unsigned i = 0; i < NumOperands; ++i) {
224 Value *Operand = C->getOperand(i_nocapture: i);
225 Value *NewOperand = remapConstant(M, F, C: cast<Constant>(Val: Operand), Builder);
226 OperandChanged |= Operand != NewOperand;
227 NewOperands.push_back(Elt: NewOperand);
228 }
229
230 // If none of the operands has been modified, return C as it is.
231 if (!OperandChanged) {
232 return C;
233 }
234
235 // If any of the operands has been modified, construct the instruction with
236 // the converted operands.
237 unsigned Opcode = C->getOpcode();
238 switch (Opcode) {
239 case Instruction::ICmp:
240 // CompareConstantExpr (icmp)
241 return Builder.CreateICmp(P: CmpInst::Predicate(C->getPredicate()),
242 LHS: NewOperands[0], RHS: NewOperands[1]);
243 case Instruction::FCmp:
244 // CompareConstantExpr (fcmp)
245 llvm_unreachable("Address space conversion should have no effect "
246 "on float point CompareConstantExpr (fcmp)!");
247 case Instruction::ExtractElement:
248 // ExtractElementConstantExpr
249 return Builder.CreateExtractElement(Vec: NewOperands[0], Idx: NewOperands[1]);
250 case Instruction::InsertElement:
251 // InsertElementConstantExpr
252 return Builder.CreateInsertElement(Vec: NewOperands[0], NewElt: NewOperands[1],
253 Idx: NewOperands[2]);
254 case Instruction::ShuffleVector:
255 // ShuffleVector
256 return Builder.CreateShuffleVector(V1: NewOperands[0], V2: NewOperands[1],
257 Mask: NewOperands[2]);
258 case Instruction::GetElementPtr:
259 // GetElementPtrConstantExpr
260 return Builder.CreateGEP(Ty: cast<GEPOperator>(Val: C)->getSourceElementType(),
261 Ptr: NewOperands[0],
262 IdxList: ArrayRef(&NewOperands[1], NumOperands - 1), Name: "",
263 IsInBounds: cast<GEPOperator>(Val: C)->isInBounds());
264 case Instruction::Select:
265 // SelectConstantExpr
266 return Builder.CreateSelect(C: NewOperands[0], True: NewOperands[1], False: NewOperands[2]);
267 default:
268 // BinaryConstantExpr
269 if (Instruction::isBinaryOp(Opcode)) {
270 return Builder.CreateBinOp(Opc: Instruction::BinaryOps(C->getOpcode()),
271 LHS: NewOperands[0], RHS: NewOperands[1]);
272 }
273 // UnaryConstantExpr
274 if (Instruction::isCast(Opcode)) {
275 return Builder.CreateCast(Op: Instruction::CastOps(C->getOpcode()),
276 V: NewOperands[0], DestTy: C->getType());
277 }
278 llvm_unreachable("GenericToNVVM encountered an unsupported ConstantExpr");
279 }
280}
281
282namespace {
283class GenericToNVVMLegacyPass : public ModulePass {
284public:
285 static char ID;
286
287 GenericToNVVMLegacyPass() : ModulePass(ID) {}
288
289 bool runOnModule(Module &M) override;
290};
291} // namespace
292
293char GenericToNVVMLegacyPass::ID = 0;
294
295ModulePass *llvm::createGenericToNVVMLegacyPass() {
296 return new GenericToNVVMLegacyPass();
297}
298
299INITIALIZE_PASS(
300 GenericToNVVMLegacyPass, "generic-to-nvvm",
301 "Ensure that the global variables are in the global address space", false,
302 false)
303
304bool GenericToNVVMLegacyPass::runOnModule(Module &M) {
305 return GenericToNVVM().runOnModule(M);
306}
307
308PreservedAnalyses GenericToNVVMPass::run(Module &M, ModuleAnalysisManager &AM) {
309 return GenericToNVVM().runOnModule(M) ? PreservedAnalyses::none()
310 : PreservedAnalyses::all();
311}
312

source code of llvm/lib/Target/NVPTX/NVPTXGenericToNVVM.cpp