1 //===-- GenericToNVVM.cpp - Convert generic module to NVVM module - C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // Convert generic global variables into either .global or .const access based 11 // on the variable's "constant" qualifier. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "NVPTX.h" 16 #include "MCTargetDesc/NVPTXBaseInfo.h" 17 #include "NVPTXUtilities.h" 18 #include "llvm/CodeGen/MachineFunctionAnalysis.h" 19 #include "llvm/CodeGen/ValueTypes.h" 20 #include "llvm/IR/Constants.h" 21 #include "llvm/IR/DerivedTypes.h" 22 #include "llvm/IR/IRBuilder.h" 23 #include "llvm/IR/Instructions.h" 24 #include "llvm/IR/Intrinsics.h" 25 #include "llvm/IR/LegacyPassManager.h" 26 #include "llvm/IR/Module.h" 27 #include "llvm/IR/Operator.h" 28 #include "llvm/IR/ValueMap.h" 29 #include "llvm/Transforms/Utils/ValueMapper.h" 30 31 using namespace llvm; 32 33 namespace llvm { 34 void initializeGenericToNVVMPass(PassRegistry &); 35 } 36 37 namespace { 38 class GenericToNVVM : public ModulePass { 39 public: 40 static char ID; 41 42 GenericToNVVM() : ModulePass(ID) {} 43 44 bool runOnModule(Module &M) override; 45 46 void getAnalysisUsage(AnalysisUsage &AU) const override {} 47 48 private: 49 Value *getOrInsertCVTA(Module *M, Function *F, GlobalVariable *GV, 50 IRBuilder<> &Builder); 51 Value *remapConstant(Module *M, Function *F, Constant *C, 52 IRBuilder<> &Builder); 53 Value *remapConstantVectorOrConstantAggregate(Module *M, Function *F, 54 Constant *C, 55 IRBuilder<> &Builder); 56 Value *remapConstantExpr(Module *M, Function *F, ConstantExpr *C, 57 IRBuilder<> &Builder); 58 void remapNamedMDNode(ValueToValueMapTy &VM, NamedMDNode *N); 59 60 typedef ValueMap<GlobalVariable *, GlobalVariable *> GVMapTy; 61 typedef ValueMap<Constant *, Value *> ConstantToValueMapTy; 62 GVMapTy GVMap; 63 ConstantToValueMapTy ConstantToValueMap; 64 }; 65 } // end namespace 66 67 char GenericToNVVM::ID = 0; 68 69 ModulePass *llvm::createGenericToNVVMPass() { return new GenericToNVVM(); } 70 71 INITIALIZE_PASS( 72 GenericToNVVM, "generic-to-nvvm", 73 "Ensure that the global variables are in the global address space", false, 74 false) 75 76 bool GenericToNVVM::runOnModule(Module &M) { 77 // Create a clone of each global variable that has the default address space. 78 // The clone is created with the global address space specifier, and the pair 79 // of original global variable and its clone is placed in the GVMap for later 80 // use. 81 82 for (Module::global_iterator I = M.global_begin(), E = M.global_end(); 83 I != E;) { 84 GlobalVariable *GV = &*I++; 85 if (GV->getType()->getAddressSpace() == llvm::ADDRESS_SPACE_GENERIC && 86 !llvm::isTexture(*GV) && !llvm::isSurface(*GV) && 87 !llvm::isSampler(*GV) && !GV->getName().startswith("llvm.")) { 88 GlobalVariable *NewGV = new GlobalVariable( 89 M, GV->getType()->getElementType(), GV->isConstant(), 90 GV->getLinkage(), 91 GV->hasInitializer() ? GV->getInitializer() : nullptr, 92 "", GV, GV->getThreadLocalMode(), llvm::ADDRESS_SPACE_GLOBAL); 93 NewGV->copyAttributesFrom(GV); 94 GVMap[GV] = NewGV; 95 } 96 } 97 98 // Return immediately, if every global variable has a specific address space 99 // specifier. 100 if (GVMap.empty()) { 101 return false; 102 } 103 104 // Walk through the instructions in function defitinions, and replace any use 105 // of original global variables in GVMap with a use of the corresponding 106 // copies in GVMap. If necessary, promote constants to instructions. 107 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) { 108 if (I->isDeclaration()) { 109 continue; 110 } 111 IRBuilder<> Builder(I->getEntryBlock().getFirstNonPHIOrDbg()); 112 for (Function::iterator BBI = I->begin(), BBE = I->end(); BBI != BBE; 113 ++BBI) { 114 for (BasicBlock::iterator II = BBI->begin(), IE = BBI->end(); II != IE; 115 ++II) { 116 for (unsigned i = 0, e = II->getNumOperands(); i < e; ++i) { 117 Value *Operand = II->getOperand(i); 118 if (isa<Constant>(Operand)) { 119 II->setOperand( 120 i, remapConstant(&M, &*I, cast<Constant>(Operand), Builder)); 121 } 122 } 123 } 124 } 125 ConstantToValueMap.clear(); 126 } 127 128 // Copy GVMap over to a standard value map. 129 ValueToValueMapTy VM; 130 for (auto I = GVMap.begin(), E = GVMap.end(); I != E; ++I) 131 VM[I->first] = I->second; 132 133 // Walk through the metadata section and update the debug information 134 // associated with the global variables in the default address space. 135 for (NamedMDNode &I : M.named_metadata()) { 136 remapNamedMDNode(VM, &I); 137 } 138 139 // Walk through the global variable initializers, and replace any use of 140 // original global variables in GVMap with a use of the corresponding copies 141 // in GVMap. The copies need to be bitcast to the original global variable 142 // types, as we cannot use cvta in global variable initializers. 143 for (GVMapTy::iterator I = GVMap.begin(), E = GVMap.end(); I != E;) { 144 GlobalVariable *GV = I->first; 145 GlobalVariable *NewGV = I->second; 146 147 // Remove GV from the map so that it can be RAUWed. Note that 148 // DenseMap::erase() won't invalidate any iterators but this one. 149 auto Next = std::next(I); 150 GVMap.erase(I); 151 I = Next; 152 153 Constant *BitCastNewGV = ConstantExpr::getPointerCast(NewGV, GV->getType()); 154 // At this point, the remaining uses of GV should be found only in global 155 // variable initializers, as other uses have been already been removed 156 // while walking through the instructions in function definitions. 157 GV->replaceAllUsesWith(BitCastNewGV); 158 std::string Name = GV->getName(); 159 GV->eraseFromParent(); 160 NewGV->setName(Name); 161 } 162 assert(GVMap.empty() && "Expected it to be empty by now"); 163 164 return true; 165 } 166 167 Value *GenericToNVVM::getOrInsertCVTA(Module *M, Function *F, 168 GlobalVariable *GV, 169 IRBuilder<> &Builder) { 170 PointerType *GVType = GV->getType(); 171 Value *CVTA = nullptr; 172 173 // See if the address space conversion requires the operand to be bitcast 174 // to i8 addrspace(n)* first. 175 EVT ExtendedGVType = EVT::getEVT(GVType->getElementType(), true); 176 if (!ExtendedGVType.isInteger() && !ExtendedGVType.isFloatingPoint()) { 177 // A bitcast to i8 addrspace(n)* on the operand is needed. 178 LLVMContext &Context = M->getContext(); 179 unsigned int AddrSpace = GVType->getAddressSpace(); 180 Type *DestTy = PointerType::get(Type::getInt8Ty(Context), AddrSpace); 181 CVTA = Builder.CreateBitCast(GV, DestTy, "cvta"); 182 // Insert the address space conversion. 183 Type *ResultType = 184 PointerType::get(Type::getInt8Ty(Context), llvm::ADDRESS_SPACE_GENERIC); 185 SmallVector<Type *, 2> ParamTypes; 186 ParamTypes.push_back(ResultType); 187 ParamTypes.push_back(DestTy); 188 Function *CVTAFunction = Intrinsic::getDeclaration( 189 M, Intrinsic::nvvm_ptr_global_to_gen, ParamTypes); 190 CVTA = Builder.CreateCall(CVTAFunction, CVTA, "cvta"); 191 // Another bitcast from i8 * to <the element type of GVType> * is 192 // required. 193 DestTy = 194 PointerType::get(GVType->getElementType(), llvm::ADDRESS_SPACE_GENERIC); 195 CVTA = Builder.CreateBitCast(CVTA, DestTy, "cvta"); 196 } else { 197 // A simple CVTA is enough. 198 SmallVector<Type *, 2> ParamTypes; 199 ParamTypes.push_back(PointerType::get(GVType->getElementType(), 200 llvm::ADDRESS_SPACE_GENERIC)); 201 ParamTypes.push_back(GVType); 202 Function *CVTAFunction = Intrinsic::getDeclaration( 203 M, Intrinsic::nvvm_ptr_global_to_gen, ParamTypes); 204 CVTA = Builder.CreateCall(CVTAFunction, GV, "cvta"); 205 } 206 207 return CVTA; 208 } 209 210 Value *GenericToNVVM::remapConstant(Module *M, Function *F, Constant *C, 211 IRBuilder<> &Builder) { 212 // If the constant C has been converted already in the given function F, just 213 // return the converted value. 214 ConstantToValueMapTy::iterator CTII = ConstantToValueMap.find(C); 215 if (CTII != ConstantToValueMap.end()) { 216 return CTII->second; 217 } 218 219 Value *NewValue = C; 220 if (isa<GlobalVariable>(C)) { 221 // If the constant C is a global variable and is found in GVMap, generate a 222 // set set of instructions that convert the clone of C with the global 223 // address space specifier to a generic pointer. 224 // The constant C cannot be used here, as it will be erased from the 225 // module eventually. And the clone of C with the global address space 226 // specifier cannot be used here either, as it will affect the types of 227 // other instructions in the function. Hence, this address space conversion 228 // is required. 229 GVMapTy::iterator I = GVMap.find(cast<GlobalVariable>(C)); 230 if (I != GVMap.end()) { 231 NewValue = getOrInsertCVTA(M, F, I->second, Builder); 232 } 233 } else if (isa<ConstantVector>(C) || isa<ConstantArray>(C) || 234 isa<ConstantStruct>(C)) { 235 // If any element in the constant vector or aggregate C is or uses a global 236 // variable in GVMap, the constant C needs to be reconstructed, using a set 237 // of instructions. 238 NewValue = remapConstantVectorOrConstantAggregate(M, F, C, Builder); 239 } else if (isa<ConstantExpr>(C)) { 240 // If any operand in the constant expression C is or uses a global variable 241 // in GVMap, the constant expression C needs to be reconstructed, using a 242 // set of instructions. 243 NewValue = remapConstantExpr(M, F, cast<ConstantExpr>(C), Builder); 244 } 245 246 ConstantToValueMap[C] = NewValue; 247 return NewValue; 248 } 249 250 Value *GenericToNVVM::remapConstantVectorOrConstantAggregate( 251 Module *M, Function *F, Constant *C, IRBuilder<> &Builder) { 252 bool OperandChanged = false; 253 SmallVector<Value *, 4> NewOperands; 254 unsigned NumOperands = C->getNumOperands(); 255 256 // Check if any element is or uses a global variable in GVMap, and thus 257 // converted to another value. 258 for (unsigned i = 0; i < NumOperands; ++i) { 259 Value *Operand = C->getOperand(i); 260 Value *NewOperand = remapConstant(M, F, cast<Constant>(Operand), Builder); 261 OperandChanged |= Operand != NewOperand; 262 NewOperands.push_back(NewOperand); 263 } 264 265 // If none of the elements has been modified, return C as it is. 266 if (!OperandChanged) { 267 return C; 268 } 269 270 // If any of the elements has been modified, construct the equivalent 271 // vector or aggregate value with a set instructions and the converted 272 // elements. 273 Value *NewValue = UndefValue::get(C->getType()); 274 if (isa<ConstantVector>(C)) { 275 for (unsigned i = 0; i < NumOperands; ++i) { 276 Value *Idx = ConstantInt::get(Type::getInt32Ty(M->getContext()), i); 277 NewValue = Builder.CreateInsertElement(NewValue, NewOperands[i], Idx); 278 } 279 } else { 280 for (unsigned i = 0; i < NumOperands; ++i) { 281 NewValue = 282 Builder.CreateInsertValue(NewValue, NewOperands[i], makeArrayRef(i)); 283 } 284 } 285 286 return NewValue; 287 } 288 289 Value *GenericToNVVM::remapConstantExpr(Module *M, Function *F, ConstantExpr *C, 290 IRBuilder<> &Builder) { 291 bool OperandChanged = false; 292 SmallVector<Value *, 4> NewOperands; 293 unsigned NumOperands = C->getNumOperands(); 294 295 // Check if any operand is or uses a global variable in GVMap, and thus 296 // converted to another value. 297 for (unsigned i = 0; i < NumOperands; ++i) { 298 Value *Operand = C->getOperand(i); 299 Value *NewOperand = remapConstant(M, F, cast<Constant>(Operand), Builder); 300 OperandChanged |= Operand != NewOperand; 301 NewOperands.push_back(NewOperand); 302 } 303 304 // If none of the operands has been modified, return C as it is. 305 if (!OperandChanged) { 306 return C; 307 } 308 309 // If any of the operands has been modified, construct the instruction with 310 // the converted operands. 311 unsigned Opcode = C->getOpcode(); 312 switch (Opcode) { 313 case Instruction::ICmp: 314 // CompareConstantExpr (icmp) 315 return Builder.CreateICmp(CmpInst::Predicate(C->getPredicate()), 316 NewOperands[0], NewOperands[1]); 317 case Instruction::FCmp: 318 // CompareConstantExpr (fcmp) 319 llvm_unreachable("Address space conversion should have no effect " 320 "on float point CompareConstantExpr (fcmp)!"); 321 case Instruction::ExtractElement: 322 // ExtractElementConstantExpr 323 return Builder.CreateExtractElement(NewOperands[0], NewOperands[1]); 324 case Instruction::InsertElement: 325 // InsertElementConstantExpr 326 return Builder.CreateInsertElement(NewOperands[0], NewOperands[1], 327 NewOperands[2]); 328 case Instruction::ShuffleVector: 329 // ShuffleVector 330 return Builder.CreateShuffleVector(NewOperands[0], NewOperands[1], 331 NewOperands[2]); 332 case Instruction::ExtractValue: 333 // ExtractValueConstantExpr 334 return Builder.CreateExtractValue(NewOperands[0], C->getIndices()); 335 case Instruction::InsertValue: 336 // InsertValueConstantExpr 337 return Builder.CreateInsertValue(NewOperands[0], NewOperands[1], 338 C->getIndices()); 339 case Instruction::GetElementPtr: 340 // GetElementPtrConstantExpr 341 return cast<GEPOperator>(C)->isInBounds() 342 ? Builder.CreateGEP( 343 cast<GEPOperator>(C)->getSourceElementType(), 344 NewOperands[0], 345 makeArrayRef(&NewOperands[1], NumOperands - 1)) 346 : Builder.CreateInBoundsGEP( 347 cast<GEPOperator>(C)->getSourceElementType(), 348 NewOperands[0], 349 makeArrayRef(&NewOperands[1], NumOperands - 1)); 350 case Instruction::Select: 351 // SelectConstantExpr 352 return Builder.CreateSelect(NewOperands[0], NewOperands[1], NewOperands[2]); 353 default: 354 // BinaryConstantExpr 355 if (Instruction::isBinaryOp(Opcode)) { 356 return Builder.CreateBinOp(Instruction::BinaryOps(C->getOpcode()), 357 NewOperands[0], NewOperands[1]); 358 } 359 // UnaryConstantExpr 360 if (Instruction::isCast(Opcode)) { 361 return Builder.CreateCast(Instruction::CastOps(C->getOpcode()), 362 NewOperands[0], C->getType()); 363 } 364 llvm_unreachable("GenericToNVVM encountered an unsupported ConstantExpr"); 365 } 366 } 367 368 void GenericToNVVM::remapNamedMDNode(ValueToValueMapTy &VM, NamedMDNode *N) { 369 370 bool OperandChanged = false; 371 SmallVector<MDNode *, 16> NewOperands; 372 unsigned NumOperands = N->getNumOperands(); 373 374 // Check if any operand is or contains a global variable in GVMap, and thus 375 // converted to another value. 376 for (unsigned i = 0; i < NumOperands; ++i) { 377 MDNode *Operand = N->getOperand(i); 378 MDNode *NewOperand = MapMetadata(Operand, VM); 379 OperandChanged |= Operand != NewOperand; 380 NewOperands.push_back(NewOperand); 381 } 382 383 // If none of the operands has been modified, return immediately. 384 if (!OperandChanged) { 385 return; 386 } 387 388 // Replace the old operands with the new operands. 389 N->dropAllReferences(); 390 for (SmallVectorImpl<MDNode *>::iterator I = NewOperands.begin(), 391 E = NewOperands.end(); 392 I != E; ++I) { 393 N->addOperand(*I); 394 } 395 } 396