[NFCI] Use TypedPointerType in more places. (#1683)

One of the reasons behind this change is to make code more easily deal with the
future prospect of opaque types, so that helper methods (like adjusting image
types) can handle both pointer type and opaque type representations simply by
querying if the input type is a TypedPointerType or an OpaqueType [name for the
latter still pending].

The set of changes are:
* OCLTypeToSPIRV now uses TypedPointerType internally
* adaptSPIRVImageType and getSPIRVStructTypeByChangeBaseTypeName are collapsed
  into one method (adjustImageType) that works with TypedPointerTypes.
* A few is*StructType methods have been reverted back to is*Type methods, taking
  a TypedPointerType parameter instead.
* BuiltinCallHelper::addSPIRVCall{Pair} allows for the creation of SPIR-V calls
  that can use TypedPointerType or actual type for parameters and return value.
* BuiltinCallHelper::getCallValue{Type} is a simple helper that hides many of
  the uses of getParameterTypes.
* The Type* parameter of the callback in BuiltinCallMutator::mapArg now provides
  a TypedPointerType or the actual type, instead of the pointer element type.
* BuiltinCallMutator::ValueTypePair similarly takes a TypedPointerType or the
  actual type.
* getParameterTypes (when passed a SmallVector<Type *>) does a similar thing.
  (The SmallVector<TypedPointerType *> variant has been removed in favor of only
  using the other one.)

Note that the last few changes do change the semantics of function parameters
without changing the function name or signature.

Co-authored-by: Dmitry Sidorov <[email protected]>

Author: jcranmer-intel

lib/SPIRV/OCLToSPIRV.cpp

@@ -944,27 +944,24 @@ void OCLToSPIRVBase::visitCallReadImageWithSampler(CallInst *CI,
   assert(CI->getCalledFunction() && "Unexpected indirect call");
   Function *Func = CI->getCalledFunction();
   bool IsRetScalar = !CI->getType()->isVectorTy();
-  SmallVector<Type *, 3> ArgStructTys;
-  getParameterTypes(CI, ArgStructTys);
   Type *Ret = CI->getType();
-  auto *ImageTy = OCLTypeToSPIRVPtr->getAdaptedArgumentType(Func, 0).second;
+  auto *ImageTy = OCLTypeToSPIRVPtr->getAdaptedArgumentType(Func, 0);
   if (!ImageTy)
-    ImageTy = ArgStructTys[0];
-  ImageTy = adaptSPIRVImageType(M, ImageTy);
-  auto *SampledImgStructTy = getSPIRVStructTypeByChangeBaseTypeName(
-      M, ImageTy, kSPIRVTypeName::Image, kSPIRVTypeName::SampledImg);
-  auto *SampledImgTy = PointerType::get(SampledImgStructTy, SPIRAS_Global);
-  Value *SampledImgArgs[] = {CI->getArgOperand(0), CI->getArgOperand(1)};
-  auto *SampledImg = addCallInstSPIRV(M, getSPIRVFuncName(OpSampledImage),
-                                      SampledImgTy, SampledImgArgs, nullptr,
-                                      {ArgStructTys[0], ArgStructTys[1]}, CI,
-                                      kSPIRVName::TempSampledImage);
+    ImageTy = getCallValueType(CI, 0);
 
   auto Mutator = mutateCallInst(
       CI, getSPIRVFuncName(OpImageSampleExplicitLod,
                            std::string(kSPIRVPostfix::ExtDivider) +
                                getPostfixForReturnType(Ret)));
-  Mutator.replaceArg(0, {SampledImg, SampledImgStructTy}).removeArg(1);
+  Mutator.mapArg(0, [&](IRBuilder<> &Builder, Value *ImgArg, Type *ImgType) {
+    auto *SampledImgTy = adjustImageType(ImageTy, kSPIRVTypeName::Image,
+                                         kSPIRVTypeName::SampledImg);
+    Value *SampledImgArgs[] = {CI->getArgOperand(0), CI->getArgOperand(1)};
+    return addSPIRVCallPair(Builder, OpSampledImage, SampledImgTy,
+                            SampledImgArgs, {ImgType, Mutator.getType(1)},
+                            kSPIRVName::TempSampledImage);
+  });
+  Mutator.removeArg(1);
   unsigned ImgOpMask = getImageSignZeroExt(DemangledName);
   unsigned ImgOpMaskInsIndex = Mutator.arg_size();
   switch (Mutator.arg_size()) {
@@ -997,15 +994,7 @@ void OCLToSPIRVBase::visitCallReadImageWithSampler(CallInst *CI,
 
 void OCLToSPIRVBase::visitCallGetImageSize(CallInst *CI,
                                            StringRef DemangledName) {
-  StringRef TyName;
-  SmallVector<StringRef, 4> SubStrs;
-  SmallVector<Type *, 4> ParamTys;
-  getParameterTypes(CI, ParamTys);
-  auto IsImg = isOCLImageStructType(ParamTys[0], &TyName);
-  (void)IsImg;
-  assert(IsImg);
-  std::string ImageTyName = getImageBaseTypeName(TyName);
-  auto Desc = map<SPIRVTypeImageDescriptor>(ImageTyName);
+  auto Desc = getImageDescriptor(getCallValueType(CI, 0));
   unsigned Dim = getImageDimension(Desc.Dim) + Desc.Arrayed;
   assert(Dim > 0 && "Invalid image dimension.");
   assert(CI->arg_size() == 1);
@@ -1131,8 +1120,10 @@ void OCLToSPIRVBase::visitCallToAddr(CallInst *CI, StringRef DemangledName) {
     Mutator
         .mapArg(Mutator.arg_size() - 1,
                 [&](Value *V) {
-                  return std::pair<Value *, Type *>(
-                      castToInt8Ptr(V, CI), Type::getInt8Ty(V->getContext()));
+                  return std::make_pair(
+                      castToInt8Ptr(V, CI),
+                      TypedPointerType::get(Type::getInt8Ty(V->getContext()),
+                                            SPIRAS_Generic));
                 })
         .appendArg(StorageClass);
   };
@@ -1497,9 +1488,7 @@ void OCLToSPIRVBase::processSubgroupBlockReadWriteINTEL(
 // reads and vector block reads.
 void OCLToSPIRVBase::visitSubgroupBlockReadINTEL(CallInst *CI) {
   OCLBuiltinTransInfo Info;
-  SmallVector<Type *, 2> ParamTys;
-  getParameterTypes(CI, ParamTys);
-  if (isOCLImageStructType(ParamTys[0]))
+  if (isOCLImageType(getCallValueType(CI, 0)))
     Info.UniqName = getSPIRVFuncName(spv::OpSubgroupImageBlockReadINTEL);
   else
     Info.UniqName = getSPIRVFuncName(spv::OpSubgroupBlockReadINTEL);
@@ -1512,9 +1501,7 @@ void OCLToSPIRVBase::visitSubgroupBlockReadINTEL(CallInst *CI) {
 // instructions.
 void OCLToSPIRVBase::visitSubgroupBlockWriteINTEL(CallInst *CI) {
   OCLBuiltinTransInfo Info;
-  SmallVector<Type *, 3> ParamTys;
-  getParameterTypes(CI, ParamTys);
-  if (isOCLImageStructType(ParamTys[0]))
+  if (isOCLImageType(getCallValueType(CI, 0)))
     Info.UniqName = getSPIRVFuncName(spv::OpSubgroupImageBlockWriteINTEL);
   else
     Info.UniqName = getSPIRVFuncName(spv::OpSubgroupBlockWriteINTEL);
@@ -1614,7 +1601,7 @@ void OCLToSPIRVBase::visitSubgroupAVCWrapperBuiltinCall(
   std::string MCETName =
       std::string(kOCLSubgroupsAVCIntel::TypePrefix) + "mce_" + TyKind + "_t";
   auto *MCESTy = getSubgroupAVCIntelMCEType(M, MCETName);
-  auto *MCETy = PointerType::get(MCESTy, SPIRAS_Private);
+  auto *MCETy = TypedPointerType::get(MCESTy, SPIRAS_Private);
   std::string ToMCEFName = Prefix + OpKind + "_convert_to_mce_" + TyKind;
   Op ToMCEOC = OpNop;
   OCLSPIRVSubgroupAVCIntelBuiltinMap::find(ToMCEFName, &ToMCEOC);
@@ -1631,28 +1618,24 @@ void OCLToSPIRVBase::visitSubgroupAVCWrapperBuiltinCall(
 
     mutateCallInst(CI, WrappedOC)
         .mapArg(CI->arg_size() - 1,
-                [&](Value *Arg, Type *ParamTy) {
+                [&](IRBuilder<> &Builder, Value *Arg, Type *ParamTy) {
                   // Create conversion function call for the last operand
-                  return std::pair<Value *, Type *>(
-                      addCallInstSPIRV(M, getSPIRVFuncName(ToMCEOC), MCETy, Arg,
-                                       nullptr, {ParamTy}, CI, ""),
-                      MCESTy);
+                  return addSPIRVCallPair(Builder, ToMCEOC, MCETy, {Arg},
+                                          {ParamTy});
                 })
-        .changeReturnType(MCETy, [=](IRBuilder<> &, CallInst *NewCI) {
+        .changeReturnType(MCETy, [&](IRBuilder<> &Builder, CallInst *NewCI) {
           // Create conversion function call for the return result
-          return addCallInstSPIRV(M, getSPIRVFuncName(FromMCEOC), CI->getType(),
-                                  NewCI, nullptr, {MCESTy}, CI, "");
+          return addSPIRVCall(Builder, FromMCEOC, CI->getType(), {NewCI},
+                              {MCETy});
         });
   } else {
     // Wrapper built-ins which take the 'result_t' argument requires only one
     // conversion for the argument
     mutateCallInst(CI, WrappedOC)
-        .mapArg(CI->arg_size() - 1, [&](Value *Arg, Type *ParamTy) {
+        .mapArg(CI->arg_size() - 1, [&](IRBuilder<> &Builder, Value *Arg,
+                                        Type *ParamTy) {
           // Create conversion function call for the last operand
-          return std::pair<Value *, Type *>(
-              addCallInstSPIRV(M, getSPIRVFuncName(ToMCEOC), MCETy, Arg,
-                               nullptr, {ParamTy}, CI, ""),
-              MCESTy);
+          return addSPIRVCallPair(Builder, ToMCEOC, MCETy, {Arg}, {ParamTy});
         });
   }
 }
@@ -1676,9 +1659,8 @@ void OCLToSPIRVBase::visitSubgroupAVCBuiltinCallWithSampler(
     return; // this is not a VME built-in
 
   SmallVector<Type *, 4> ParamTys;
-  getParameterTypes(CI, ParamTys);
-  auto *TyIt =
-      std::find_if(ParamTys.begin(), ParamTys.end(), isSamplerStructTy);
+  getParameterTypes(CI->getCalledFunction(), ParamTys);
+  auto *TyIt = std::find_if(ParamTys.begin(), ParamTys.end(), isSamplerTy);
   assert(TyIt != ParamTys.end() && "Invalid Subgroup AVC Intel built-in call");
   unsigned SamplerIndex = TyIt - ParamTys.begin();
   Value *SamplerVal = CI->getOperand(SamplerIndex);
@@ -1687,30 +1669,24 @@ void OCLToSPIRVBase::visitSubgroupAVCBuiltinCallWithSampler(
   SmallVector<Type *, 4> AdaptedTys;
   for (unsigned I = 0; I < CI->arg_size(); I++)
     AdaptedTys.push_back(
-        OCLTypeToSPIRVPtr->getAdaptedArgumentType(CI->getCalledFunction(), I)
-            .second);
+        OCLTypeToSPIRVPtr->getAdaptedArgumentType(CI->getCalledFunction(), I));
   auto *AdaptedIter = AdaptedTys.begin();
 
   mutateCallInst(CI, OC)
-      .mapArgs([&](Value *Arg, Type *PointerTy) {
-        if (!isOCLImageStructType(PointerTy))
-          return std::make_pair(Arg, PointerTy);
+      .mapArgs([&](IRBuilder<> &Builder, Value *Arg, Type *ArgTy) {
+        if (!isOCLImageType(ArgTy))
+          return BuiltinCallMutator::ValueTypePair(Arg, ArgTy);
 
         auto *ImageTy = *AdaptedIter++;
         if (!ImageTy)
-          ImageTy = PointerTy;
-        ImageTy = adaptSPIRVImageType(M, ImageTy);
-        auto *SampledImgStructTy = getSPIRVStructTypeByChangeBaseTypeName(
-            M, ImageTy, kSPIRVTypeName::Image, kSPIRVTypeName::VmeImageINTEL);
-        auto *SampledImgTy =
-            PointerType::get(SampledImgStructTy, SPIRAS_Global);
+          ImageTy = ArgTy;
+        auto *SampledImgTy = adjustImageType(ImageTy, kSPIRVTypeName::Image,
+                                             kSPIRVTypeName::VmeImageINTEL);
 
         Value *SampledImgArgs[] = {Arg, SamplerVal};
-        return std::pair<Value *, Type *>(
-            addCallInstSPIRV(M, getSPIRVFuncName(OpVmeImageINTEL), SampledImgTy,
-                             SampledImgArgs, nullptr, {PointerTy, SamplerTy},
-                             CI, kSPIRVName::TempSampledImage),
-            SampledImgStructTy);
+        return addSPIRVCallPair(Builder, OpVmeImageINTEL, SampledImgTy,
+                                SampledImgArgs, {ArgTy, SamplerTy},
+                                kSPIRVName::TempSampledImage);
       })
       .removeArg(SamplerIndex);
 }

lib/SPIRV/OCLTypeToSPIRV.cpp

@@ -106,12 +106,11 @@ bool OCLTypeToSPIRVBase::runOCLTypeToSPIRV(Module &Module) {
   return false;
 }
 
-void OCLTypeToSPIRVBase::addAdaptedType(Value *V, Type *Ty,
-                                        unsigned AddrSpace) {
+void OCLTypeToSPIRVBase::addAdaptedType(Value *V, Type *Ty) {
   LLVM_DEBUG(dbgs() << "[add adapted type] ";
              V->printAsOperand(dbgs(), true, M);
              dbgs() << " => " << *Ty << '\n');
-  AdaptedTy[V] = {Ty, AddrSpace};
+  AdaptedTy[V] = Ty;
 }
 
 void OCLTypeToSPIRVBase::addWork(Function *F) {
@@ -133,17 +132,16 @@ void OCLTypeToSPIRVBase::adaptFunction(Function *F) {
     auto Loc = AdaptedTy.find(&I);
     auto Found = (Loc != AdaptedTy.end());
     Changed |= Found;
-    ArgTys.push_back(Found ? Loc->second.first : I.getType());
+    ArgTys.push_back(Found ? Loc->second : I.getType());
 
     if (Found) {
-      auto *Ty = Loc->second.first;
-      unsigned AddrSpace = Loc->second.second;
+      Type *Ty = Loc->second;
       for (auto &U : I.uses()) {
         if (auto *CI = dyn_cast<CallInst>(U.getUser())) {
           auto ArgIndex = CI->getArgOperandNo(&U);
           auto CF = CI->getCalledFunction();
           if (AdaptedTy.count(CF) == 0) {
-            addAdaptedType(CF->getArg(ArgIndex), Ty, AddrSpace);
+            addAdaptedType(CF->getArg(ArgIndex), Ty);
             addWork(CF);
           }
         }
@@ -156,7 +154,7 @@ void OCLTypeToSPIRVBase::adaptFunction(Function *F) {
 
   auto FT = F->getFunctionType();
   FT = FunctionType::get(FT->getReturnType(), ArgTys, FT->isVarArg());
-  addAdaptedType(F, FT, 0);
+  addAdaptedType(F, TypedPointerType::get(FT, 0));
 }
 
 // Handle functions with sampler arguments that don't get called by
@@ -181,7 +179,8 @@ void OCLTypeToSPIRVBase::adaptArgumentsBySamplerUse(Module &M) {
           AdaptedTy.count(SamplerArg) != 0) // Already traced this, move on.
         continue;
 
-      addAdaptedType(SamplerArg, getSamplerStructType(&M), SPIRAS_Constant);
+      addAdaptedType(SamplerArg, TypedPointerType::get(getSamplerStructType(&M),
+                                                       SPIRAS_Constant));
       auto Caller = cast<Argument>(SamplerArg)->getParent();
       addWork(Caller);
       TraceArg(Caller, cast<Argument>(SamplerArg)->getArgNo());
@@ -209,26 +208,27 @@ void OCLTypeToSPIRVBase::adaptFunctionArguments(Function *F) {
   bool Changed = false;
   auto Arg = F->arg_begin();
   SmallVector<Type *, 4> ParamTys;
-  getParameterTypes(F, ParamTys);
 
   // If we couldn't get any information from demangling, there is nothing that
   // can be done.
-  if (ParamTys.empty())
+  if (!getParameterTypes(F, ParamTys))
     return;
 
   for (unsigned I = 0; I < F->arg_size(); ++I, ++Arg) {
-    StructType *NewTy = dyn_cast_or_null<StructType>(ParamTys[I]);
+    StructType *NewTy = nullptr;
+    if (auto *TPT = dyn_cast<TypedPointerType>(ParamTys[I]))
+      NewTy = dyn_cast_or_null<StructType>(TPT->getElementType());
     if (NewTy && NewTy->isOpaque()) {
       auto STName = NewTy->getStructName();
       if (!hasAccessQualifiedName(STName))
         continue;
       if (STName.startswith(kSPR2TypeName::ImagePrefix)) {
         auto Ty = STName.str();
         auto AccStr = getAccessQualifierFullName(Ty);
-        addAdaptedType(
-            &*Arg,
-            getOrCreateOpaqueStructType(M, mapOCLTypeNameToSPIRV(Ty, AccStr)),
-            SPIRAS_Global);
+        addAdaptedType(&*Arg, TypedPointerType::get(
+                                  getOrCreateOpaqueStructType(
+                                      M, mapOCLTypeNameToSPIRV(Ty, AccStr)),
+                                  SPIRAS_Global));
         Changed = true;
       }
     }
@@ -249,18 +249,19 @@ void OCLTypeToSPIRVBase::adaptArgumentsByMetadata(Function *F) {
   for (unsigned I = 0, E = TypeMD->getNumOperands(); I != E; ++I, ++Arg) {
     auto OCLTyStr = getMDOperandAsString(TypeMD, I);
     if (OCLTyStr == OCL_TYPE_NAME_SAMPLER_T) {
-      addAdaptedType(&(*Arg), getSamplerStructType(M), SPIRAS_Constant);
+      addAdaptedType(&(*Arg), TypedPointerType::get(getSamplerStructType(M),
+                                                    SPIRAS_Constant));
       Changed = true;
     } else if (OCLTyStr.startswith("image") && OCLTyStr.endswith("_t")) {
       auto Ty = (Twine("opencl.") + OCLTyStr).str();
       if (StructType::getTypeByName(F->getContext(), Ty)) {
         auto AccMD = F->getMetadata(SPIR_MD_KERNEL_ARG_ACCESS_QUAL);
         assert(AccMD && "Invalid access qualifier metadata");
         auto AccStr = getMDOperandAsString(AccMD, I);
-        addAdaptedType(
-            &(*Arg),
-            getOrCreateOpaqueStructType(M, mapOCLTypeNameToSPIRV(Ty, AccStr)),
-            SPIRAS_Global);
+        addAdaptedType(&(*Arg), TypedPointerType::get(
+                                    getOrCreateOpaqueStructType(
+                                        M, mapOCLTypeNameToSPIRV(Ty, AccStr)),
+                                    SPIRAS_Global));
         Changed = true;
       }
     }
@@ -297,15 +298,12 @@ void OCLTypeToSPIRVBase::adaptArgumentsByMetadata(Function *F) {
 // opencl data type x and access qualifier y, and use opencl.image_x.y to
 // represent image_x type with access qualifier y.
 //
-std::pair<Type *, Type *>
-OCLTypeToSPIRVBase::getAdaptedArgumentType(Function *F, unsigned ArgNo) {
+Type *OCLTypeToSPIRVBase::getAdaptedArgumentType(Function *F, unsigned ArgNo) {
   Value *Arg = F->getArg(ArgNo);
   auto Loc = AdaptedTy.find(Arg);
   if (Loc == AdaptedTy.end())
-    return {nullptr, nullptr};
-  Type *PointeeTy = Loc->second.first;
-  Type *PointerTy = PointerType::get(PointeeTy, Loc->second.second);
-  return {PointerTy, PointeeTy};
+    return nullptr;
+  return Loc->second;
 }
 
 } // namespace SPIRV

lib/SPIRV/OCLTypeToSPIRV.h

@@ -59,25 +59,22 @@ class OCLTypeToSPIRVBase {
 
   bool runOCLTypeToSPIRV(llvm::Module &M);
 
-  /// Returns the adapted type of the corresponding argument for a function.
-  /// The first value of the returned pair is the LLVM type of the argument.
-  /// The second value of the returned pair is the pointer element type of the
-  /// argument, if the type is a pointer.
-  std::pair<llvm::Type *, llvm::Type *>
-  getAdaptedArgumentType(llvm::Function *F, unsigned ArgNo);
+  /// Returns the adapted type of the corresponding argument for a function. If
+  /// the type is a pointer type, it will return a TypedPointerType instead.
+  llvm::Type *getAdaptedArgumentType(llvm::Function *F, unsigned ArgNo);
 
 private:
   llvm::Module *M;
   llvm::LLVMContext *Ctx;
-  // Map of argument/Function -> {pointee type, address space}
-  std::map<llvm::Value *, std::pair<llvm::Type *, unsigned>> AdaptedTy;
+  // Map of argument/Function -> adapted type (probably TypedPointerType)
+  std::map<llvm::Value *, llvm::Type *> AdaptedTy;
   std::set<llvm::Function *> WorkSet; // Functions to be adapted
 
   void adaptFunctionArguments(llvm::Function *F);
   void adaptArgumentsByMetadata(llvm::Function *F);
   void adaptArgumentsBySamplerUse(llvm::Module &M);
   void adaptFunction(llvm::Function *F);
-  void addAdaptedType(llvm::Value *V, llvm::Type *PointeeTy, unsigned AS);
+  void addAdaptedType(llvm::Value *V, llvm::Type *Ty);
   void addWork(llvm::Function *F);
 };
 

lib/SPIRV/OCLUtil.cpp

@@ -1344,9 +1344,12 @@ Value *unwrapSpecialTypeInitializer(Value *V) {
   return nullptr;
 }
 
-bool isSamplerStructTy(Type *Ty) {
-  auto *STy = dyn_cast_or_null<StructType>(Ty);
-  return STy && STy->hasName() && STy->getName() == kSPR2TypeName::Sampler;
+bool isSamplerTy(Type *Ty) {
+  if (auto *TPT = dyn_cast_or_null<TypedPointerType>(Ty)) {
+    auto *STy = dyn_cast_or_null<StructType>(TPT->getElementType());
+    return STy && STy->hasName() && STy->getName() == kSPR2TypeName::Sampler;
+  }
+  return false;
 }
 
 bool isPipeOrAddressSpaceCastBI(const StringRef MangledName) {

lib/SPIRV/OCLUtil.h

@@ -499,7 +499,7 @@ bool isEnqueueKernelBI(const StringRef MangledName);
 bool isKernelQueryBI(const StringRef MangledName);
 
 /// Check that the type is the sampler_t
-bool isSamplerStructTy(Type *Ty);
+bool isSamplerTy(Type *Ty);
 
 // Checks if the binary operator is an unfused fmul + fadd instruction.
 bool isUnfusedMulAdd(BinaryOperator *B);