[OpaquePointers][NFC] Replace use of isOpaquePointerTy with isPointerTy (#2091)

'bool llvm::Type::isOpaquePointerTy() const' has been removed.
We need to use isPointerTy() instead.

This PR handles all uses except one (lib/SPIRV/SPIRVWriter.cpp:279) which is handled in a different PR (#2089)

Thanks

Author: asudarsa

lib/SPIRV/OCLUtil.cpp

@@ -1329,32 +1329,6 @@ std::unique_ptr<SPIRV::BuiltinFuncMangleInfo> makeMangler(Function &F) {
   return std::make_unique<OCLBuiltinFuncMangleInfo>(&F);
 }
 
-static StringRef getStructName(Type *Ty) {
-  if (auto *STy = dyn_cast<StructType>(Ty))
-    return STy->isLiteral() ? "" : Ty->getStructName();
-  return "";
-}
-
-Value *unwrapSpecialTypeInitializer(Value *V) {
-  if (auto *BC = dyn_cast<BitCastOperator>(V)) {
-    Type *DestTy = BC->getDestTy();
-    Type *SrcTy = BC->getSrcTy();
-    if (SrcTy->isPointerTy() && !SrcTy->isOpaquePointerTy()) {
-      StringRef SrcName =
-          getStructName(SrcTy->getNonOpaquePointerElementType());
-      StringRef DestName =
-          getStructName(DestTy->getNonOpaquePointerElementType());
-      if (DestName == getSPIRVTypeName(kSPIRVTypeName::PipeStorage) &&
-          SrcName == getSPIRVTypeName(kSPIRVTypeName::ConstantPipeStorage))
-        return BC->getOperand(0);
-      if (DestName == getSPIRVTypeName(kSPIRVTypeName::Sampler) &&
-          SrcName == getSPIRVTypeName(kSPIRVTypeName::ConstantSampler))
-        return BC->getOperand(0);
-    }
-  }
-  return nullptr;
-}
-
 bool isSamplerTy(Type *Ty) {
   if (auto *TPT = dyn_cast_or_null<TypedPointerType>(Ty)) {
     auto *STy = dyn_cast_or_null<StructType>(TPT->getElementType());

lib/SPIRV/OCLUtil.h

@@ -489,11 +489,6 @@ inline OCLMemOrderKind mapSPIRVMemOrderToOCL(unsigned Sema) {
   return OCLMemOrderMap::rmap(extractSPIRVMemOrderSemantic(Sema));
 }
 
-/// If the value is a special type initializer (something that bitcasts from
-/// spirv.ConstantSampler to spirv.Sampler or likewise for PipeStorage), get the
-/// original type initializer, unwrap the bitcast. Otherwise, return nullptr.
-Value *unwrapSpecialTypeInitializer(Value *V);
-
 bool isPipeOrAddressSpaceCastBI(const StringRef MangledName);
 bool isEnqueueKernelBI(const StringRef MangledName);
 bool isKernelQueryBI(const StringRef MangledName);

lib/SPIRV/SPIRVLowerBitCastToNonStandardType.cpp

@@ -77,11 +77,6 @@ static Value *removeBitCasts(Value *OldValue, Type *NewTy, NFIRBuilder &Builder,
   if (auto *LI = dyn_cast<LoadInst>(OldValue)) {
     Builder.SetInsertPoint(LI);
     Value *Pointer = LI->getPointerOperand();
-    if (!Pointer->getType()->isOpaquePointerTy()) {
-      Type *NewPointerTy =
-          PointerType::get(NewTy, LI->getPointerAddressSpace());
-      Pointer = removeBitCasts(Pointer, NewPointerTy, Builder, InstsToErase);
-    }
     LoadInst *NewLI = Builder.CreateAlignedLoad(NewTy, Pointer, LI->getAlign(),
                                                 LI->isVolatile());
     NewLI->setOrdering(LI->getOrdering());

lib/SPIRV/SPIRVWriter.cpp

@@ -325,8 +325,7 @@ SPIRVType *LLVMToSPIRVBase::transType(Type *T) {
   // A pointer to image or pipe type in LLVM is translated to a SPIRV
   // (non-pointer) image or pipe type.
   if (T->isPointerTy()) {
-    auto *ET = T->isOpaquePointerTy() ? Type::getInt8Ty(T->getContext())
-                                      : T->getNonOpaquePointerElementType();
+    auto *ET = Type::getInt8Ty(T->getContext());
     auto AddrSpc = T->getPointerAddressSpace();
     return transPointerType(ET, AddrSpc);
   }
@@ -375,7 +374,7 @@ SPIRVType *LLVMToSPIRVBase::transType(Type *T) {
             ConstantInt::get(getSizetType(), T->getArrayNumElements(), false),
             nullptr)));
     mapType(T, TransType);
-    if (ElTy->isOpaquePointerTy()) {
+    if (ElTy->isPointerTy()) {
       mapType(
           ArrayType::get(TypedPointerType::get(Type::getInt8Ty(*Ctx),
                                                ElTy->getPointerAddressSpace()),
@@ -713,9 +712,7 @@ SPIRVType *LLVMToSPIRVBase::transSPIRVOpaqueType(StringRef STName,
 
 SPIRVType *LLVMToSPIRVBase::transScavengedType(Value *V) {
   if (auto *F = dyn_cast<Function>(V)) {
-    FunctionType *FnTy = F->getType()->isOpaquePointerTy()
-                             ? Scavenger->getFunctionType(F)
-                             : F->getFunctionType();
+    FunctionType *FnTy = Scavenger->getFunctionType(F);
     SPIRVType *RT = transType(FnTy->getReturnType());
     std::vector<SPIRVType *> PT;
     for (Argument &Arg : F->args()) {
@@ -1808,11 +1805,6 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
       assert(BV);
       return mapValue(V, BV);
     } else if (ConstantExpr *ConstUE = dyn_cast_or_null<ConstantExpr>(Init)) {
-      Value *SpecialInit = unwrapSpecialTypeInitializer(ConstUE);
-      if (auto *SpecialGV = dyn_cast_or_null<GlobalValue>(SpecialInit)) {
-        Init = SpecialGV;
-        Ty = Scavenger->getScavengedType(SpecialGV);
-      }
       BVarInit = transValue(Init, nullptr);
     } else if (ST && isa<UndefValue>(Init)) {
       // Undef initializer for LLVM structure be can translated to
@@ -1918,9 +1910,9 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
   if (isa<Constant>(V)) {
     auto BV = transConstant(V);
     assert(BV);
-    // Don't store opaque pointer constants in the map--we might reuse the wrong
-    // type for (e.g.) a null value if we do so.
-    if (V->getType()->isOpaquePointerTy())
+    // Don't store pointer constants in the map -- they are opaque and thus we
+    // might reuse the wrong type (Example: a null value) if we do so.
+    if (V->getType()->isPointerTy())
       return BV;
     return mapValue(V, BV);
   }
@@ -2166,8 +2158,6 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
   }
 
   if (UnaryInstruction *U = dyn_cast<UnaryInstruction>(V)) {
-    if (auto *Init = unwrapSpecialTypeInitializer(U))
-      return mapValue(V, transValue(Init, BB));
     auto UI = transUnaryInst(U, BB);
     return mapValue(V, UI ? UI : transValue(U->getOperand(0), BB));
   }
@@ -2779,12 +2769,6 @@ SPIRVValue *LLVMToSPIRVBase::oclTransSpvcCastSampler(CallInst *CI,
   auto FT = F->getFunctionType();
   auto RT = FT->getReturnType();
   assert(FT->getNumParams() == 1);
-  if (RT->isPointerTy() && !RT->isOpaquePointerTy()) {
-    StructType *ST = dyn_cast<StructType>(RT->getNonOpaquePointerElementType());
-    (void)ST;
-    assert(isSPIRVStructType(ST, kSPIRVTypeName::Sampler) ||
-           (ST->isOpaque() && ST->getName() == kSPR2TypeName::Sampler));
-  }
   assert(FT->getParamType(0)->isIntegerTy() && "Invalid sampler type");
   auto Arg = CI->getArgOperand(0);
 
@@ -2923,7 +2907,7 @@ void processOptionalAnnotationInfo(Constant *Const,
 void processAnnotationString(IntrinsicInst *II, std::string &AnnotationString) {
   auto *StrVal = II->getArgOperand(1);
   auto *StrValTy = StrVal->getType();
-  if (StrValTy->isOpaquePointerTy()) {
+  if (StrValTy->isPointerTy()) {
     StringRef StrRef;
     if (getConstantStringInfo(dyn_cast<Constant>(StrVal), StrRef))
       AnnotationString += StrRef.str();