[OpaquePtr] Pass pointer type information into mangleBuiltin. (#1549)

This includes a rejigging of the BuiltinFuncMangleInfo to actually act as the
source of information to pass this information into.

Only some of the call sites of mangleBuiltin have been properly updated to pass
in the pointer type element information. The various mutateCallInst* callers
have yet to be updated, so those methods are temporarily relying on querying
getPointerElementType() to generate this information.

Author: jcranmer-intel

include/LLVMSPIRVLib.h

@@ -106,6 +106,10 @@ std::unique_ptr<SPIRVModule> readSpirvModule(std::istream &IS,
                                              const SPIRV::TranslatorOpts &Opts,
                                              std::string &ErrMsg);
 
+/// This contains a pair of the pointer element type and an indirection
+/// parameter (to capture cases where an array of OpenCL types is used).
+typedef llvm::PointerIntPair<llvm::Type *, 1, bool> PointerIndirectPair;
+
 } // End namespace SPIRV
 
 namespace llvm {
@@ -156,8 +160,13 @@ bool regularizeLlvmForSpirv(Module *M, std::string &ErrMsg,
                             const SPIRV::TranslatorOpts &Opts);
 
 /// \brief Mangle OpenCL builtin function function name.
+/// If any type in ArgTypes is a pointer type, the corresponding entry in
+/// ArgPointerTypes should contain the type should point to. If there are no
+/// pointer-typed arguments in ArgTypes, then ArgPointerTypes may be empty.
 void mangleOpenClBuiltin(const std::string &UnmangledName,
-                         ArrayRef<Type *> ArgTypes, std::string &MangledName);
+                         ArrayRef<Type *> ArgTypes,
+                         ArrayRef<SPIRV::PointerIndirectPair> ArgPointerTypes,
+                         std::string &MangledName);
 
 /// Create a pass for translating LLVM to SPIR-V.
 ModulePass *createLLVMToSPIRVLegacy(SPIRV::SPIRVModule *);

lib/SPIRV/OCLToSPIRV.cpp

@@ -1009,7 +1009,8 @@ void OCLToSPIRVBase::visitCallReadImageWithSampler(CallInst *CI,
         Value *SampledImgArgs[] = {Args[0], Args[1]};
         auto SampledImg = addCallInstSPIRV(
             M, getSPIRVFuncName(OpSampledImage), SampledImgTy, SampledImgArgs,
-            nullptr, CI, kSPIRVName::TempSampledImage);
+            nullptr, {ArgStructTys[0], ArgStructTys[1]}, CI,
+            kSPIRVName::TempSampledImage);
 
         Args[0] = SampledImg;
         Args.erase(Args.begin() + 1, Args.begin() + 2);
