Add a unified getSPIRVType interface. (#1716)

We have a couple of interfaces that create the custom SPIR-V types. Again, in
preparation for an eventual OpaqueType-based interface for types, these
functions are being replaced with a more centralized, uniform basis for
constructing these types.

Some of the related helper methods that were previously used to build the names
for struct types are now obsoleted by this change and have been removed.

Original commit:
KhronosGroup/SPIRV-LLVM-Translator@8784853

Author: jcranmer-intel

llvm-spirv/lib/SPIRV/OCLToSPIRV.cpp

@@ -1383,9 +1383,11 @@ void OCLToSPIRVBase::visitCallEnqueueKernel(CallInst *CI,
 
   // If no event arguments in original call, add dummy ones
   if (!HasEvents) {
-    Args.push_back(getInt32(M, 0));           // dummy num events
-    Args.push_back(getOCLNullClkEventPtr(M)); // dummy wait events
-    Args.push_back(getOCLNullClkEventPtr(M)); // dummy ret event
+    Args.push_back(getInt32(M, 0)); // dummy num events
+    Value *Null = Constant::getNullValue(PointerType::get(
+        getSPIRVType(OpTypeDeviceEvent, true), SPIRAS_Generic));
+    Args.push_back(Null); // dummy wait events
+    Args.push_back(Null); // dummy ret event
   }
 
   // Invoke: Pointer to invoke function

llvm-spirv/lib/SPIRV/OCLTypeToSPIRV.cpp

@@ -76,10 +76,12 @@ OCLTypeToSPIRVBase &OCLTypeToSPIRVPass::run(llvm::Module &M,
   return *this;
 }
 
-OCLTypeToSPIRVBase::OCLTypeToSPIRVBase() : M(nullptr), Ctx(nullptr) {}
+OCLTypeToSPIRVBase::OCLTypeToSPIRVBase()
+    : BuiltinCallHelper(ManglingRules::None), M(nullptr), Ctx(nullptr) {}
 
 bool OCLTypeToSPIRVBase::runOCLTypeToSPIRV(Module &Module) {
   LLVM_DEBUG(dbgs() << "Enter OCLTypeToSPIRV:\n");
+  initialize(Module);
   M = &Module;
   Ctx = &M->getContext();
   AdaptedTy.clear();
@@ -179,8 +181,7 @@ void OCLTypeToSPIRVBase::adaptArgumentsBySamplerUse(Module &M) {
           AdaptedTy.count(SamplerArg) != 0) // Already traced this, move on.
         continue;
 
-      addAdaptedType(SamplerArg, TypedPointerType::get(getSamplerStructType(&M),
-                                                       SPIRAS_Constant));
+      addAdaptedType(SamplerArg, getSPIRVType(OpTypeSampler));
       auto Caller = cast<Argument>(SamplerArg)->getParent();
       addWork(Caller);
       TraceArg(Caller, cast<Argument>(SamplerArg)->getArgNo());
@@ -224,11 +225,10 @@ void OCLTypeToSPIRVBase::adaptFunctionArguments(Function *F) {
         continue;
       if (STName.startswith(kSPR2TypeName::ImagePrefix)) {
         auto Ty = STName.str();
-        auto AccStr = getAccessQualifierFullName(Ty);
-        addAdaptedType(&*Arg, TypedPointerType::get(
-                                  getOrCreateOpaqueStructType(
-                                      M, mapOCLTypeNameToSPIRV(Ty, AccStr)),
-                                  SPIRAS_Global));
+        auto Acc = getAccessQualifier(Ty);
+        auto Desc = getImageDescriptor(ParamTys[I]);
+        addAdaptedType(
+            &*Arg, getSPIRVType(OpTypeImage, Type::getVoidTy(*Ctx), Desc, Acc));
         Changed = true;
       }
     }
@@ -249,19 +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), TypedPointerType::get(getSamplerStructType(M),
-                                                    SPIRAS_Constant));
+      addAdaptedType(&(*Arg), getSPIRVType(OpTypeSampler));
       Changed = true;
     } else if (OCLTyStr.startswith("image") && OCLTyStr.endswith("_t")) {
       auto Ty = (Twine("opencl.") + OCLTyStr).str();
-      if (StructType::getTypeByName(F->getContext(), Ty)) {
+      if (auto *STy = StructType::getTypeByName(F->getContext(), Ty)) {
+        auto *ImageTy = TypedPointerType::get(STy, SPIRAS_Global);
+        auto Desc = getImageDescriptor(ImageTy);
         auto AccMD = F->getMetadata(SPIR_MD_KERNEL_ARG_ACCESS_QUAL);
         assert(AccMD && "Invalid access qualifier metadata");
-        auto AccStr = getMDOperandAsString(AccMD, I);
-        addAdaptedType(&(*Arg), TypedPointerType::get(
-                                    getOrCreateOpaqueStructType(
-                                        M, mapOCLTypeNameToSPIRV(Ty, AccStr)),
-                                    SPIRAS_Global));
+        auto Acc = SPIRSPIRVAccessQualifierMap::map(
+            getMDOperandAsString(AccMD, I).str());
+        addAdaptedType(
+            &*Arg, getSPIRVType(OpTypeImage, Type::getVoidTy(*Ctx), Desc, Acc));
         Changed = true;
       }
     }

llvm-spirv/lib/SPIRV/OCLTypeToSPIRV.h

@@ -43,6 +43,7 @@
 #define SPIRV_OCLTYPETOSPIRV_H
 
 #include "LLVMSPIRVLib.h"
+#include "SPIRVBuiltinHelper.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/PassManager.h"
@@ -53,7 +54,7 @@
 
 namespace SPIRV {
 
-class OCLTypeToSPIRVBase {
+class OCLTypeToSPIRVBase : protected BuiltinCallHelper {
 public:
   OCLTypeToSPIRVBase();
 

llvm-spirv/lib/SPIRV/OCLUtil.cpp

@@ -864,7 +864,7 @@ unsigned transVecTypeHint(MDNode *Node) {
 }
 
 SPIRAddressSpace getOCLOpaqueTypeAddrSpace(Op OpCode) {
-  switch (OpCode) {
+  switch ((unsigned)OpCode) {
   case OpTypeQueue:
     return SPIRV_QUEUE_T_ADDR_SPACE;
   case OpTypeEvent:
@@ -878,10 +878,13 @@ SPIRAddressSpace getOCLOpaqueTypeAddrSpace(Op OpCode) {
     return SPIRV_PIPE_ADDR_SPACE;
   case OpTypeImage:
   case OpTypeSampledImage:
+  case OpTypeVmeImageINTEL:
     return SPIRV_IMAGE_ADDR_SPACE;
   case OpConstantSampler:
   case OpTypeSampler:
     return SPIRV_SAMPLER_T_ADDR_SPACE;
+  case internal::OpTypeJointMatrixINTEL:
+    return SPIRAS_Global;
   default:
     if (isSubgroupAvcINTELTypeOpCode(OpCode))
       return SPIRV_AVC_INTEL_T_ADDR_SPACE;

llvm-spirv/lib/SPIRV/SPIRVBuiltinHelper.cpp

@@ -242,12 +242,17 @@ Type *BuiltinCallHelper::adjustImageType(Type *T, StringRef OldImageKind,
     Type *StructTy = TypedPtrTy->getElementType();
     // Adapt opencl.* struct type names to spirv.* struct type names.
     if (isOCLImageType(T)) {
+      if (OldImageKind != kSPIRVTypeName::Image)
+        report_fatal_error("Type was not an image type");
       auto ImageTypeName = StructTy->getStructName();
-      StringRef Acc = kAccessQualName::ReadOnly;
+      auto Desc =
+          map<SPIRVTypeImageDescriptor>(getImageBaseTypeName(ImageTypeName));
+      spv::AccessQualifier Acc = AccessQualifierReadOnly;
       if (hasAccessQualifiedName(ImageTypeName))
-        Acc = getAccessQualifierFullName(ImageTypeName);
-      StructTy = getOrCreateOpaqueStructType(
-          M, mapOCLTypeNameToSPIRV(ImageTypeName, Acc));
+        Acc = getAccessQualifier(ImageTypeName);
+      auto NewImageType = SPIRVOpaqueTypeOpCodeMap::map(NewImageKind.str());
+      return getSPIRVType(NewImageType, Type::getVoidTy(M->getContext()), Desc,
+                          Acc);
     }
 
     // Change type name (e.g., spirv.Image -> spirv.SampledImg) if necessary.
@@ -263,6 +268,53 @@ Type *BuiltinCallHelper::adjustImageType(Type *T, StringRef OldImageKind,
   report_fatal_error("Expected type to be a SPIRV image type");
 }
 
+Type *BuiltinCallHelper::getSPIRVType(spv::Op TypeOpcode, bool UseRealType) {
+  return getSPIRVType(TypeOpcode, "", {}, UseRealType);
+}
+
+Type *BuiltinCallHelper::getSPIRVType(spv::Op TypeOpcode,
+                                      spv::AccessQualifier Access,
+                                      bool UseRealType) {
+  return getSPIRVType(TypeOpcode, "", {(unsigned)Access}, UseRealType);
+}
+
+Type *BuiltinCallHelper::getSPIRVType(spv::Op TypeOpcode, Type *InnerType,
+                                      SPIRVTypeImageDescriptor Desc,
+                                      Optional<spv::AccessQualifier> Access,
+                                      bool UseRealType) {
+  return getSPIRVType(TypeOpcode, convertTypeToPostfix(InnerType),
+                      {(unsigned)Desc.Dim, (unsigned)Desc.Depth,
+                       (unsigned)Desc.Arrayed, (unsigned)Desc.MS,
+                       (unsigned)Desc.Sampled, (unsigned)Desc.Format,
+                       (unsigned)Access.value_or(AccessQualifierReadOnly)},
+                      UseRealType);
+}
+
+Type *BuiltinCallHelper::getSPIRVType(spv::Op TypeOpcode,
+                                      StringRef InnerTypeName,
+                                      ArrayRef<unsigned> Parameters,
+                                      bool UseRealType) {
+  std::string FullName;
+  {
+    raw_string_ostream OS(FullName);
+    OS << kSPIRVTypeName::PrefixAndDelim
+       << SPIRVOpaqueTypeOpCodeMap::rmap(TypeOpcode);
+    if (!InnerTypeName.empty() || !Parameters.empty())
+      OS << kSPIRVTypeName::Delimiter;
+    if (!InnerTypeName.empty())
+      OS << kSPIRVTypeName::PostfixDelim << InnerTypeName;
+    for (unsigned IntParam : Parameters)
+      OS << kSPIRVTypeName::PostfixDelim << IntParam;
+  }
+  auto *STy = StructType::getTypeByName(M->getContext(), FullName);
+  if (!STy)
+    STy = StructType::create(M->getContext(), FullName);
+
+  unsigned AddrSpace = getOCLOpaqueTypeAddrSpace(TypeOpcode);
+  return UseRealType ? (Type *)PointerType::get(STy, AddrSpace)
+                     : TypedPointerType::get(STy, AddrSpace);
+}
+
 BuiltinCallMutator::ValueTypePair
 BuiltinCallHelper::getCallValue(CallInst *CI, unsigned ArgNo) {
   Function *CalledFunc = CI->getCalledFunction();

llvm-spirv/lib/SPIRV/SPIRVBuiltinHelper.h

@@ -42,6 +42,8 @@
 
 #include "LLVMSPIRVLib.h"
 #include "libSPIRV/SPIRVOpCode.h"
+#include "libSPIRV/SPIRVType.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/IRBuilder.h"
@@ -310,6 +312,40 @@ class BuiltinCallHelper {
   llvm::Type *adjustImageType(llvm::Type *T, llvm::StringRef OldImageKind,
                               llvm::StringRef NewImageKind);
 
+  /// Create a new type representing a SPIR-V opaque type that takes no
+  /// parameters (such as sampler types).
+  ///
+  /// If UseRealType is false, a typed pointer type may be returned; if it is
+  /// true, a pointer type will be used instead.
+  llvm::Type *getSPIRVType(spv::Op TypeOpcode, bool UseRealType = false);
+
+  /// Create a new type representing a SPIR-V opaque type that takes only an
+  /// access qualifier (such as pipe types).
+  ///
+  /// If UseRealType is false, a typed pointer type may be returned; if it is
+  /// true, a pointer type will be used instead.
+  llvm::Type *getSPIRVType(spv::Op TypeOpcode, spv::AccessQualifier Access,
+                           bool UseRealType = false);
+
+  /// Create a new type representing a SPIR-V opaque type that is an image type
+  /// of some kind.
+  ///
+  /// If UseRealType is false, a typed pointer type may be returned; if it is
+  /// true, a pointer type will be used instead.
+  llvm::Type *getSPIRVType(spv::Op TypeOpcode, llvm::Type *InnerType,
+                           SPIRVTypeImageDescriptor Desc,
+                           llvm::Optional<spv::AccessQualifier> Access,
+                           bool UseRealType = false);
+
+  /// Create a new type representing a SPIR-V opaque type that takes arbitrary
+  /// parameters.
+  ///
+  /// If UseRealType is false, a typed pointer type may be returned; if it is
+  /// true, a pointer type will be used instead.
+  llvm::Type *getSPIRVType(spv::Op TypeOpcode, llvm::StringRef InnerTypeName,
+                           llvm::ArrayRef<unsigned> Parameters,
+                           bool UseRealType = false);
+
 private:
   llvm::SmallVector<llvm::Type *, 4> CachedParameterTypes;
   llvm::Function *CachedFunc = nullptr;

llvm-spirv/lib/SPIRV/SPIRVInternal.h

@@ -560,7 +560,6 @@ bool isSupportedTriple(Triple T);
 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,
                                  Type *PointerElementType = nullptr);
 SPIRVDecorate *mapPostfixToDecorate(StringRef Postfix, SPIRVEntry *Target);
@@ -570,12 +569,7 @@ SPIRVDecorate *mapPostfixToDecorate(StringRef Postfix, SPIRVEntry *Target);
 SPIRVValue *addDecorations(SPIRVValue *Target,
                            const SmallVectorImpl<std::string> &Decs);
 
-PointerType *getOrCreateOpaquePtrType(Module *M, const std::string &Name,
-                                      unsigned AddrSpace = SPIRAS_Global);
 StructType *getOrCreateOpaqueStructType(Module *M, StringRef Name);
-PointerType *getSamplerType(Module *M);
-Type *getSamplerStructType(Module *M);
-PointerType *getSPIRVOpaquePtrType(Module *M, Op OC);
 void getFunctionTypeParameterTypes(llvm::FunctionType *FT,
                                    std::vector<Type *> &ArgTys);
 Function *getOrCreateFunction(Module *M, Type *RetTy, ArrayRef<Type *> ArgTypes,
@@ -584,10 +578,6 @@ Function *getOrCreateFunction(Module *M, Type *RetTy, ArrayRef<Type *> ArgTypes,
                               AttributeList *Attrs = nullptr,
                               bool TakeName = true);
 
-PointerType *getOCLClkEventType(Module *M);
-PointerType *getOCLClkEventPtrType(Module *M);
-Constant *getOCLNullClkEventPtr(Module *M);
-
 /// Get function call arguments.
 /// \param Start Starting index.
 /// \param End Ending index.
@@ -736,11 +726,6 @@ CallInst *addCallInstSPIRV(Module *M, StringRef FuncName, Type *RetTy,
                            ArrayRef<Type *> PointerElementTypes,
                            Instruction *Pos, StringRef InstName);
 
-/// Add a call of spir_block_bind function.
-CallInst *addBlockBind(Module *M, Function *InvokeFunc, Value *BlkCtx,
-                       Value *CtxLen, Value *CtxAlign, Instruction *InsPos,
-                       StringRef InstName = SPIR_TEMP_NAME_PREFIX_BLOCK);
-
 typedef std::pair<std::vector<Value *>::iterator,
                   std::vector<Value *>::iterator>
     ValueVecRange;
@@ -858,11 +843,6 @@ std::string getSPIRVTypeName(StringRef BaseTyName, StringRef Postfixes = "");
 /// Checks if given type name is either ConstantSampler or ConsantPipeStorage.
 bool isSPIRVConstantName(StringRef TyName);
 
-/// Get the postfixes of SPIR-V image type name as in spirv.Image.postfixes.
-std::string getSPIRVImageTypePostfixes(StringRef SampledType,
-                                       SPIRVTypeImageDescriptor Desc,
-                                       SPIRVAccessQualifierKind Acc);
-
 /// Get the sampled type name used in postfix of image type in SPIR-V
 /// friendly LLVM IR.
 std::string getSPIRVImageSampledTypeName(SPIRVType *Ty);
@@ -871,16 +851,16 @@ std::string getSPIRVImageSampledTypeName(SPIRVType *Ty);
 Type *getLLVMTypeForSPIRVImageSampledTypePostfix(StringRef Postfix,
                                                  LLVMContext &Ctx);
 
+/// Convert an LLVM type to a string postfix name.
+std::string convertTypeToPostfix(Type *T);
+
 /// Return the unqualified and unsuffixed base name of an image type.
 /// E.g. opencl.image2d_ro_t.3 -> image2d_t
 std::string getImageBaseTypeName(StringRef Name);
 
 /// Extract the image type descriptor from the given image type.
 SPIRVTypeImageDescriptor getImageDescriptor(Type *Ty);
 
-/// Map OpenCL opaque type name to SPIR-V type name.
-std::string mapOCLTypeNameToSPIRV(StringRef Name, StringRef Acc = "");
-
 /// Check if access qualifier is encoded in the type name.
 bool hasAccessQualifiedName(StringRef TyName);
 
@@ -890,9 +870,6 @@ SPIRVAccessQualifierKind getAccessQualifier(StringRef TyName);
 /// Get access qualifier from the type name.
 StringRef getAccessQualifierPostfix(SPIRVAccessQualifierKind Access);
 
-/// Get access qualifier from the type name.
-StringRef getAccessQualifierFullName(StringRef TyName);
-
 bool eraseUselessFunctions(Module *M);
 
 /// Erase a function if it is declaration, has internal linkage and has no use.
@@ -978,6 +955,7 @@ template <> inline void SPIRVMap<std::string, Op, SPIRVOpaqueType>::init() {
   _SPIRV_OP(ReserveId)
   _SPIRV_OP(Sampler)
   _SPIRV_OP(SampledImage)
+  _SPIRV_OP(PipeStorage)
   // SPV_INTEL_device_side_avc_motion_estimation types
   _SPIRV_OP(AvcMcePayloadINTEL)
   _SPIRV_OP(AvcImePayloadINTEL)
@@ -991,7 +969,9 @@ template <> inline void SPIRVMap<std::string, Op, SPIRVOpaqueType>::init() {
   _SPIRV_OP(AvcImeDualReferenceStreaminINTEL)
   _SPIRV_OP(AvcRefResultINTEL)
   _SPIRV_OP(AvcSicResultINTEL)
+  _SPIRV_OP(VmeImageINTEL)
 #undef _SPIRV_OP
+  add("JointMatrixINTEL", internal::OpTypeJointMatrixINTEL);
 }
 
 // Check if the module contains llvm.loop.* metadata