lib/Target/NVPTX/NVPTXGenericToNVVM.cpp

   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 }