@@ -1645,13 +1646,16 @@ void OCLToSPIRVBase::visitSubgroupAVCWrapperBuiltinCall(
       getSubgroupAVCIntelTyKind(CI->getCalledFunction()->getName());
   std::string MCETName =
       std::string(kOCLSubgroupsAVCIntel::TypePrefix) + "mce_" + TyKind + "_t";
-  auto *MCETy =
-      PointerType::get(getSubgroupAVCIntelMCEType(M, MCETName), SPIRAS_Private);
+  auto *MCESTy = getSubgroupAVCIntelMCEType(M, MCETName);
+  auto *MCETy = PointerType::get(MCESTy, SPIRAS_Private);
   std::string ToMCEFName = Prefix + OpKind + "_convert_to_mce_" + TyKind;
   Op ToMCEOC = OpNop;
   OCLSPIRVSubgroupAVCIntelBuiltinMap::find(ToMCEFName, &ToMCEOC);
   assert(ToMCEOC != OpNop && "Invalid Subgroup AVC Intel built-in call");
 
+  SmallVector<StructType *, 2> ParamTys;
+  getParameterTypes(CI, ParamTys);
+
   if (std::strcmp(TyKind, "payload") == 0) {
     // Wrapper built-ins which take the 'payload_t' argument return it as
     // the result: two conversion calls required.
@@ -1666,16 +1670,16 @@ void OCLToSPIRVBase::visitSubgroupAVCWrapperBuiltinCall(
         [=](CallInst *, std::vector<Value *> &Args, Type *&Ret) {
           Ret = MCETy;
           // Create conversion function call for the last operand
-          Args[Args.size() - 1] =
-              addCallInstSPIRV(M, getSPIRVFuncName(ToMCEOC), MCETy,
-                               Args[Args.size() - 1], nullptr, CI, "");
+          Args[Args.size() - 1] = addCallInstSPIRV(
+              M, getSPIRVFuncName(ToMCEOC), MCETy, Args[Args.size() - 1],
+              nullptr, {ParamTys[Args.size() - 1]}, CI, "");
 
           return getSPIRVFuncName(WrappedOC);
         },
         [=](CallInst *NewCI) -> Instruction * {
           // Create conversion function call for the return result
           return addCallInstSPIRV(M, getSPIRVFuncName(FromMCEOC), CI->getType(),
-                                  NewCI, nullptr, CI, "");
+                                  NewCI, nullptr, {MCESTy}, CI, "");
         },
         &Attrs);
   } else {
@@ -1686,9 +1690,9 @@ void OCLToSPIRVBase::visitSubgroupAVCWrapperBuiltinCall(
         [=](CallInst *, std::vector<Value *> &Args) {
           // Create conversion function call for the last
           // operand
-          Args[Args.size() - 1] =
-              addCallInstSPIRV(M, getSPIRVFuncName(ToMCEOC), MCETy,
-                               Args[Args.size() - 1], nullptr, CI, "");
+          Args[Args.size() - 1] = addCallInstSPIRV(
+              M, getSPIRVFuncName(ToMCEOC), MCETy, Args[Args.size() - 1],
+              nullptr, {ParamTys[Args.size() - 1]}, CI, "");
 
           return getSPIRVFuncName(WrappedOC);
         },
@@ -1726,6 +1730,7 @@ void OCLToSPIRVBase::visitSubgroupAVCBuiltinCallWithSampler(
                "Invalid Subgroup AVC Intel built-in call");
         auto SamplerIt = Args.begin() + (TyIt - ParamTys.begin());
         auto *SamplerVal = *SamplerIt;
+        auto *SamplerTy = *TyIt;
         Args.erase(SamplerIt);
         ParamTys.erase(TyIt);
 
@@ -1745,7 +1750,8 @@ void OCLToSPIRVBase::visitSubgroupAVCBuiltinCallWithSampler(
 
           Value *SampledImgArgs[] = {Args[I], SamplerVal};
           Args[I] = addCallInstSPIRV(M, getSPIRVFuncName(OpVmeImageINTEL),
-                                     SampledImgTy, SampledImgArgs, nullptr, CI,
+                                     SampledImgTy, SampledImgArgs, nullptr,
+                                     {ParamTys[I], SamplerTy}, CI,
                                      kSPIRVName::TempSampledImage);
         }
         return getSPIRVFuncName(OC);

lib/SPIRV/OCLUtil.cpp

@@ -1154,9 +1154,11 @@ class OCLBuiltinFuncMangleInfo : public SPIRV::BuiltinFuncMangleInfo {
     } else if (NameRef.startswith("vstore")) {
       addUnsignedArg(1);
     } else if (NameRef.startswith("ndrange_")) {
-      addUnsignedArg(-1);
+      addUnsignedArgs(0, 2);
       if (NameRef[8] == '2' || NameRef[8] == '3') {
-        setArgAttr(-1, SPIR::ATTR_CONST);
+        setArgAttr(0, SPIR::ATTR_CONST);
+        setArgAttr(1, SPIR::ATTR_CONST);
+        setArgAttr(2, SPIR::ATTR_CONST);
       }
     } else if (NameRef.contains("umax")) {
       addUnsignedArg(-1);
@@ -1602,7 +1604,9 @@ Value *SPIRV::transSPIRVMemorySemanticsIntoOCLMemFenceFlags(
 
 void llvm::mangleOpenClBuiltin(const std::string &UniqName,
                                ArrayRef<Type *> ArgTypes,
+                               ArrayRef<PointerIndirectPair> PointerElementTys,
                                std::string &MangledName) {
   OCLUtil::OCLBuiltinFuncMangleInfo BtnInfo(ArgTypes);
+  BtnInfo.fillPointerElementTypes(PointerElementTys);
   MangledName = SPIRV::mangleBuiltin(UniqName, ArgTypes, &BtnInfo);
 }

lib/SPIRV/SPIRVInternal.h

@@ -457,10 +457,11 @@ struct BuiltinArgTypeMangleInfo {
   bool IsLocalArgBlock;
   SPIR::TypePrimitiveEnum Enum;
   unsigned Attr;
+  PointerIndirectPair PointerElementType;
   BuiltinArgTypeMangleInfo()
       : IsSigned(true), IsVoidPtr(false), IsEnum(false), IsSampler(false),
         IsAtomic(false), IsLocalArgBlock(false), Enum(SPIR::PRIMITIVE_NONE),
-        Attr(0) {}
+        Attr(0), PointerElementType(nullptr, false) {}
 };
 
 /// Information for mangling builtin function.
@@ -469,92 +470,61 @@ class BuiltinFuncMangleInfo {
   /// Translate builtin function name and set
   /// argument attributes and unsigned args.
   BuiltinFuncMangleInfo(const std::string &UniqName = "")
-      : LocalArgBlockIdx(-1), VarArgIdx(-1), DontMangle(false) {
+      : VarArgIdx(-1), DontMangle(false) {
     if (!UniqName.empty())
       init(UniqName);
   }
   virtual ~BuiltinFuncMangleInfo() {}
   const std::string &getUnmangledName() const { return UnmangledName; }
-  void addUnsignedArg(int Ndx) { UnsignedArgs.insert(Ndx); }
+  void addUnsignedArg(int Ndx) {
+    if (Ndx == -1)
+      return addUnsignedArgs(0, 10); // 10 is enough for everybody, right?
+    getTypeMangleInfo(Ndx).IsSigned = false;
+  }
   void addUnsignedArgs(int StartNdx, int StopNdx) {
     assert(StartNdx < StopNdx && "wrong parameters");
     for (int I = StartNdx; I <= StopNdx; ++I)
       addUnsignedArg(I);
   }
-  void addVoidPtrArg(int Ndx) { VoidPtrArgs.insert(Ndx); }
-  void addSamplerArg(int Ndx) { SamplerArgs.insert(Ndx); }
-  void addAtomicArg(int Ndx) { AtomicArgs.insert(Ndx); }
-  void setLocalArgBlock(int Ndx) {
-    assert(0 <= Ndx && "it is not allowed to set less than zero index");
-    LocalArgBlockIdx = Ndx;
+  void addVoidPtrArg(unsigned Ndx) { getTypeMangleInfo(Ndx).IsVoidPtr = true; }
+  void addSamplerArg(unsigned Ndx) { getTypeMangleInfo(Ndx).IsSampler = true; }
+  void addAtomicArg(unsigned Ndx) { getTypeMangleInfo(Ndx).IsAtomic = true; }
+  void setLocalArgBlock(unsigned Ndx) {
+    getTypeMangleInfo(Ndx).IsLocalArgBlock = true;
   }
-  void setEnumArg(int Ndx, SPIR::TypePrimitiveEnum Enum) {
-    EnumArgs[Ndx] = Enum;
+  void setEnumArg(unsigned Ndx, SPIR::TypePrimitiveEnum Enum) {
+    auto &Info = getTypeMangleInfo(Ndx);
+    Info.IsEnum = true;
+    Info.Enum = Enum;
+  }
+  void setArgAttr(unsigned Ndx, unsigned Attr) {
+    getTypeMangleInfo(Ndx).Attr = Attr;
   }
-  void setArgAttr(int Ndx, unsigned Attr) { Attrs[Ndx] = Attr; }
   void setVarArg(int Ndx) {
     assert(0 <= Ndx && "it is not allowed to set less than zero index");
     VarArgIdx = Ndx;
   }
   void setAsDontMangle() { DontMangle = true; }
-  bool isArgUnsigned(int Ndx) {
-    return UnsignedArgs.count(-1) || UnsignedArgs.count(Ndx);
-  }
-  bool isArgVoidPtr(int Ndx) {
-    return VoidPtrArgs.count(-1) || VoidPtrArgs.count(Ndx);
-  }
-  bool isArgSampler(int Ndx) { return SamplerArgs.count(Ndx); }
-  bool isArgAtomic(int Ndx) { return AtomicArgs.count(Ndx); }
-  bool isLocalArgBlock(int Ndx) { return LocalArgBlockIdx == Ndx; }
-  bool isArgEnum(int Ndx, SPIR::TypePrimitiveEnum *Enum = nullptr) {
-    auto Loc = EnumArgs.find(Ndx);
-    if (Loc == EnumArgs.end())
-      Loc = EnumArgs.find(-1);
-    if (Loc == EnumArgs.end())
-      return false;
-    if (Enum)
-      *Enum = Loc->second;
-    return true;
-  }
   bool avoidMangling() { return DontMangle; }
-  unsigned getArgAttr(int Ndx) {
-    auto Loc = Attrs.find(Ndx);
-    if (Loc == Attrs.end())
-      Loc = Attrs.find(-1);
-    if (Loc == Attrs.end())
-      return 0;
-    return Loc->second;
-  }
   // get ellipsis index, single ellipsis at the end of the function is possible
   // only return value < 0 if none
   int getVarArg() const { return VarArgIdx; }
-  BuiltinArgTypeMangleInfo getTypeMangleInfo(int Ndx) {
-    BuiltinArgTypeMangleInfo Info;
-    Info.IsSigned = !isArgUnsigned(Ndx);
-    Info.IsVoidPtr = isArgVoidPtr(Ndx);
-    Info.IsEnum = isArgEnum(Ndx, &Info.Enum);
-    Info.IsSampler = isArgSampler(Ndx);
-    Info.IsAtomic = isArgAtomic(Ndx);
-    Info.IsLocalArgBlock = isLocalArgBlock(Ndx);
-    Info.Attr = getArgAttr(Ndx);
+  BuiltinArgTypeMangleInfo &getTypeMangleInfo(unsigned Ndx) {
+    while (Ndx >= ArgInfo.size())
+      ArgInfo.emplace_back();
+    BuiltinArgTypeMangleInfo &Info = ArgInfo[Ndx];
     return Info;
   }
   virtual void init(StringRef UniqUnmangledName) {
     UnmangledName = UniqUnmangledName.str();
   }
 
+  void fillPointerElementTypes(ArrayRef<PointerIndirectPair>);
+
 protected:
   std::string UnmangledName;
-  std::set<int> UnsignedArgs; // unsigned arguments, or -1 if all are unsigned
-  std::set<int> VoidPtrArgs;  // void pointer arguments, or -1 if all are void
-                              // pointer
-  std::set<int> SamplerArgs;  // sampler arguments
-  std::set<int> AtomicArgs;   // atomic arguments
-  std::map<int, SPIR::TypePrimitiveEnum> EnumArgs; // enum arguments
-  std::map<int, unsigned> Attrs;                   // argument attributes
-  int LocalArgBlockIdx; // index of a block with local arguments, idx < 0 if
-                        // none
-  int VarArgIdx;        // index of ellipsis argument, idx < 0 if none
+  std::vector<BuiltinArgTypeMangleInfo> ArgInfo;
+  int VarArgIdx; // index of ellipsis argument, idx < 0 if none
 private:
   bool DontMangle; // clang doesn't apply mangling for some builtin functions
                    // (i.e. enqueue_kernel)
@@ -598,7 +568,8 @@ void removeFnAttr(CallInst *Call, Attribute::AttrKind Attr);
 void addFnAttr(CallInst *Call, Attribute::AttrKind Attr);
 void saveLLVMModule(Module *M, const std::string &OutputFile);
 std::string mapSPIRVTypeToOCLType(SPIRVType *Ty, bool Signed);
-std::string mapLLVMTypeToOCLType(const Type *Ty, bool Signed);
+std::string mapLLVMTypeToOCLType(const Type *Ty, bool Signed,
+                                 Type *PointerElementType = nullptr);
 SPIRVDecorate *mapPostfixToDecorate(StringRef Postfix, SPIRVEntry *Target);
 
 /// Add decorations to a SPIR-V entry.
@@ -682,7 +653,8 @@ StringRef dePrefixSPIRVName(StringRef R, SmallVectorImpl<StringRef> &Postfix);
 /// Get a canonical function name for a SPIR-V op code.
 std::string getSPIRVFuncName(Op OC, StringRef PostFix = "");
 
-std::string getSPIRVFuncName(Op OC, const Type *PRetTy, bool IsSigned = false);
+std::string getSPIRVFuncName(Op OC, const Type *PRetTy, bool IsSigned = false,
+                             Type *PointerElementType = nullptr);
 
 std::string getSPIRVFuncName(SPIRVBuiltinVariableKind BVKind);
 
@@ -785,6 +757,7 @@ CallInst *addCallInst(Module *M, StringRef FuncName, Type *RetTy,
 /// Add a call instruction for SPIR-V builtin function.
 CallInst *addCallInstSPIRV(Module *M, StringRef FuncName, Type *RetTy,
                            ArrayRef<Value *> Args, AttributeList *Attrs,
+                           ArrayRef<Type *> PointerElementTypes,
                            Instruction *Pos, StringRef InstName);
 
 /// Add a call of spir_block_bind function.
@@ -889,7 +862,8 @@ std::string getPostfix(Decoration Dec, unsigned Value = 0);
 /// Get postfix _R{ReturnType} for return type
 /// The returned postfix does not includ "_" at the beginning
 std::string getPostfixForReturnType(CallInst *CI, bool IsSigned = false);
-std::string getPostfixForReturnType(const Type *PRetTy, bool IsSigned = false);
+std::string getPostfixForReturnType(const Type *PRetTy, bool IsSigned = false,
+                                    Type *PointerElementType = nullptr);
 
 Constant *getScalarOrVectorConstantInt(Type *T, uint64_t V,
                                        bool IsSigned = false);
@@ -1013,6 +987,7 @@ inline void getParameterTypes(CallInst *CI,
 /// manner
 std::string getSPIRVFriendlyIRFunctionName(OCLExtOpKind ExtOpId,
                                            ArrayRef<Type *> ArgTys,
+                                           ArrayRef<PointerIndirectPair> PETs,
                                            Type *RetTy = nullptr);
 
 /// Mangle a function in SPIR-V friendly IR manner
@@ -1024,7 +999,8 @@ std::string getSPIRVFriendlyIRFunctionName(OCLExtOpKind ExtOpId,
 /// \param Types of arguments of SPIR-V built-in function
 /// \return IA64 mangled name.
 std::string getSPIRVFriendlyIRFunctionName(const std::string &UniqName,
-                                           spv::Op OC, ArrayRef<Type *> ArgTys);
+                                           spv::Op OC, ArrayRef<Type *> ArgTys,
+                                           ArrayRef<PointerIndirectPair> PETs);
 
 /// Cast a function to a void(void) funtion pointer.
 Constant *castToVoidFuncPtr(Function *F);