Recover SPIR-V opaque types from demangling function names. (#1477)

The centerpiece of this patch is the addition of getParameterTypes function,
which will parse out the pointee struct types using LLVM's built-in Itanium
demangling interface (which is unfortunately not easy to use). Passing this
information along via llvm StructTypes was chosen to minimize the impact of
this change on caller code; it is likely that a future cleanup patch to use
an enum or similar mechanism to represent possible SPIR-V struct types would
be advisable.

A side effect of this change is that several helper methods that query
pointer element types can be eliminated, which does lead to some cleanup that
got tangled up in the demangler-enabling work.

Extra function calls to getPointerElementType() are temporarily added to
disentangle this patch from work moving OCLTypeToSPIRV to store pointee types
rather than pointer types; this will likely be fixed as part of the effort to
get SPIRVWriter working with opaque pointer types.

Author: jcranmer-intel

lib/SPIRV/OCLToSPIRV.cpp

@@ -1200,9 +1200,9 @@ void OCLToSPIRVBase::visitCallReadImageWithSampler(CallInst *CI,
   mutateCallInstSPIRV(
       M, CI,
       [=](CallInst *, std::vector<Value *> &Args, Type *&Ret) {
-        auto ImageTy = OCLTypeToSPIRVPtr->getAdaptedType(Args[0]);
-        if (isOCLImageType(ImageTy))
-          ImageTy = getSPIRVImageTypeFromOCL(M, ImageTy);
+        auto *ImageTy =
+            OCLTypeToSPIRVPtr->getAdaptedType(Args[0])->getPointerElementType();
+        ImageTy = adaptSPIRVImageType(M, ImageTy);
         auto SampledImgTy = getSPIRVTypeByChangeBaseTypeName(
             M, ImageTy, kSPIRVTypeName::Image, kSPIRVTypeName::SampledImg);
         Value *SampledImgArgs[] = {Args[0], Args[1]};
@@ -1251,7 +1251,9 @@ void OCLToSPIRVBase::visitCallGetImageSize(CallInst *CI,
   AttributeList Attrs = CI->getCalledFunction()->getAttributes();
   StringRef TyName;
   SmallVector<StringRef, 4> SubStrs;
-  auto IsImg = isOCLImageType(CI->getArgOperand(0)->getType(), &TyName);
+  SmallVector<StructType *, 4> ParamTys;
+  getParameterTypes(CI, ParamTys);
+  auto IsImg = isOCLImageStructType(ParamTys[0], &TyName);
   (void)IsImg;
   assert(IsImg);
   std::string ImageTyName = getImageBaseTypeName(TyName);
@@ -1696,7 +1698,9 @@ static void processSubgroupBlockReadWriteINTEL(CallInst *CI,
 // reads and vector block reads.
 void OCLToSPIRVBase::visitSubgroupBlockReadINTEL(CallInst *CI) {
   OCLBuiltinTransInfo Info;
-  if (isOCLImageType(CI->getArgOperand(0)->getType()))
+  SmallVector<StructType *, 2> ParamTys;
+  getParameterTypes(CI, ParamTys);
+  if (isOCLImageStructType(ParamTys[0]))
     Info.UniqName = getSPIRVFuncName(spv::OpSubgroupImageBlockReadINTEL);
   else
     Info.UniqName = getSPIRVFuncName(spv::OpSubgroupBlockReadINTEL);
@@ -1709,7 +1713,9 @@ void OCLToSPIRVBase::visitSubgroupBlockReadINTEL(CallInst *CI) {
 // instructions.
 void OCLToSPIRVBase::visitSubgroupBlockWriteINTEL(CallInst *CI) {
   OCLBuiltinTransInfo Info;
-  if (isOCLImageType(CI->getArgOperand(0)->getType()))
+  SmallVector<StructType *, 3> ParamTys;
+  getParameterTypes(CI, ParamTys);
+  if (isOCLImageStructType(ParamTys[0]))
     Info.UniqName = getSPIRVFuncName(spv::OpSubgroupImageBlockWriteINTEL);
   else
     Info.UniqName = getSPIRVFuncName(spv::OpSubgroupBlockWriteINTEL);
@@ -1894,21 +1900,24 @@ void OCLToSPIRVBase::visitSubgroupAVCBuiltinCallWithSampler(
   mutateCallInstSPIRV(
       M, CI,
       [=](CallInst *, std::vector<Value *> &Args) {
-        auto SamplerIt = std::find_if(Args.begin(), Args.end(), [](Value *V) {
-          return OCLUtil::isSamplerTy(V->getType());
-        });
-        assert(SamplerIt != Args.end() &&
+        SmallVector<StructType *, 4> ParamTys;
+        getParameterTypes(CI, ParamTys);
+        auto *TyIt =
+            std::find_if(ParamTys.begin(), ParamTys.end(), isSamplerStructTy);
+        assert(TyIt != ParamTys.end() &&
                "Invalid Subgroup AVC Intel built-in call");
+        auto SamplerIt = Args.begin() + (TyIt - ParamTys.begin());
         auto *SamplerVal = *SamplerIt;
         Args.erase(SamplerIt);
+        ParamTys.erase(TyIt);
 
         for (unsigned I = 0, E = Args.size(); I < E; ++I) {
-          if (!isOCLImageType(Args[I]->getType()))
+          if (!isOCLImageStructType(ParamTys[I]))
             continue;
 
-          auto *ImageTy = OCLTypeToSPIRVPtr->getAdaptedType(Args[I]);
-          if (isOCLImageType(ImageTy))
-            ImageTy = getSPIRVImageTypeFromOCL(M, ImageTy);
+          auto *ImageTy = OCLTypeToSPIRVPtr->getAdaptedType(Args[I])
+                              ->getPointerElementType();
+          ImageTy = adaptSPIRVImageType(M, ImageTy);
           auto *SampledImgTy = getSPIRVTypeByChangeBaseTypeName(
               M, ImageTy, kSPIRVTypeName::Image, kSPIRVTypeName::VmeImageINTEL);
 

lib/SPIRV/OCLTypeToSPIRV.cpp

@@ -204,7 +204,9 @@ void OCLTypeToSPIRVBase::adaptArgumentsBySamplerUse(Module &M) {
           AdaptedTy.count(SamplerArg) != 0) // Already traced this, move on.
         continue;
 
-      if (isSPIRVType(SamplerArg->getType(), kSPIRVTypeName::Sampler))
+      if (SamplerArg->getType()->isPointerTy() &&
+          isSPIRVStructType(SamplerArg->getType()->getPointerElementType(),
+                            kSPIRVTypeName::Sampler))
         return;
 
       addAdaptedType(SamplerArg, getSamplerType(&M));
@@ -263,19 +265,15 @@ void OCLTypeToSPIRVBase::adaptArgumentsByMetadata(Function *F) {
   if (!TypeMD)
     return;
   bool Changed = false;
-  auto FT = F->getFunctionType();
-  auto PI = FT->param_begin();
   auto Arg = F->arg_begin();
-  for (unsigned I = 0, E = TypeMD->getNumOperands(); I != E; ++I, ++PI, ++Arg) {
+  for (unsigned I = 0, E = TypeMD->getNumOperands(); I != E; ++I, ++Arg) {
     auto OCLTyStr = getMDOperandAsString(TypeMD, I);
-    auto NewTy = *PI;
-    if (OCLTyStr == OCL_TYPE_NAME_SAMPLER_T && !NewTy->isStructTy()) {
+    if (OCLTyStr == OCL_TYPE_NAME_SAMPLER_T) {
       addAdaptedType(&(*Arg), getSamplerType(M));
       Changed = true;
-    } else if (isPointerToOpaqueStructType(NewTy)) {
-      auto STName = NewTy->getPointerElementType()->getStructName();
-      if (STName.startswith(kSPR2TypeName::ImagePrefix)) {
-        auto Ty = STName.str();
+    } 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);

lib/SPIRV/OCLUtil.cpp

@@ -1369,12 +1369,7 @@ bool isSpecialTypeInitializer(Instruction *Inst) {
   return isSamplerInitializer(Inst) || isPipeStorageInitializer(Inst);
 }
 
-bool isSamplerTy(Type *Ty) {
-  auto PTy = dyn_cast<PointerType>(Ty);
-  if (!PTy)
-    return false;
-
-  auto *STy = dyn_cast<StructType>(PTy->getPointerElementType());
+bool isSamplerStructTy(StructType *STy) {
   return STy && STy->hasName() && STy->getName() == kSPR2TypeName::Sampler;
 }
 

lib/SPIRV/OCLUtil.h

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

lib/SPIRV/PreprocessMetadata.cpp

@@ -272,7 +272,7 @@ void PreprocessMetadataBase::visit(Module *M) {
       // !ip_interface !N
       // !N = !{!"streaming", !"stall_free_return"}
       for (size_t I = 0; I != Interface->getNumOperands(); ++I)
-        InterfaceStrSet.insert(getMDOperandAsString(Interface, I));
+        InterfaceStrSet.insert(getMDOperandAsString(Interface, I).str());
       if (InterfaceStrSet.find("streaming") != InterfaceStrSet.end()) {
         int32_t InterfaceMode = 0;
         if (InterfaceStrSet.find("stall_free_return") != InterfaceStrSet.end())

lib/SPIRV/SPIRVInternal.h

@@ -608,6 +608,7 @@ SPIRVValue *addDecorations(SPIRVValue *Target,
 
 PointerType *getOrCreateOpaquePtrType(Module *M, const std::string &Name,
                                       unsigned AddrSpace = SPIRAS_Global);
+StructType *getOrCreateOpaqueStructType(Module *M, StringRef Name);
 PointerType *getSamplerType(Module *M);
 PointerType *getPipeStorageType(Module *M);
 PointerType *getSPIRVOpaquePtrType(Module *M, Op OC);
@@ -650,17 +651,15 @@ Decoration getArgAsDecoration(CallInst *CI, unsigned I);
 bool isPointerToOpaqueStructType(llvm::Type *Ty);
 bool isPointerToOpaqueStructType(llvm::Type *Ty, const std::string &Name);
 
-/// Check if a type is SPIRV sampler type.
-bool isSPIRVSamplerType(llvm::Type *Ty);
-
-/// Check if a type is OCL image type.
+/// Check if a type is OCL image type (if pointed to).
 /// \return type name without "opencl." prefix.
-bool isOCLImageType(llvm::Type *Ty, StringRef *Name = nullptr);
+bool isOCLImageStructType(llvm::Type *Ty, StringRef *Name = nullptr);
 
 /// \param BaseTyName is the type name as in spirv.BaseTyName.Postfixes
 /// \param Postfix contains postfixes extracted from the SPIR-V image
 ///   type name as spirv.BaseTyName.Postfixes.
-bool isSPIRVType(llvm::Type *Ty, StringRef BaseTyName, StringRef *Postfix = 0);
+bool isSPIRVStructType(llvm::Type *Ty, StringRef BaseTyName,
+                       StringRef *Postfix = 0);
 
 bool isSYCLHalfType(llvm::Type *Ty);
 
@@ -856,7 +855,7 @@ ConstantInt *getSizet(Module *M, uint64_t Value);
 int64_t getMDOperandAsInt(MDNode *N, unsigned I);
 
 /// Get metadata operand as string.
-std::string getMDOperandAsString(MDNode *N, unsigned I);
+StringRef getMDOperandAsString(MDNode *N, unsigned I);
 
 /// Get metadata operand as another metadata node
 MDNode *getMDOperandAsMDNode(MDNode *N, unsigned I);
@@ -935,7 +934,7 @@ std::string getSPIRVImageSampledTypeName(SPIRVType *Ty);
 
 /// Translates OpenCL image type names to SPIR-V.
 /// E.g. %opencl.image1d_rw_t -> %spirv.Image._void_0_0_0_0_0_0_2
-Type *getSPIRVImageTypeFromOCL(Module *M, Type *T);
+Type *adaptSPIRVImageType(Module *M, Type *PointeeType);
 
 /// Get LLVM type for sampled type of SPIR-V image type by postfix.
 Type *getLLVMTypeForSPIRVImageSampledTypePostfix(StringRef Postfix,
@@ -998,6 +997,15 @@ bool containsUnsignedAtomicType(StringRef Name);
 std::string mangleBuiltin(StringRef UniqName, ArrayRef<Type *> ArgTypes,
                           BuiltinFuncMangleInfo *BtnInfo);
 
+/// Extract the pointee types of arguments from a mangled function name. If the
+/// corresponding type is not a pointer to a struct type, its value will be a
+/// nullptr instead.
+void getParameterTypes(Function *F, SmallVectorImpl<StructType *> &ArgTys);
+inline void getParameterTypes(CallInst *CI,
+                              SmallVectorImpl<StructType *> &ArgTys) {
+  return getParameterTypes(CI->getCalledFunction(), ArgTys);
+}
+
 /// Mangle a function from OpenCL extended instruction set in SPIR-V friendly IR
 /// manner
 std::string getSPIRVFriendlyIRFunctionName(OCLExtOpKind ExtOpId,

lib/SPIRV/SPIRVReader.cpp

@@ -1492,13 +1492,14 @@ Value *SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F,
 
   case OpVariable: {
     auto BVar = static_cast<SPIRVVariable *>(BV);
-    auto Ty = transType(BVar->getType()->getPointerElementType());
+    auto *PreTransTy = BVar->getType()->getPointerElementType();
+    auto *Ty = transType(PreTransTy);
     bool IsConst = BVar->isConstant();
     llvm::GlobalValue::LinkageTypes LinkageTy = transLinkageType(BVar);
     SPIRVStorageClassKind BS = BVar->getStorageClass();
     SPIRVValue *Init = BVar->getInitializer();
 
-    if (isSPIRVSamplerType(Ty) && BS == StorageClassUniformConstant) {
+    if (PreTransTy->isTypeSampler() && BS == StorageClassUniformConstant) {
       // Skip generating llvm code during translation of a variable definition,
       // generate code only for its uses
       if (!BB)

lib/SPIRV/SPIRVToOCL.cpp

@@ -250,13 +250,12 @@ void SPIRVToOCLBase::visitCastInst(CastInst &Cast) {
 }
 
 void SPIRVToOCLBase::visitCallSPRIVImageQuerySize(CallInst *CI) {
-  Function *Func = CI->getCalledFunction();
   // Get image type
-  Type *ArgTy = Func->getFunctionType()->getParamType(0);
-  assert(ArgTy->isPointerTy() &&
-         "argument must be a pointer to opaque structure");
-  StructType *ImgTy = cast<StructType>(ArgTy->getPointerElementType());
-  assert(ImgTy->isOpaque() && "image type must be an opaque structure");
+  SmallVector<StructType *, 4> ParamTys;
+  getParameterTypes(CI, ParamTys);
+  StructType *ImgTy = ParamTys[0];
+  assert(ImgTy && ImgTy->isOpaque() &&
+         "image type must be an opaque structure");
   StringRef ImgTyName = ImgTy->getName();
   assert(ImgTyName.startswith("opencl.image") && "not an OCL image type");
 
@@ -755,18 +754,20 @@ void SPIRVToOCLBase::visitCallSPIRVImageSampleExplicitLodBuiltIn(CallInst *CI,
                                                                  Op OC) {
   assert(CI->getCalledFunction() && "Unexpected indirect call");
   AttributeList Attrs = CI->getCalledFunction()->getAttributes();
+  CallInst *CallSampledImg = cast<CallInst>(CI->getArgOperand(0));
+  SmallVector<StructType *, 6> ParamTys;
+  getParameterTypes(CallSampledImg, ParamTys);
   StringRef ImageTypeName;
   bool IsDepthImage = false;
-  if (isOCLImageType(
-          (cast<CallInst>(CI->getOperand(0)))->getArgOperand(0)->getType(),
-          &ImageTypeName))
+  if (isOCLImageStructType(ParamTys[0], &ImageTypeName))
     IsDepthImage = ImageTypeName.contains("_depth_");
 
   auto ModifyArguments = [=](CallInst *, std::vector<Value *> &Args,
                              llvm::Type *&RetTy) {
-    CallInst *CallSampledImg = cast<CallInst>(Args[0]);
     auto Img = CallSampledImg->getArgOperand(0);
-    assert(isOCLImageType(Img->getType()));
+    if (!Img->getType()->isOpaquePointerTy())
+      assert(isOCLImageStructType(
+          Img->getType()->getNonOpaquePointerElementType()));
     auto Sampler = CallSampledImg->getArgOperand(1);
     Args[0] = Img;
     Args.insert(Args.begin() + 1, Sampler);
@@ -1247,27 +1248,53 @@ void SPIRVToOCLBase::translateOpaqueTypes() {
     if (!IsSPIRVOpaque)
       continue;
 
-    SmallVector<std::string, 8> Postfixes;
-    std::string DecodedST = decodeSPIRVTypeName(STName, Postfixes);
+    S->setName(translateOpaqueType(STName));
+  }
+}
+
+std::string SPIRVToOCLBase::translateOpaqueType(StringRef STName) {
+  if (!STName.startswith(kSPIRVTypeName::PrefixAndDelim))
+    return STName.str();
+
+  SmallVector<std::string, 8> Postfixes;
+  std::string DecodedST = decodeSPIRVTypeName(STName, Postfixes);
+
+  if (!SPIRVOpaqueTypeOpCodeMap::find(DecodedST))
+    return STName.str();
+
+  Op OP = SPIRVOpaqueTypeOpCodeMap::map(DecodedST);
+  std::string OCLOpaqueName;
+  if (OP == OpTypeImage)
+    OCLOpaqueName = getOCLImageOpaqueType(Postfixes);
+  else if (OP == OpTypePipe)
+    OCLOpaqueName = getOCLPipeOpaqueType(Postfixes);
+  else if (isSubgroupAvcINTELTypeOpCode(OP))
+    OCLOpaqueName = OCLSubgroupINTELTypeOpCodeMap::rmap(OP);
+  else if (isOpaqueGenericTypeOpCode(OP))
+    OCLOpaqueName = OCLOpaqueTypeOpCodeMap::rmap(OP);
+  else
+    return STName.str();
+
+  return OCLOpaqueName;
+}
 
-    if (!SPIRVOpaqueTypeOpCodeMap::find(DecodedST))
+void SPIRVToOCLBase::getParameterTypes(CallInst *CI,
+                                       SmallVectorImpl<StructType *> &Tys) {
+  ::getParameterTypes(CI, Tys);
+  for (auto &Ty : Tys) {
+    if (!Ty)
       continue;
+    StringRef STName = Ty->getStructName();
+    bool IsSPIRVOpaque =
+        Ty->isOpaque() && STName.startswith(kSPIRVTypeName::PrefixAndDelim);
 
-    Op OP = SPIRVOpaqueTypeOpCodeMap::map(DecodedST);
-    std::string OCLOpaqueName;
-    if (OP == OpTypeImage)
-      OCLOpaqueName = getOCLImageOpaqueType(Postfixes);
-    else if (OP == OpTypePipe)
-      OCLOpaqueName = getOCLPipeOpaqueType(Postfixes);
-    else if (isSubgroupAvcINTELTypeOpCode(OP))
-      OCLOpaqueName = OCLSubgroupINTELTypeOpCodeMap::rmap(OP);
-    else if (isOpaqueGenericTypeOpCode(OP))
-      OCLOpaqueName = OCLOpaqueTypeOpCodeMap::rmap(OP);
-    else
+    if (!IsSPIRVOpaque)
       continue;
 
-    S->setName(OCLOpaqueName);
-  }
+    std::string NewName = translateOpaqueType(STName);
+    if (NewName != STName)
+      Ty = getOrCreateOpaqueStructType(M, NewName);
+  };
 }
 
 void addSPIRVBIsLoweringPass(ModulePassManager &PassMgr,

lib/SPIRV/SPIRVToOCL.h

@@ -262,7 +262,10 @@ class SPIRVToOCLBase : public InstVisitor<SPIRVToOCLBase> {
   /// example: spirv.Pipe._0 => opencl.pipe_ro_t
   std::string getOCLPipeOpaqueType(SmallVector<std::string, 8> &Postfixes);
 
+  void getParameterTypes(CallInst *CI, SmallVectorImpl<StructType *> &Tys);
+
   void translateOpaqueTypes();
+  std::string translateOpaqueType(StringRef STName);
 
   Module *M;
   LLVMContext *Ctx;